blob: 44b0791b0a2e378d1ad20e390cbfbec981e7fad8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/slab.h>
15#include <linux/init.h>
16#include <linux/unistd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/module.h>
18#include <linux/vmalloc.h>
19#include <linux/completion.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/personality.h>
21#include <linux/mempolicy.h>
22#include <linux/sem.h>
23#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040024#include <linux/fdtable.h>
Jens Axboeda9cbc82008-06-30 20:42:08 +020025#include <linux/iocontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/key.h>
27#include <linux/binfmts.h>
28#include <linux/mman.h>
Andrea Arcangelicddb8a52008-07-28 15:46:29 -070029#include <linux/mmu_notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/fs.h>
Serge E. Hallynab516012006-10-02 02:18:06 -070031#include <linux/nsproxy.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080032#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/cpu.h>
Paul Menageb4f48b62007-10-18 23:39:33 -070034#include <linux/cgroup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/security.h>
Mel Gormana1e78772008-07-23 21:27:23 -070036#include <linux/hugetlb.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/swap.h>
38#include <linux/syscalls.h>
39#include <linux/jiffies.h>
Roland McGrath09a05392008-07-25 19:45:47 -070040#include <linux/tracehook.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/futex.h>
Linus Torvalds8141c7f2008-11-15 10:20:36 -080042#include <linux/compat.h>
Andrew Morton7c3ab732006-12-10 02:19:19 -080043#include <linux/task_io_accounting_ops.h>
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -070044#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/ptrace.h>
46#include <linux/mount.h>
47#include <linux/audit.h>
Pavel Emelianov78fb7462008-02-07 00:13:51 -080048#include <linux/memcontrol.h>
Frederic Weisbeckerf201ae22008-11-23 06:22:56 +010049#include <linux/ftrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/profile.h>
51#include <linux/rmap.h>
Hugh Dickinsf8af4da2009-09-21 17:01:57 -070052#include <linux/ksm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/acct.h>
Jay Lan8f0ab512006-09-30 23:28:59 -070054#include <linux/tsacct_kern.h>
Matt Helsley9f460802005-11-07 00:59:16 -080055#include <linux/cn_proc.h>
Rafael J. Wysockiba96a0c2007-05-23 13:57:25 -070056#include <linux/freezer.h>
Shailabh Nagarca74e922006-07-14 00:24:36 -070057#include <linux/delayacct.h>
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -070058#include <linux/taskstats_kern.h>
Arjan van de Ven0a425402006-09-26 10:52:38 +020059#include <linux/random.h>
Miloslav Trmac522ed772007-07-15 23:40:56 -070060#include <linux/tty.h>
Pavel Emelyanov6f4e6432007-10-18 23:40:11 -070061#include <linux/proc_fs.h>
Jens Axboefd0928d2008-01-24 08:52:45 +010062#include <linux/blkdev.h>
Al Viro5ad4e532009-03-29 19:50:06 -040063#include <linux/fs_struct.h>
Eric Sandeen7c9f8862008-04-22 16:38:23 -050064#include <linux/magic.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +020065#include <linux/perf_event.h>
Stanislaw Gruszka42c4ab42009-07-29 12:15:26 +020066#include <linux/posix-timers.h>
Avi Kivity8e7cac72009-11-29 16:34:48 +020067#include <linux/user-return-notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69#include <asm/pgtable.h>
70#include <asm/pgalloc.h>
71#include <asm/uaccess.h>
72#include <asm/mmu_context.h>
73#include <asm/cacheflush.h>
74#include <asm/tlbflush.h>
75
Steven Rostedtad8d75f2009-04-14 19:39:12 -040076#include <trace/events/sched.h>
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078/*
79 * Protected counters by write_lock_irq(&tasklist_lock)
80 */
81unsigned long total_forks; /* Handle normal Linux uptimes. */
82int nr_threads; /* The idle threads do not count.. */
83
84int max_threads; /* tunable limit on nr_threads */
85
86DEFINE_PER_CPU(unsigned long, process_counts) = 0;
87
Christoph Hellwigc59923a2006-07-10 04:45:40 -070088__cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
Paul E. McKenneydb1466b2010-03-03 07:46:56 -080089
90#ifdef CONFIG_PROVE_RCU
91int lockdep_tasklist_lock_is_held(void)
92{
93 return lockdep_is_held(&tasklist_lock);
94}
95EXPORT_SYMBOL_GPL(lockdep_tasklist_lock_is_held);
96#endif /* #ifdef CONFIG_PROVE_RCU */
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98int nr_processes(void)
99{
100 int cpu;
101 int total = 0;
102
Ian Campbell1d510752009-11-03 10:11:14 +0000103 for_each_possible_cpu(cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 total += per_cpu(process_counts, cpu);
105
106 return total;
107}
108
109#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
110# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
111# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))
Christoph Lametere18b8902006-12-06 20:33:20 -0800112static struct kmem_cache *task_struct_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#endif
114
FUJITA Tomonorib69c49b2008-07-25 01:45:40 -0700115#ifndef __HAVE_ARCH_THREAD_INFO_ALLOCATOR
116static inline struct thread_info *alloc_thread_info(struct task_struct *tsk)
117{
118#ifdef CONFIG_DEBUG_STACK_USAGE
119 gfp_t mask = GFP_KERNEL | __GFP_ZERO;
120#else
121 gfp_t mask = GFP_KERNEL;
122#endif
123 return (struct thread_info *)__get_free_pages(mask, THREAD_SIZE_ORDER);
124}
125
126static inline void free_thread_info(struct thread_info *ti)
127{
128 free_pages((unsigned long)ti, THREAD_SIZE_ORDER);
129}
130#endif
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132/* SLAB cache for signal_struct structures (tsk->signal) */
Christoph Lametere18b8902006-12-06 20:33:20 -0800133static struct kmem_cache *signal_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135/* SLAB cache for sighand_struct structures (tsk->sighand) */
Christoph Lametere18b8902006-12-06 20:33:20 -0800136struct kmem_cache *sighand_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138/* SLAB cache for files_struct structures (tsk->files) */
Christoph Lametere18b8902006-12-06 20:33:20 -0800139struct kmem_cache *files_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
141/* SLAB cache for fs_struct structures (tsk->fs) */
Christoph Lametere18b8902006-12-06 20:33:20 -0800142struct kmem_cache *fs_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144/* SLAB cache for vm_area_struct structures */
Christoph Lametere18b8902006-12-06 20:33:20 -0800145struct kmem_cache *vm_area_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147/* SLAB cache for mm_struct structures (tsk->mm) */
Christoph Lametere18b8902006-12-06 20:33:20 -0800148static struct kmem_cache *mm_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
KOSAKI Motohiroc6a7f572009-09-21 17:01:32 -0700150static void account_kernel_stack(struct thread_info *ti, int account)
151{
152 struct zone *zone = page_zone(virt_to_page(ti));
153
154 mod_zone_page_state(zone, NR_KERNEL_STACK, account);
155}
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157void free_task(struct task_struct *tsk)
158{
Peter Zijlstra3e26c142007-10-16 23:25:50 -0700159 prop_local_destroy_single(&tsk->dirties);
KOSAKI Motohiroc6a7f572009-09-21 17:01:32 -0700160 account_kernel_stack(tsk->stack, -1);
Roman Zippelf7e42172007-05-09 02:35:17 -0700161 free_thread_info(tsk->stack);
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700162 rt_mutex_debug_task_free(tsk);
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100163 ftrace_graph_exit_task(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 free_task_struct(tsk);
165}
166EXPORT_SYMBOL(free_task);
167
Andrew Morton158d9eb2006-03-31 02:31:34 -0800168void __put_task_struct(struct task_struct *tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
Eugene Teo270f7222007-10-18 23:40:38 -0700170 WARN_ON(!tsk->exit_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 WARN_ON(atomic_read(&tsk->usage));
172 WARN_ON(tsk == current);
173
David Howellse0e81732009-09-02 09:13:40 +0100174 exit_creds(tsk);
Shailabh Nagar35df17c2006-08-31 21:27:38 -0700175 delayacct_tsk_free(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 if (!profile_handoff_task(tsk))
178 free_task(tsk);
179}
180
Suresh Siddha2adee9b2008-04-16 10:25:35 +0200181/*
182 * macro override instead of weak attribute alias, to workaround
183 * gcc 4.1.0 and 4.1.1 bugs with weak attribute and empty functions.
184 */
185#ifndef arch_task_cache_init
186#define arch_task_cache_init()
187#endif
Suresh Siddha61c46282008-03-10 15:28:04 -0700188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189void __init fork_init(unsigned long mempages)
190{
191#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
192#ifndef ARCH_MIN_TASKALIGN
193#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES
194#endif
195 /* create a slab on which task_structs can be allocated */
196 task_struct_cachep =
197 kmem_cache_create("task_struct", sizeof(struct task_struct),
Vegard Nossum2dff4402008-05-31 15:56:17 +0200198 ARCH_MIN_TASKALIGN, SLAB_PANIC | SLAB_NOTRACK, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199#endif
200
Suresh Siddha61c46282008-03-10 15:28:04 -0700201 /* do the arch specific task caches init */
202 arch_task_cache_init();
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 /*
205 * The default maximum number of threads is set to a safe
206 * value: the thread structures can take up at most half
207 * of memory.
208 */
209 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
210
211 /*
212 * we need to allow at least 20 threads to boot a system
213 */
214 if(max_threads < 20)
215 max_threads = 20;
216
217 init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
218 init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
219 init_task.signal->rlim[RLIMIT_SIGPENDING] =
220 init_task.signal->rlim[RLIMIT_NPROC];
221}
222
Suresh Siddha61c46282008-03-10 15:28:04 -0700223int __attribute__((weak)) arch_dup_task_struct(struct task_struct *dst,
224 struct task_struct *src)
225{
226 *dst = *src;
227 return 0;
228}
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230static struct task_struct *dup_task_struct(struct task_struct *orig)
231{
232 struct task_struct *tsk;
233 struct thread_info *ti;
Eric Sandeen7c9f8862008-04-22 16:38:23 -0500234 unsigned long *stackend;
235
Peter Zijlstra3e26c142007-10-16 23:25:50 -0700236 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 prepare_to_copy(orig);
239
240 tsk = alloc_task_struct();
241 if (!tsk)
242 return NULL;
243
244 ti = alloc_thread_info(tsk);
245 if (!ti) {
246 free_task_struct(tsk);
247 return NULL;
248 }
249
Suresh Siddha61c46282008-03-10 15:28:04 -0700250 err = arch_dup_task_struct(tsk, orig);
251 if (err)
252 goto out;
253
Roman Zippelf7e42172007-05-09 02:35:17 -0700254 tsk->stack = ti;
Peter Zijlstra3e26c142007-10-16 23:25:50 -0700255
256 err = prop_local_init_single(&tsk->dirties);
Suresh Siddha61c46282008-03-10 15:28:04 -0700257 if (err)
258 goto out;
Peter Zijlstra3e26c142007-10-16 23:25:50 -0700259
Al Viro10ebffd2005-11-13 16:06:56 -0800260 setup_thread_stack(tsk, orig);
Avi Kivity8e7cac72009-11-29 16:34:48 +0200261 clear_user_return_notifier(tsk);
Eric Sandeen7c9f8862008-04-22 16:38:23 -0500262 stackend = end_of_stack(tsk);
263 *stackend = STACK_END_MAGIC; /* for overflow detection */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Arjan van de Ven0a425402006-09-26 10:52:38 +0200265#ifdef CONFIG_CC_STACKPROTECTOR
266 tsk->stack_canary = get_random_int();
267#endif
268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 /* One for us, one for whoever does the "release_task()" (usually parent) */
270 atomic_set(&tsk->usage,2);
Giancarlo Formicuccia4b5d37a2005-09-09 13:01:22 -0700271 atomic_set(&tsk->fs_excl, 0);
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -0700272#ifdef CONFIG_BLK_DEV_IO_TRACE
Jens Axboe2056a782006-03-23 20:00:26 +0100273 tsk->btrace_seq = 0;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -0700274#endif
Jens Axboea0aa7f62006-04-20 13:05:33 +0200275 tsk->splice_pipe = NULL;
KOSAKI Motohiroc6a7f572009-09-21 17:01:32 -0700276
277 account_kernel_stack(ti, 1);
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return tsk;
Suresh Siddha61c46282008-03-10 15:28:04 -0700280
281out:
282 free_thread_info(ti);
283 free_task_struct(tsk);
284 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285}
286
287#ifdef CONFIG_MMU
Alexey Dobriyana39bc512007-10-18 23:41:10 -0700288static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700290 struct vm_area_struct *mpnt, *tmp, **pprev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 struct rb_node **rb_link, *rb_parent;
292 int retval;
293 unsigned long charge;
294 struct mempolicy *pol;
295
296 down_write(&oldmm->mmap_sem);
Ralf Baechleec8c0442006-12-12 17:14:57 +0000297 flush_cache_dup_mm(oldmm);
Ingo Molnarad339452006-07-03 00:25:15 -0700298 /*
299 * Not linked in yet - no deadlock potential:
300 */
301 down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
Hugh Dickins7ee78232005-10-29 18:16:08 -0700302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 mm->locked_vm = 0;
304 mm->mmap = NULL;
305 mm->mmap_cache = NULL;
306 mm->free_area_cache = oldmm->mmap_base;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700307 mm->cached_hole_size = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 mm->map_count = 0;
Rusty Russell94894242009-03-30 22:05:12 -0600309 cpumask_clear(mm_cpumask(mm));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 mm->mm_rb = RB_ROOT;
311 rb_link = &mm->mm_rb.rb_node;
312 rb_parent = NULL;
313 pprev = &mm->mmap;
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700314 retval = ksm_fork(mm, oldmm);
315 if (retval)
316 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700318 for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 struct file *file;
320
321 if (mpnt->vm_flags & VM_DONTCOPY) {
Hugh Dickins3b6bfcd2005-07-12 13:58:09 -0700322 long pages = vma_pages(mpnt);
323 mm->total_vm -= pages;
Hugh Dickinsab50b8e2005-10-29 18:15:56 -0700324 vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
Hugh Dickins3b6bfcd2005-07-12 13:58:09 -0700325 -pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 continue;
327 }
328 charge = 0;
329 if (mpnt->vm_flags & VM_ACCOUNT) {
330 unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
331 if (security_vm_enough_memory(len))
332 goto fail_nomem;
333 charge = len;
334 }
Christoph Lametere94b1762006-12-06 20:33:17 -0800335 tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 if (!tmp)
337 goto fail_nomem;
338 *tmp = *mpnt;
Rik van Riel5beb4932010-03-05 13:42:07 -0800339 INIT_LIST_HEAD(&tmp->anon_vma_chain);
Lee Schermerhorn846a16b2008-04-28 02:13:09 -0700340 pol = mpol_dup(vma_policy(mpnt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 retval = PTR_ERR(pol);
342 if (IS_ERR(pol))
343 goto fail_nomem_policy;
344 vma_set_policy(tmp, pol);
Rik van Riel5beb4932010-03-05 13:42:07 -0800345 if (anon_vma_fork(tmp, mpnt))
346 goto fail_nomem_anon_vma_fork;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 tmp->vm_flags &= ~VM_LOCKED;
348 tmp->vm_mm = mm;
349 tmp->vm_next = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 file = tmp->vm_file;
351 if (file) {
Josef "Jeff" Sipekf3a43f32006-12-08 02:36:43 -0800352 struct inode *inode = file->f_path.dentry->d_inode;
Hugh Dickinsb88ed202008-12-10 20:48:52 +0000353 struct address_space *mapping = file->f_mapping;
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 get_file(file);
356 if (tmp->vm_flags & VM_DENYWRITE)
357 atomic_dec(&inode->i_writecount);
Hugh Dickinsb88ed202008-12-10 20:48:52 +0000358 spin_lock(&mapping->i_mmap_lock);
359 if (tmp->vm_flags & VM_SHARED)
360 mapping->i_mmap_writable++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 tmp->vm_truncate_count = mpnt->vm_truncate_count;
Hugh Dickinsb88ed202008-12-10 20:48:52 +0000362 flush_dcache_mmap_lock(mapping);
363 /* insert tmp into the share list, just after mpnt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 vma_prio_tree_add(tmp, mpnt);
Hugh Dickinsb88ed202008-12-10 20:48:52 +0000365 flush_dcache_mmap_unlock(mapping);
366 spin_unlock(&mapping->i_mmap_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 }
368
369 /*
Mel Gormana1e78772008-07-23 21:27:23 -0700370 * Clear hugetlb-related page reserves for children. This only
371 * affects MAP_PRIVATE mappings. Faults generated by the child
372 * are not guaranteed to succeed, even if read-only
373 */
374 if (is_vm_hugetlb_page(tmp))
375 reset_vma_resv_huge_pages(tmp);
376
377 /*
Hugh Dickins7ee78232005-10-29 18:16:08 -0700378 * Link in the new vma and copy the page table entries.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 *pprev = tmp;
381 pprev = &tmp->vm_next;
382
383 __vma_link_rb(mm, tmp, rb_link, rb_parent);
384 rb_link = &tmp->vm_rb.rb_right;
385 rb_parent = &tmp->vm_rb;
386
387 mm->map_count++;
Hugh Dickins0b0db142005-11-21 21:32:20 -0800388 retval = copy_page_range(mm, oldmm, mpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 if (tmp->vm_ops && tmp->vm_ops->open)
391 tmp->vm_ops->open(tmp);
392
393 if (retval)
394 goto out;
395 }
Jeremy Fitzhardinged6dd61c2007-05-02 19:27:14 +0200396 /* a new mm has just been created */
397 arch_dup_mmap(oldmm, mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399out:
Hugh Dickins7ee78232005-10-29 18:16:08 -0700400 up_write(&mm->mmap_sem);
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700401 flush_tlb_mm(oldmm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 up_write(&oldmm->mmap_sem);
403 return retval;
Rik van Riel5beb4932010-03-05 13:42:07 -0800404fail_nomem_anon_vma_fork:
405 mpol_put(pol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406fail_nomem_policy:
407 kmem_cache_free(vm_area_cachep, tmp);
408fail_nomem:
409 retval = -ENOMEM;
410 vm_unacct_memory(charge);
411 goto out;
412}
413
414static inline int mm_alloc_pgd(struct mm_struct * mm)
415{
416 mm->pgd = pgd_alloc(mm);
417 if (unlikely(!mm->pgd))
418 return -ENOMEM;
419 return 0;
420}
421
422static inline void mm_free_pgd(struct mm_struct * mm)
423{
Benjamin Herrenschmidt5e541972008-02-04 22:29:14 -0800424 pgd_free(mm, mm->pgd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425}
426#else
427#define dup_mmap(mm, oldmm) (0)
428#define mm_alloc_pgd(mm) (0)
429#define mm_free_pgd(mm)
430#endif /* CONFIG_MMU */
431
Daniel Walker23ff4442007-10-18 03:06:07 -0700432__cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
Christoph Lametere94b1762006-12-06 20:33:17 -0800434#define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
436
Hidehiro Kawai4cb0e112009-01-06 14:42:47 -0800437static unsigned long default_dump_filter = MMF_DUMP_FILTER_DEFAULT;
438
439static int __init coredump_filter_setup(char *s)
440{
441 default_dump_filter =
442 (simple_strtoul(s, NULL, 0) << MMF_DUMP_FILTER_SHIFT) &
443 MMF_DUMP_FILTER_MASK;
444 return 1;
445}
446
447__setup("coredump_filter=", coredump_filter_setup);
448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449#include <linux/init_task.h>
450
Alexey Dobriyan858f0992009-09-23 15:57:32 -0700451static void mm_init_aio(struct mm_struct *mm)
452{
453#ifdef CONFIG_AIO
454 spin_lock_init(&mm->ioctx_lock);
455 INIT_HLIST_HEAD(&mm->ioctx_list);
456#endif
457}
458
Pavel Emelianov78fb7462008-02-07 00:13:51 -0800459static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
461 atomic_set(&mm->mm_users, 1);
462 atomic_set(&mm->mm_count, 1);
463 init_rwsem(&mm->mmap_sem);
464 INIT_LIST_HEAD(&mm->mmlist);
Hugh Dickinsf8af4da2009-09-21 17:01:57 -0700465 mm->flags = (current->mm) ?
466 (current->mm->flags & MMF_INIT_MASK) : default_dump_filter;
Oleg Nesterov999d9fc2008-07-25 01:47:41 -0700467 mm->core_state = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 mm->nr_ptes = 0;
KAMEZAWA Hiroyukid559db02010-03-05 13:41:39 -0800469 memset(&mm->rss_stat, 0, sizeof(mm->rss_stat));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 spin_lock_init(&mm->page_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 mm->free_area_cache = TASK_UNMAPPED_BASE;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700472 mm->cached_hole_size = ~0UL;
Alexey Dobriyan858f0992009-09-23 15:57:32 -0700473 mm_init_aio(mm);
Balbir Singhcf475ad2008-04-29 01:00:16 -0700474 mm_init_owner(mm, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476 if (likely(!mm_alloc_pgd(mm))) {
477 mm->def_flags = 0;
Andrea Arcangelicddb8a52008-07-28 15:46:29 -0700478 mmu_notifier_mm_init(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 return mm;
480 }
Pavel Emelianov78fb7462008-02-07 00:13:51 -0800481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 free_mm(mm);
483 return NULL;
484}
485
486/*
487 * Allocate and initialize an mm_struct.
488 */
489struct mm_struct * mm_alloc(void)
490{
491 struct mm_struct * mm;
492
493 mm = allocate_mm();
494 if (mm) {
495 memset(mm, 0, sizeof(*mm));
Pavel Emelianov78fb7462008-02-07 00:13:51 -0800496 mm = mm_init(mm, current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 }
498 return mm;
499}
500
501/*
502 * Called when the last reference to the mm
503 * is dropped: either by a lazy thread or by
504 * mmput. Free the page directory and the mm.
505 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800506void __mmdrop(struct mm_struct *mm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507{
508 BUG_ON(mm == &init_mm);
509 mm_free_pgd(mm);
510 destroy_context(mm);
Andrea Arcangelicddb8a52008-07-28 15:46:29 -0700511 mmu_notifier_mm_destroy(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 free_mm(mm);
513}
Avi Kivity6d4e4c42007-11-21 16:41:05 +0200514EXPORT_SYMBOL_GPL(__mmdrop);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516/*
517 * Decrement the use count and release all resources for an mm.
518 */
519void mmput(struct mm_struct *mm)
520{
Andrew Morton0ae26f12006-06-23 02:05:15 -0700521 might_sleep();
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (atomic_dec_and_test(&mm->mm_users)) {
524 exit_aio(mm);
Andrea Arcangeli1c2fb7a2009-09-21 17:02:22 -0700525 ksm_exit(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 exit_mmap(mm);
Matt Helsley925d1c42008-04-29 01:01:36 -0700527 set_mm_exe_file(mm, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 if (!list_empty(&mm->mmlist)) {
529 spin_lock(&mmlist_lock);
530 list_del(&mm->mmlist);
531 spin_unlock(&mmlist_lock);
532 }
533 put_swap_token(mm);
Hiroshi Shimamoto801460d2009-09-23 15:57:41 -0700534 if (mm->binfmt)
535 module_put(mm->binfmt->module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 mmdrop(mm);
537 }
538}
539EXPORT_SYMBOL_GPL(mmput);
540
541/**
542 * get_task_mm - acquire a reference to the task's mm
543 *
Oleg Nesterov246bb0b2008-07-25 01:47:38 -0700544 * Returns %NULL if the task has no mm. Checks PF_KTHREAD (meaning
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 * this kernel workthread has transiently adopted a user mm with use_mm,
546 * to do its AIO) is not set and if so returns a reference to it, after
547 * bumping up the use count. User must release the mm via mmput()
548 * after use. Typically used by /proc and ptrace.
549 */
550struct mm_struct *get_task_mm(struct task_struct *task)
551{
552 struct mm_struct *mm;
553
554 task_lock(task);
555 mm = task->mm;
556 if (mm) {
Oleg Nesterov246bb0b2008-07-25 01:47:38 -0700557 if (task->flags & PF_KTHREAD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 mm = NULL;
559 else
560 atomic_inc(&mm->mm_users);
561 }
562 task_unlock(task);
563 return mm;
564}
565EXPORT_SYMBOL_GPL(get_task_mm);
566
567/* Please note the differences between mmput and mm_release.
568 * mmput is called whenever we stop holding onto a mm_struct,
569 * error success whatever.
570 *
571 * mm_release is called after a mm_struct has been removed
572 * from the current process.
573 *
574 * This difference is important for error handling, when we
575 * only half set up a mm_struct for a new process and need to restore
576 * the old one. Because we mmput the new mm_struct before
577 * restoring the old one. . .
578 * Eric Biederman 10 January 1998
579 */
580void mm_release(struct task_struct *tsk, struct mm_struct *mm)
581{
582 struct completion *vfork_done = tsk->vfork_done;
583
Linus Torvalds8141c7f2008-11-15 10:20:36 -0800584 /* Get rid of any futexes when releasing the mm */
585#ifdef CONFIG_FUTEX
Peter Zijlstrafc6b1772009-10-05 18:17:32 +0200586 if (unlikely(tsk->robust_list)) {
Linus Torvalds8141c7f2008-11-15 10:20:36 -0800587 exit_robust_list(tsk);
Peter Zijlstrafc6b1772009-10-05 18:17:32 +0200588 tsk->robust_list = NULL;
589 }
Linus Torvalds8141c7f2008-11-15 10:20:36 -0800590#ifdef CONFIG_COMPAT
Peter Zijlstrafc6b1772009-10-05 18:17:32 +0200591 if (unlikely(tsk->compat_robust_list)) {
Linus Torvalds8141c7f2008-11-15 10:20:36 -0800592 compat_exit_robust_list(tsk);
Peter Zijlstrafc6b1772009-10-05 18:17:32 +0200593 tsk->compat_robust_list = NULL;
594 }
Linus Torvalds8141c7f2008-11-15 10:20:36 -0800595#endif
Thomas Gleixner322a2c12009-10-05 18:18:03 +0200596 if (unlikely(!list_empty(&tsk->pi_state_list)))
597 exit_pi_state_list(tsk);
Linus Torvalds8141c7f2008-11-15 10:20:36 -0800598#endif
599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 /* Get rid of any cached register state */
601 deactivate_mm(tsk, mm);
602
603 /* notify parent sleeping on vfork() */
604 if (vfork_done) {
605 tsk->vfork_done = NULL;
606 complete(vfork_done);
607 }
Roland McGrathfec1d012006-12-06 20:36:34 -0800608
609 /*
610 * If we're exiting normally, clear a user-space tid field if
611 * requested. We leave this alone when dying by signal, to leave
612 * the value intact in a core dump, and to save the unnecessary
613 * trouble otherwise. Userland only wants this done for a sys_exit.
614 */
Eric Dumazet9c8a8222009-08-06 15:09:28 -0700615 if (tsk->clear_child_tid) {
616 if (!(tsk->flags & PF_SIGNALED) &&
617 atomic_read(&mm->mm_users) > 1) {
618 /*
619 * We don't check the error code - if userspace has
620 * not set up a proper pointer then tough luck.
621 */
622 put_user(0, tsk->clear_child_tid);
623 sys_futex(tsk->clear_child_tid, FUTEX_WAKE,
624 1, NULL, NULL, 0);
625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 tsk->clear_child_tid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 }
628}
629
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800630/*
631 * Allocate a new mm structure and copy contents from the
632 * mm structure of the passed in task structure.
633 */
Carsten Otte402b0862008-03-25 18:47:10 +0100634struct mm_struct *dup_mm(struct task_struct *tsk)
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800635{
636 struct mm_struct *mm, *oldmm = current->mm;
637 int err;
638
639 if (!oldmm)
640 return NULL;
641
642 mm = allocate_mm();
643 if (!mm)
644 goto fail_nomem;
645
646 memcpy(mm, oldmm, sizeof(*mm));
647
Ashwin Chaugule7602bdf2006-12-06 20:31:57 -0800648 /* Initializing for Swap token stuff */
649 mm->token_priority = 0;
650 mm->last_interval = 0;
651
Pavel Emelianov78fb7462008-02-07 00:13:51 -0800652 if (!mm_init(mm, tsk))
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800653 goto fail_nomem;
654
655 if (init_new_context(tsk, mm))
656 goto fail_nocontext;
657
Matt Helsley925d1c42008-04-29 01:01:36 -0700658 dup_mm_exe_file(oldmm, mm);
659
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800660 err = dup_mmap(mm, oldmm);
661 if (err)
662 goto free_pt;
663
664 mm->hiwater_rss = get_mm_rss(mm);
665 mm->hiwater_vm = mm->total_vm;
666
Hiroshi Shimamoto801460d2009-09-23 15:57:41 -0700667 if (mm->binfmt && !try_module_get(mm->binfmt->module))
668 goto free_pt;
669
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800670 return mm;
671
672free_pt:
Hiroshi Shimamoto801460d2009-09-23 15:57:41 -0700673 /* don't put binfmt in mmput, we haven't got module yet */
674 mm->binfmt = NULL;
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800675 mmput(mm);
676
677fail_nomem:
678 return NULL;
679
680fail_nocontext:
681 /*
682 * If init_new_context() failed, we cannot use mmput() to free the mm
683 * because it calls destroy_context()
684 */
685 mm_free_pgd(mm);
686 free_mm(mm);
687 return NULL;
688}
689
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
691{
692 struct mm_struct * mm, *oldmm;
693 int retval;
694
695 tsk->min_flt = tsk->maj_flt = 0;
696 tsk->nvcsw = tsk->nivcsw = 0;
Mandeep Singh Baines17406b82009-02-06 15:37:47 -0800697#ifdef CONFIG_DETECT_HUNG_TASK
698 tsk->last_switch_count = tsk->nvcsw + tsk->nivcsw;
699#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 tsk->mm = NULL;
702 tsk->active_mm = NULL;
703
704 /*
705 * Are we cloning a kernel thread?
706 *
707 * We need to steal a active VM for that..
708 */
709 oldmm = current->mm;
710 if (!oldmm)
711 return 0;
712
713 if (clone_flags & CLONE_VM) {
714 atomic_inc(&oldmm->mm_users);
715 mm = oldmm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 goto good_mm;
717 }
718
719 retval = -ENOMEM;
JANAK DESAIa0a7ec32006-02-07 12:59:01 -0800720 mm = dup_mm(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 if (!mm)
722 goto fail_nomem;
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724good_mm:
Ashwin Chaugule7602bdf2006-12-06 20:31:57 -0800725 /* Initializing for Swap token stuff */
726 mm->token_priority = 0;
727 mm->last_interval = 0;
728
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 tsk->mm = mm;
730 tsk->active_mm = mm;
731 return 0;
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733fail_nomem:
734 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735}
736
Alexey Dobriyana39bc512007-10-18 23:41:10 -0700737static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Al Viro498052b2009-03-30 07:20:30 -0400739 struct fs_struct *fs = current->fs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (clone_flags & CLONE_FS) {
Al Viro498052b2009-03-30 07:20:30 -0400741 /* tsk->fs is already what we want */
742 write_lock(&fs->lock);
743 if (fs->in_exec) {
744 write_unlock(&fs->lock);
745 return -EAGAIN;
746 }
747 fs->users++;
748 write_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return 0;
750 }
Al Viro498052b2009-03-30 07:20:30 -0400751 tsk->fs = copy_fs_struct(fs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 if (!tsk->fs)
753 return -ENOMEM;
754 return 0;
755}
756
JANAK DESAIa016f332006-02-07 12:59:02 -0800757static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
758{
759 struct files_struct *oldf, *newf;
760 int error = 0;
761
762 /*
763 * A background process may not have any files ...
764 */
765 oldf = current->files;
766 if (!oldf)
767 goto out;
768
769 if (clone_flags & CLONE_FILES) {
770 atomic_inc(&oldf->count);
771 goto out;
772 }
773
JANAK DESAIa016f332006-02-07 12:59:02 -0800774 newf = dup_fd(oldf, &error);
775 if (!newf)
776 goto out;
777
778 tsk->files = newf;
779 error = 0;
780out:
781 return error;
782}
783
Jens Axboefadad8782008-01-24 08:54:47 +0100784static int copy_io(unsigned long clone_flags, struct task_struct *tsk)
Jens Axboefd0928d2008-01-24 08:52:45 +0100785{
786#ifdef CONFIG_BLOCK
787 struct io_context *ioc = current->io_context;
788
789 if (!ioc)
790 return 0;
Jens Axboefadad8782008-01-24 08:54:47 +0100791 /*
792 * Share io context with parent, if CLONE_IO is set
793 */
794 if (clone_flags & CLONE_IO) {
795 tsk->io_context = ioc_task_link(ioc);
796 if (unlikely(!tsk->io_context))
797 return -ENOMEM;
798 } else if (ioprio_valid(ioc->ioprio)) {
Jens Axboefd0928d2008-01-24 08:52:45 +0100799 tsk->io_context = alloc_io_context(GFP_KERNEL, -1);
800 if (unlikely(!tsk->io_context))
801 return -ENOMEM;
802
Jens Axboefd0928d2008-01-24 08:52:45 +0100803 tsk->io_context->ioprio = ioc->ioprio;
804 }
805#endif
806 return 0;
807}
808
Alexey Dobriyana39bc512007-10-18 23:41:10 -0700809static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
811 struct sighand_struct *sig;
812
Zhaolei60348802009-01-06 14:40:46 -0800813 if (clone_flags & CLONE_SIGHAND) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 atomic_inc(&current->sighand->count);
815 return 0;
816 }
817 sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
Ingo Molnare56d0902006-01-08 01:01:37 -0800818 rcu_assign_pointer(tsk->sighand, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 if (!sig)
820 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 atomic_set(&sig->count, 1);
822 memcpy(sig->action, current->sighand->action, sizeof(sig->action));
823 return 0;
824}
825
Oleg Nesterova7e53282006-03-28 16:11:27 -0800826void __cleanup_sighand(struct sighand_struct *sighand)
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800827{
Oleg Nesterovc81addc2006-03-28 16:11:17 -0800828 if (atomic_dec_and_test(&sighand->count))
829 kmem_cache_free(sighand_cachep, sighand);
830}
831
Frank Mayharf06febc2008-09-12 09:54:39 -0700832
833/*
834 * Initialize POSIX timer handling for a thread group.
835 */
836static void posix_cpu_timers_init_group(struct signal_struct *sig)
837{
Jiri Slaby78d7d402010-03-05 13:42:54 -0800838 unsigned long cpu_limit;
839
Frank Mayharf06febc2008-09-12 09:54:39 -0700840 /* Thread group counters. */
841 thread_group_cputime_init(sig);
842
Jiri Slaby78d7d402010-03-05 13:42:54 -0800843 cpu_limit = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur);
844 if (cpu_limit != RLIM_INFINITY) {
845 sig->cputime_expires.prof_exp = secs_to_cputime(cpu_limit);
Oleg Nesterov6279a7512009-03-27 01:06:07 +0100846 sig->cputimer.running = 1;
847 }
848
Frank Mayharf06febc2008-09-12 09:54:39 -0700849 /* The timer lists. */
850 INIT_LIST_HEAD(&sig->cpu_timers[0]);
851 INIT_LIST_HEAD(&sig->cpu_timers[1]);
852 INIT_LIST_HEAD(&sig->cpu_timers[2]);
853}
854
Alexey Dobriyana39bc512007-10-18 23:41:10 -0700855static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
857 struct signal_struct *sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Oleg Nesterov4ab6c082009-08-26 14:29:24 -0700859 if (clone_flags & CLONE_THREAD)
Peter Zijlstra490dea42008-11-24 17:06:57 +0100860 return 0;
Oleg Nesterov6279a7512009-03-27 01:06:07 +0100861
Veaceslav Falicoa56704e2010-03-10 15:23:01 -0800862 sig = kmem_cache_zalloc(signal_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 tsk->signal = sig;
864 if (!sig)
865 return -ENOMEM;
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 atomic_set(&sig->count, 1);
868 atomic_set(&sig->live, 1);
869 init_waitqueue_head(&sig->wait_chldexit);
Sukadev Bhattiprolub3bfa0c2009-04-02 16:58:08 -0700870 if (clone_flags & CLONE_NEWPID)
871 sig->flags |= SIGNAL_UNKILLABLE;
Oleg Nesterovdb51aec2008-04-30 00:52:52 -0700872 sig->curr_target = tsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 init_sigpending(&sig->shared_pending);
874 INIT_LIST_HEAD(&sig->posix_timers);
875
Thomas Gleixnerc9cb2e32007-02-16 01:27:49 -0800876 hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 sig->real_timer.function = it_real_fn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 task_lock(current->group_leader);
880 memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
881 task_unlock(current->group_leader);
882
Oleg Nesterov6279a7512009-03-27 01:06:07 +0100883 posix_cpu_timers_init_group(sig);
884
Miloslav Trmac522ed772007-07-15 23:40:56 -0700885 tty_audit_fork(sig);
886
KOSAKI Motohiro28b83c52009-09-21 17:03:13 -0700887 sig->oom_adj = current->signal->oom_adj;
888
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 return 0;
890}
891
Oleg Nesterov6b3934e2006-03-28 16:11:16 -0800892void __cleanup_signal(struct signal_struct *sig)
893{
Frank Mayharf06febc2008-09-12 09:54:39 -0700894 thread_group_cputime_free(sig);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100895 tty_kref_put(sig->tty);
Oleg Nesterov6b3934e2006-03-28 16:11:16 -0800896 kmem_cache_free(signal_cachep, sig);
897}
898
Alexey Dobriyana39bc512007-10-18 23:41:10 -0700899static void copy_flags(unsigned long clone_flags, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
901 unsigned long new_flags = p->flags;
902
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700903 new_flags &= ~PF_SUPERPRIV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 new_flags |= PF_FORKNOEXEC;
Roland McGrath09a05392008-07-25 19:45:47 -0700905 new_flags |= PF_STARTING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 p->flags = new_flags;
Rafael J. Wysocki2e131892007-10-18 03:04:45 -0700907 clear_freeze_flag(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908}
909
Heiko Carstens17da2bd2009-01-14 14:14:10 +0100910SYSCALL_DEFINE1(set_tid_address, int __user *, tidptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911{
912 current->clear_child_tid = tidptr;
913
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700914 return task_pid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
916
Alexey Dobriyana39bc512007-10-18 23:41:10 -0700917static void rt_mutex_init_task(struct task_struct *p)
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700918{
Thomas Gleixner1d615482009-11-17 14:54:03 +0100919 raw_spin_lock_init(&p->pi_lock);
Zilvinas Valinskase29e1752007-03-16 13:38:34 -0800920#ifdef CONFIG_RT_MUTEXES
Thomas Gleixner1d615482009-11-17 14:54:03 +0100921 plist_head_init_raw(&p->pi_waiters, &p->pi_lock);
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700922 p->pi_blocked_on = NULL;
Ingo Molnar23f78d4a2006-06-27 02:54:53 -0700923#endif
924}
925
Balbir Singhcf475ad2008-04-29 01:00:16 -0700926#ifdef CONFIG_MM_OWNER
927void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
928{
929 mm->owner = p;
930}
931#endif /* CONFIG_MM_OWNER */
932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933/*
Frank Mayharf06febc2008-09-12 09:54:39 -0700934 * Initialize POSIX timer handling for a single task.
935 */
936static void posix_cpu_timers_init(struct task_struct *tsk)
937{
938 tsk->cputime_expires.prof_exp = cputime_zero;
939 tsk->cputime_expires.virt_exp = cputime_zero;
940 tsk->cputime_expires.sched_exp = 0;
941 INIT_LIST_HEAD(&tsk->cpu_timers[0]);
942 INIT_LIST_HEAD(&tsk->cpu_timers[1]);
943 INIT_LIST_HEAD(&tsk->cpu_timers[2]);
944}
945
946/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 * This creates a new process as a copy of the old one,
948 * but does not actually start it yet.
949 *
950 * It copies the registers, and all the appropriate
951 * parts of the process environment (as per the clone
952 * flags). The actual kick-off is left to the caller.
953 */
Ingo Molnar36c8b582006-07-03 00:25:41 -0700954static struct task_struct *copy_process(unsigned long clone_flags,
955 unsigned long stack_start,
956 struct pt_regs *regs,
957 unsigned long stack_size,
Ingo Molnar36c8b582006-07-03 00:25:41 -0700958 int __user *child_tidptr,
Roland McGrath09a05392008-07-25 19:45:47 -0700959 struct pid *pid,
960 int trace)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961{
962 int retval;
Mariusz Kozlowskia24efe62007-10-18 23:41:09 -0700963 struct task_struct *p;
Paul Menageb4f48b62007-10-18 23:39:33 -0700964 int cgroup_callbacks_done = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966 if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
967 return ERR_PTR(-EINVAL);
968
969 /*
970 * Thread groups must share signals as well, and detached threads
971 * can only be started up within the thread group.
972 */
973 if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
974 return ERR_PTR(-EINVAL);
975
976 /*
977 * Shared signal handlers imply shared VM. By way of the above,
978 * thread groups also imply shared VM. Blocking this case allows
979 * for various simplifications in other code.
980 */
981 if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
982 return ERR_PTR(-EINVAL);
983
Sukadev Bhattiprolu123be072009-09-23 15:57:20 -0700984 /*
985 * Siblings of global init remain as zombies on exit since they are
986 * not reaped by their parent (swapper). To solve this and to avoid
987 * multi-rooted process trees, prevent global and container-inits
988 * from creating siblings.
989 */
990 if ((clone_flags & CLONE_PARENT) &&
991 current->signal->flags & SIGNAL_UNKILLABLE)
992 return ERR_PTR(-EINVAL);
993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 retval = security_task_create(clone_flags);
995 if (retval)
996 goto fork_out;
997
998 retval = -ENOMEM;
999 p = dup_task_struct(current);
1000 if (!p)
1001 goto fork_out;
1002
Steven Rostedtf7e8b612009-06-02 16:39:48 -04001003 ftrace_graph_init_task(p);
1004
Peter Zijlstrabea493a2006-10-17 00:10:33 -07001005 rt_mutex_init_task(p);
1006
Ingo Molnard12c1a32008-07-14 12:09:28 +02001007#ifdef CONFIG_PROVE_LOCKING
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001008 DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
1009 DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
1010#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 retval = -EAGAIN;
David Howells3b11a1d2008-11-14 10:39:26 +11001012 if (atomic_read(&p->real_cred->user->processes) >=
Jiri Slaby78d7d402010-03-05 13:42:54 -08001013 task_rlimit(p, RLIMIT_NPROC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
Serge Hallyn18b6e042008-10-15 16:38:45 -05001015 p->real_cred->user != INIT_USER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 goto bad_fork_free;
1017 }
1018
David Howellsf1752ee2008-11-14 10:39:17 +11001019 retval = copy_creds(p, clone_flags);
1020 if (retval < 0)
1021 goto bad_fork_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
1023 /*
1024 * If multiple threads are within copy_process(), then this check
1025 * triggers too late. This doesn't hurt, the check is only there
1026 * to stop root fork bombs.
1027 */
Li Zefan04ec93f2009-02-06 08:17:19 +00001028 retval = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 if (nr_threads >= max_threads)
1030 goto bad_fork_cleanup_count;
1031
Al Viroa1261f52005-11-13 16:06:55 -08001032 if (!try_module_get(task_thread_info(p)->exec_domain->module))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 goto bad_fork_cleanup_count;
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 p->did_exec = 0;
Shailabh Nagarca74e922006-07-14 00:24:36 -07001036 delayacct_tsk_init(p); /* Must remain after dup_task_struct() */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 copy_flags(clone_flags, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 INIT_LIST_HEAD(&p->children);
1039 INIT_LIST_HEAD(&p->sibling);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -07001040 rcu_copy_process(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 p->vfork_done = NULL;
1042 spin_lock_init(&p->alloc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 init_sigpending(&p->pending);
1045
1046 p->utime = cputime_zero;
1047 p->stime = cputime_zero;
Laurent Vivier9ac52312007-10-15 17:00:19 +02001048 p->gtime = cputime_zero;
Michael Neulingc66f08b2007-10-18 03:06:34 -07001049 p->utimescaled = cputime_zero;
1050 p->stimescaled = cputime_zero;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001051#ifndef CONFIG_VIRT_CPU_ACCOUNTING
Peter Zijlstra73a2bcb2007-10-29 21:18:11 +01001052 p->prev_utime = cputime_zero;
Balbir Singh93018992007-10-30 00:26:32 +01001053 p->prev_stime = cputime_zero;
Hidetoshi Setod99ca3b2009-12-02 17:26:47 +09001054#endif
KAMEZAWA Hiroyukia3a2e762010-04-06 14:34:42 -07001055#if defined(SPLIT_RSS_COUNTING)
1056 memset(&p->rss_stat, 0, sizeof(p->rss_stat));
1057#endif
Balbir Singh172ba842007-07-09 18:52:00 +02001058
Arjan van de Ven69766752008-09-01 15:52:40 -07001059 p->default_timer_slack_ns = current->timer_slack_ns;
1060
Andrea Righi59954772008-07-27 17:29:15 +02001061 task_io_accounting_init(&p->ioac);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 acct_clear_integrals(p);
1063
Frank Mayharf06febc2008-09-12 09:54:39 -07001064 posix_cpu_timers_init(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 p->lock_depth = -1; /* -1 = no lock */
1067 do_posix_clock_monotonic_gettime(&p->start_time);
Tomas Janousek924b42d2007-07-15 23:39:42 -07001068 p->real_start_time = p->start_time;
1069 monotonic_to_bootbased(&p->real_start_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 p->io_context = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 p->audit_context = NULL;
Paul Menageb4f48b62007-10-18 23:39:33 -07001072 cgroup_fork(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073#ifdef CONFIG_NUMA
Lee Schermerhorn846a16b2008-04-28 02:13:09 -07001074 p->mempolicy = mpol_dup(p->mempolicy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (IS_ERR(p->mempolicy)) {
1076 retval = PTR_ERR(p->mempolicy);
1077 p->mempolicy = NULL;
Paul Menageb4f48b62007-10-18 23:39:33 -07001078 goto bad_fork_cleanup_cgroup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
Paul Jacksonc61afb12006-03-24 03:16:08 -08001080 mpol_fix_fork_child_flag(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081#endif
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001082#ifdef CONFIG_TRACE_IRQFLAGS
1083 p->irq_events = 0;
Russell Kingb36e4752006-08-27 12:26:34 +01001084#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
1085 p->hardirqs_enabled = 1;
1086#else
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001087 p->hardirqs_enabled = 0;
Russell Kingb36e4752006-08-27 12:26:34 +01001088#endif
Ingo Molnarde30a2b2006-07-03 00:24:42 -07001089 p->hardirq_enable_ip = 0;
1090 p->hardirq_enable_event = 0;
1091 p->hardirq_disable_ip = _THIS_IP_;
1092 p->hardirq_disable_event = 0;
1093 p->softirqs_enabled = 1;
1094 p->softirq_enable_ip = _THIS_IP_;
1095 p->softirq_enable_event = 0;
1096 p->softirq_disable_ip = 0;
1097 p->softirq_disable_event = 0;
1098 p->hardirq_context = 0;
1099 p->softirq_context = 0;
1100#endif
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001101#ifdef CONFIG_LOCKDEP
1102 p->lockdep_depth = 0; /* no locks held yet */
1103 p->curr_chain_key = 0;
1104 p->lockdep_recursion = 0;
1105#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Ingo Molnar408894e2006-01-09 15:59:20 -08001107#ifdef CONFIG_DEBUG_MUTEXES
1108 p->blocked_on = NULL; /* not blocked yet */
1109#endif
KAMEZAWA Hiroyuki569b8462009-12-15 16:47:03 -08001110#ifdef CONFIG_CGROUP_MEM_RES_CTLR
1111 p->memcg_batch.do_batch = 0;
1112 p->memcg_batch.memcg = NULL;
1113#endif
Markus Metzger0f481402009-04-03 16:43:48 +02001114
1115 p->bts = NULL;
Ingo Molnar408894e2006-01-09 15:59:20 -08001116
Stefani Seiboldd899bf72009-09-22 16:45:40 -07001117 p->stack_start = stack_start;
1118
Srivatsa Vaddagiri3c90e6e2007-11-09 22:39:39 +01001119 /* Perform scheduler related setup. Assign this task to a CPU. */
1120 sched_fork(p, clone_flags);
Peter Zijlstra6ab423e2009-05-25 14:45:27 +02001121
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001122 retval = perf_event_init_task(p);
Peter Zijlstra6ab423e2009-05-25 14:45:27 +02001123 if (retval)
1124 goto bad_fork_cleanup_policy;
Srivatsa Vaddagiri3c90e6e2007-11-09 22:39:39 +01001125
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 if ((retval = audit_alloc(p)))
David Howellsf1752ee2008-11-14 10:39:17 +11001127 goto bad_fork_cleanup_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 /* copy all the process information */
1129 if ((retval = copy_semundo(clone_flags, p)))
1130 goto bad_fork_cleanup_audit;
1131 if ((retval = copy_files(clone_flags, p)))
1132 goto bad_fork_cleanup_semundo;
1133 if ((retval = copy_fs(clone_flags, p)))
1134 goto bad_fork_cleanup_files;
1135 if ((retval = copy_sighand(clone_flags, p)))
1136 goto bad_fork_cleanup_fs;
1137 if ((retval = copy_signal(clone_flags, p)))
1138 goto bad_fork_cleanup_sighand;
1139 if ((retval = copy_mm(clone_flags, p)))
1140 goto bad_fork_cleanup_signal;
Serge E. Hallynab516012006-10-02 02:18:06 -07001141 if ((retval = copy_namespaces(clone_flags, p)))
David Howellsd84f4f92008-11-14 10:39:23 +11001142 goto bad_fork_cleanup_mm;
Jens Axboefadad8782008-01-24 08:54:47 +01001143 if ((retval = copy_io(clone_flags, p)))
Jens Axboefd0928d2008-01-24 08:52:45 +01001144 goto bad_fork_cleanup_namespaces;
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -07001145 retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 if (retval)
Jens Axboefd0928d2008-01-24 08:52:45 +01001147 goto bad_fork_cleanup_io;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Pavel Emelyanov425fb2b2007-10-18 23:40:07 -07001149 if (pid != &init_struct_pid) {
1150 retval = -ENOMEM;
Eric W. Biederman61bce0f2009-01-07 18:08:49 -08001151 pid = alloc_pid(p->nsproxy->pid_ns);
Pavel Emelyanov425fb2b2007-10-18 23:40:07 -07001152 if (!pid)
Jens Axboefd0928d2008-01-24 08:52:45 +01001153 goto bad_fork_cleanup_io;
Pavel Emelyanov6f4e6432007-10-18 23:40:11 -07001154
1155 if (clone_flags & CLONE_NEWPID) {
Eric W. Biederman61bce0f2009-01-07 18:08:49 -08001156 retval = pid_ns_prepare_proc(p->nsproxy->pid_ns);
Pavel Emelyanov6f4e6432007-10-18 23:40:11 -07001157 if (retval < 0)
1158 goto bad_fork_free_pid;
1159 }
Pavel Emelyanov425fb2b2007-10-18 23:40:07 -07001160 }
1161
1162 p->pid = pid_nr(pid);
1163 p->tgid = p->pid;
1164 if (clone_flags & CLONE_THREAD)
1165 p->tgid = current->tgid;
1166
Serge E. Hallyne885dcd2008-07-25 01:47:06 -07001167 if (current->nsproxy != p->nsproxy) {
1168 retval = ns_cgroup_clone(p, pid);
1169 if (retval)
Steven Rostedtf7e8b612009-06-02 16:39:48 -04001170 goto bad_fork_free_pid;
Serge E. Hallyne885dcd2008-07-25 01:47:06 -07001171 }
1172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1174 /*
1175 * Clear TID on mm_release()?
1176 */
1177 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001178#ifdef CONFIG_FUTEX
Ingo Molnar8f17d3a2006-03-27 01:16:27 -08001179 p->robust_list = NULL;
1180#ifdef CONFIG_COMPAT
1181 p->compat_robust_list = NULL;
1182#endif
Ingo Molnarc87e2832006-06-27 02:54:58 -07001183 INIT_LIST_HEAD(&p->pi_state_list);
1184 p->pi_state_cache = NULL;
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -07001185#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 /*
GOTO Masanorif9a38792006-03-13 21:20:44 -08001187 * sigaltstack should be cleared when sharing the same VM
1188 */
1189 if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
1190 p->sas_ss_sp = p->sas_ss_size = 0;
1191
1192 /*
Oleg Nesterov65808072009-12-15 16:47:16 -08001193 * Syscall tracing and stepping should be turned off in the
1194 * child regardless of CLONE_PTRACE.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 */
Oleg Nesterov65808072009-12-15 16:47:16 -08001196 user_disable_single_step(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
Laurent Viviered75e8d2005-09-03 15:57:18 -07001198#ifdef TIF_SYSCALL_EMU
1199 clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
1200#endif
Arjan van de Ven97455122008-01-25 21:08:34 +01001201 clear_all_latency_tracing(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 /* ok, now we should be set up.. */
1204 p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
1205 p->pdeath_signal = 0;
1206 p->exit_state = 0;
1207
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 /*
1209 * Ok, make it visible to the rest of the system.
1210 * We dont wake it up yet.
1211 */
1212 p->group_leader = p;
Oleg Nesterov47e65322006-03-28 16:11:25 -08001213 INIT_LIST_HEAD(&p->thread_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
Paul Menageb4f48b62007-10-18 23:39:33 -07001215 /* Now that the task is set up, run cgroup callbacks if
1216 * necessary. We need to run them before the task is visible
1217 * on the tasklist. */
1218 cgroup_fork_callbacks(p);
1219 cgroup_callbacks_done = 1;
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 /* Need tasklist lock for parent etc handling! */
1222 write_lock_irq(&tasklist_lock);
1223
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 /* CLONE_PARENT re-uses the old parent */
Oleg Nesterov2d5516c2009-03-02 22:58:45 +01001225 if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 p->real_parent = current->real_parent;
Oleg Nesterov2d5516c2009-03-02 22:58:45 +01001227 p->parent_exec_id = current->parent_exec_id;
1228 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 p->real_parent = current;
Oleg Nesterov2d5516c2009-03-02 22:58:45 +01001230 p->parent_exec_id = current->self_exec_id;
1231 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
Oleg Nesterov3f17da62006-02-15 22:13:24 +03001233 spin_lock(&current->sighand->siglock);
Oleg Nesterov4a2c7a72006-03-28 16:11:26 -08001234
1235 /*
1236 * Process group and session signals need to be delivered to just the
1237 * parent before the fork or both the parent and the child after the
1238 * fork. Restart if a signal comes in before we add the new process to
1239 * it's process group.
1240 * A fatal signal pending means that current will exit, so the new
1241 * thread can't slip out of an OOM kill (or normal SIGKILL).
1242 */
Daniel Walker23ff4442007-10-18 03:06:07 -07001243 recalc_sigpending();
Oleg Nesterov4a2c7a72006-03-28 16:11:26 -08001244 if (signal_pending(current)) {
1245 spin_unlock(&current->sighand->siglock);
1246 write_unlock_irq(&tasklist_lock);
1247 retval = -ERESTARTNOINTR;
Steven Rostedtf7e8b612009-06-02 16:39:48 -04001248 goto bad_fork_free_pid;
Oleg Nesterov4a2c7a72006-03-28 16:11:26 -08001249 }
1250
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 if (clone_flags & CLONE_THREAD) {
Oleg Nesterov4ab6c082009-08-26 14:29:24 -07001252 atomic_inc(&current->signal->count);
1253 atomic_inc(&current->signal->live);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 p->group_leader = current->group_leader;
Oleg Nesterov47e65322006-03-28 16:11:25 -08001255 list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 }
1257
Oleg Nesterov73b9ebf2006-03-28 16:11:07 -08001258 if (likely(p->pid)) {
Roland McGrath09a05392008-07-25 19:45:47 -07001259 tracehook_finish_clone(p, clone_flags, trace);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Oleg Nesterov73b9ebf2006-03-28 16:11:07 -08001261 if (thread_group_leader(p)) {
Eric W. Biederman5cd17562007-12-04 23:45:04 -08001262 if (clone_flags & CLONE_NEWPID)
Pavel Emelyanov30e49c22007-10-18 23:40:10 -07001263 p->nsproxy->pid_ns->child_reaper = p;
Oleg Nesterovc97d9892006-03-28 16:11:06 -08001264
Oleg Nesterovfea9d172008-02-08 04:19:19 -08001265 p->signal->leader_pid = pid;
Alan Cox9c9f4de2008-10-13 10:37:26 +01001266 tty_kref_put(p->signal->tty);
1267 p->signal->tty = tty_kref_get(current->signal->tty);
Eric W. Biederman5cd17562007-12-04 23:45:04 -08001268 attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
1269 attach_pid(p, PIDTYPE_SID, task_session(current));
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -08001270 list_add_tail(&p->sibling, &p->real_parent->children);
Eric W. Biederman5e85d4a2006-04-18 22:20:16 -07001271 list_add_tail_rcu(&p->tasks, &init_task.tasks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 __get_cpu_var(process_counts)++;
Oleg Nesterov73b9ebf2006-03-28 16:11:07 -08001273 }
Sukadev Bhattiprolu85868992007-05-10 22:23:03 -07001274 attach_pid(p, PIDTYPE_PID, pid);
Oleg Nesterov73b9ebf2006-03-28 16:11:07 -08001275 nr_threads++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 }
1277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 total_forks++;
Oleg Nesterov3f17da62006-02-15 22:13:24 +03001279 spin_unlock(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 write_unlock_irq(&tasklist_lock);
Andrew Mortonc13cf852005-11-28 13:43:48 -08001281 proc_fork_connector(p);
Paul Menage817929e2007-10-18 23:39:36 -07001282 cgroup_post_fork(p);
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001283 perf_event_fork(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 return p;
1285
Pavel Emelyanov425fb2b2007-10-18 23:40:07 -07001286bad_fork_free_pid:
1287 if (pid != &init_struct_pid)
1288 free_pid(pid);
Jens Axboefd0928d2008-01-24 08:52:45 +01001289bad_fork_cleanup_io:
Louis Rillingb69f2292009-12-04 14:52:42 +01001290 if (p->io_context)
1291 exit_io_context(p);
Serge E. Hallynab516012006-10-02 02:18:06 -07001292bad_fork_cleanup_namespaces:
Linus Torvalds444f3782007-01-30 13:35:18 -08001293 exit_task_namespaces(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294bad_fork_cleanup_mm:
1295 if (p->mm)
1296 mmput(p->mm);
1297bad_fork_cleanup_signal:
Oleg Nesterov4ab6c082009-08-26 14:29:24 -07001298 if (!(clone_flags & CLONE_THREAD))
1299 __cleanup_signal(p->signal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300bad_fork_cleanup_sighand:
Oleg Nesterova7e53282006-03-28 16:11:27 -08001301 __cleanup_sighand(p->sighand);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302bad_fork_cleanup_fs:
1303 exit_fs(p); /* blocking */
1304bad_fork_cleanup_files:
1305 exit_files(p); /* blocking */
1306bad_fork_cleanup_semundo:
1307 exit_sem(p);
1308bad_fork_cleanup_audit:
1309 audit_free(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310bad_fork_cleanup_policy:
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001311 perf_event_free_task(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312#ifdef CONFIG_NUMA
Lee Schermerhornf0be3d32008-04-28 02:13:08 -07001313 mpol_put(p->mempolicy);
Paul Menageb4f48b62007-10-18 23:39:33 -07001314bad_fork_cleanup_cgroup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315#endif
Paul Menageb4f48b62007-10-18 23:39:33 -07001316 cgroup_exit(p, cgroup_callbacks_done);
Shailabh Nagar35df17c2006-08-31 21:27:38 -07001317 delayacct_tsk_free(p);
Al Viroa1261f52005-11-13 16:06:55 -08001318 module_put(task_thread_info(p)->exec_domain->module);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319bad_fork_cleanup_count:
David Howellsd84f4f92008-11-14 10:39:23 +11001320 atomic_dec(&p->cred->user->processes);
David Howellse0e81732009-09-02 09:13:40 +01001321 exit_creds(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322bad_fork_free:
1323 free_task(p);
Oleg Nesterovfe7d37d2006-01-08 01:04:02 -08001324fork_out:
1325 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326}
1327
Adrian Bunk6b2fb3c2008-02-06 01:37:55 -08001328noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329{
1330 memset(regs, 0, sizeof(struct pt_regs));
1331 return regs;
1332}
1333
Al Viro9abcf402007-02-01 13:52:48 +00001334struct task_struct * __cpuinit fork_idle(int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335{
Ingo Molnar36c8b582006-07-03 00:25:41 -07001336 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 struct pt_regs regs;
1338
Pavel Emelyanov30e49c22007-10-18 23:40:10 -07001339 task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,
Roland McGrath09a05392008-07-25 19:45:47 -07001340 &init_struct_pid, 0);
Akinobu Mita753ca4f2006-11-25 11:09:34 -08001341 if (!IS_ERR(task))
1342 init_idle(task, cpu);
Oleg Nesterov73b9ebf2006-03-28 16:11:07 -08001343
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 return task;
1345}
1346
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347/*
1348 * Ok, this is the main fork-routine.
1349 *
1350 * It copies the process, and if successful kick-starts
1351 * it and waits for it to finish using the VM if required.
1352 */
1353long do_fork(unsigned long clone_flags,
1354 unsigned long stack_start,
1355 struct pt_regs *regs,
1356 unsigned long stack_size,
1357 int __user *parent_tidptr,
1358 int __user *child_tidptr)
1359{
1360 struct task_struct *p;
1361 int trace = 0;
Eric W. Biederman92476d72006-03-31 02:31:42 -08001362 long nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Andrew Mortonbdff7462008-02-04 22:27:22 -08001364 /*
Serge Hallyn18b6e042008-10-15 16:38:45 -05001365 * Do some preliminary argument and permissions checking before we
1366 * actually start allocating stuff
1367 */
1368 if (clone_flags & CLONE_NEWUSER) {
1369 if (clone_flags & CLONE_THREAD)
1370 return -EINVAL;
1371 /* hopefully this check will go away when userns support is
1372 * complete
1373 */
Serge E. Hallyn7657d902008-12-03 13:17:33 -06001374 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) ||
1375 !capable(CAP_SETGID))
Serge Hallyn18b6e042008-10-15 16:38:45 -05001376 return -EPERM;
1377 }
1378
1379 /*
Andrew Mortonbdff7462008-02-04 22:27:22 -08001380 * We hope to recycle these flags after 2.6.26
1381 */
1382 if (unlikely(clone_flags & CLONE_STOPPED)) {
1383 static int __read_mostly count = 100;
1384
1385 if (count > 0 && printk_ratelimit()) {
1386 char comm[TASK_COMM_LEN];
1387
1388 count--;
1389 printk(KERN_INFO "fork(): process `%s' used deprecated "
1390 "clone flags 0x%lx\n",
1391 get_task_comm(comm, current),
1392 clone_flags & CLONE_STOPPED);
1393 }
1394 }
1395
Roland McGrath09a05392008-07-25 19:45:47 -07001396 /*
1397 * When called from kernel_thread, don't do user tracing stuff.
1398 */
1399 if (likely(user_mode(regs)))
1400 trace = tracehook_prepare_clone(clone_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
Sukadev Bhattiprolua6f5e062007-10-18 23:39:53 -07001402 p = copy_process(clone_flags, stack_start, regs, stack_size,
Roland McGrath09a05392008-07-25 19:45:47 -07001403 child_tidptr, NULL, trace);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 /*
1405 * Do this prior waking up the new thread - the thread pointer
1406 * might get invalid after that point, if the thread exits quickly.
1407 */
1408 if (!IS_ERR(p)) {
1409 struct completion vfork;
1410
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -04001411 trace_sched_process_fork(current, p);
1412
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08001413 nr = task_pid_vnr(p);
Pavel Emelyanov30e49c22007-10-18 23:40:10 -07001414
1415 if (clone_flags & CLONE_PARENT_SETTID)
1416 put_user(nr, parent_tidptr);
Sukadev Bhattiprolua6f5e062007-10-18 23:39:53 -07001417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 if (clone_flags & CLONE_VFORK) {
1419 p->vfork_done = &vfork;
1420 init_completion(&vfork);
1421 }
1422
Al Viroa64e6492008-11-12 18:37:41 -05001423 audit_finish_fork(p);
Oleg Nesterov087eb432009-06-04 16:29:07 -07001424 tracehook_report_clone(regs, clone_flags, nr, p);
Roland McGrath09a05392008-07-25 19:45:47 -07001425
1426 /*
1427 * We set PF_STARTING at creation in case tracing wants to
1428 * use this to distinguish a fully live task from one that
1429 * hasn't gotten to tracehook_report_clone() yet. Now we
1430 * clear it and set the child going.
1431 */
1432 p->flags &= ~PF_STARTING;
1433
1434 if (unlikely(clone_flags & CLONE_STOPPED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 /*
1436 * We'll start up with an immediate SIGSTOP.
1437 */
1438 sigaddset(&p->pending.signal, SIGSTOP);
1439 set_tsk_thread_flag(p, TIF_SIGPENDING);
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -08001440 __set_task_state(p, TASK_STOPPED);
Roland McGrath09a05392008-07-25 19:45:47 -07001441 } else {
1442 wake_up_new_task(p, clone_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 }
1444
Roland McGrath09a05392008-07-25 19:45:47 -07001445 tracehook_report_clone_complete(trace, regs,
1446 clone_flags, nr, p);
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (clone_flags & CLONE_VFORK) {
Rafael J. Wysockiba96a0c2007-05-23 13:57:25 -07001449 freezer_do_not_count();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 wait_for_completion(&vfork);
Rafael J. Wysockiba96a0c2007-05-23 13:57:25 -07001451 freezer_count();
Roland McGrathdaded342008-07-25 19:45:47 -07001452 tracehook_report_vfork_done(p, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 }
1454 } else {
Eric W. Biederman92476d72006-03-31 02:31:42 -08001455 nr = PTR_ERR(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 }
Eric W. Biederman92476d72006-03-31 02:31:42 -08001457 return nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458}
1459
Ravikiran G Thirumalai5fd63b32006-01-11 22:46:15 +01001460#ifndef ARCH_MIN_MMSTRUCT_ALIGN
1461#define ARCH_MIN_MMSTRUCT_ALIGN 0
1462#endif
1463
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001464static void sighand_ctor(void *data)
Oleg Nesterovaa1757f2006-03-28 16:11:12 -08001465{
1466 struct sighand_struct *sighand = data;
1467
Christoph Lametera35afb82007-05-16 22:10:57 -07001468 spin_lock_init(&sighand->siglock);
Davide Libenzib8fceee2007-09-20 12:40:16 -07001469 init_waitqueue_head(&sighand->signalfd_wqh);
Oleg Nesterovaa1757f2006-03-28 16:11:12 -08001470}
1471
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472void __init proc_caches_init(void)
1473{
1474 sighand_cachep = kmem_cache_create("sighand_cache",
1475 sizeof(struct sighand_struct), 0,
Vegard Nossum2dff4402008-05-31 15:56:17 +02001476 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU|
1477 SLAB_NOTRACK, sighand_ctor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 signal_cachep = kmem_cache_create("signal_cache",
1479 sizeof(struct signal_struct), 0,
Vegard Nossum2dff4402008-05-31 15:56:17 +02001480 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);
Paul Mundt20c2df82007-07-20 10:11:58 +09001481 files_cachep = kmem_cache_create("files_cache",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 sizeof(struct files_struct), 0,
Vegard Nossum2dff4402008-05-31 15:56:17 +02001483 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);
Paul Mundt20c2df82007-07-20 10:11:58 +09001484 fs_cachep = kmem_cache_create("fs_cache",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 sizeof(struct fs_struct), 0,
Vegard Nossum2dff4402008-05-31 15:56:17 +02001486 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 mm_cachep = kmem_cache_create("mm_struct",
Ravikiran G Thirumalai5fd63b32006-01-11 22:46:15 +01001488 sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
Vegard Nossum2dff4402008-05-31 15:56:17 +02001489 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);
David Howells33e5d7692009-04-02 16:56:32 -07001490 vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC);
David Howells8feae132009-01-08 12:04:47 +00001491 mmap_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492}
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001493
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001494/*
1495 * Check constraints on flags passed to the unshare system call and
1496 * force unsharing of additional process context as appropriate.
1497 */
Alexey Dobriyana39bc512007-10-18 23:41:10 -07001498static void check_unshare_flags(unsigned long *flags_ptr)
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001499{
1500 /*
1501 * If unsharing a thread from a thread group, must also
1502 * unshare vm.
1503 */
1504 if (*flags_ptr & CLONE_THREAD)
1505 *flags_ptr |= CLONE_VM;
1506
1507 /*
1508 * If unsharing vm, must also unshare signal handlers.
1509 */
1510 if (*flags_ptr & CLONE_VM)
1511 *flags_ptr |= CLONE_SIGHAND;
1512
1513 /*
1514 * If unsharing signal handlers and the task was created
1515 * using CLONE_THREAD, then must unshare the thread
1516 */
1517 if ((*flags_ptr & CLONE_SIGHAND) &&
1518 (atomic_read(&current->signal->count) > 1))
1519 *flags_ptr |= CLONE_THREAD;
1520
1521 /*
1522 * If unsharing namespace, must also unshare filesystem information.
1523 */
1524 if (*flags_ptr & CLONE_NEWNS)
1525 *flags_ptr |= CLONE_FS;
1526}
1527
1528/*
1529 * Unsharing of tasks created with CLONE_THREAD is not supported yet
1530 */
1531static int unshare_thread(unsigned long unshare_flags)
1532{
1533 if (unshare_flags & CLONE_THREAD)
1534 return -EINVAL;
1535
1536 return 0;
1537}
1538
1539/*
JANAK DESAI99d14192006-02-07 12:58:59 -08001540 * Unshare the filesystem structure if it is being shared
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001541 */
1542static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)
1543{
1544 struct fs_struct *fs = current->fs;
1545
Al Viro498052b2009-03-30 07:20:30 -04001546 if (!(unshare_flags & CLONE_FS) || !fs)
1547 return 0;
1548
1549 /* don't need lock here; in the worst case we'll do useless copy */
1550 if (fs->users == 1)
1551 return 0;
1552
1553 *new_fsp = copy_fs_struct(fs);
1554 if (!*new_fsp)
1555 return -ENOMEM;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001556
1557 return 0;
1558}
1559
1560/*
Oleg Nesterovdae3c5a2006-12-08 02:36:09 -08001561 * Unsharing of sighand is not supported yet
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001562 */
1563static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)
1564{
1565 struct sighand_struct *sigh = current->sighand;
1566
Oleg Nesterovdae3c5a2006-12-08 02:36:09 -08001567 if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001568 return -EINVAL;
1569 else
1570 return 0;
1571}
1572
1573/*
JANAK DESAIa0a7ec32006-02-07 12:59:01 -08001574 * Unshare vm if it is being shared
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001575 */
1576static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)
1577{
1578 struct mm_struct *mm = current->mm;
1579
1580 if ((unshare_flags & CLONE_VM) &&
JANAK DESAIa0a7ec32006-02-07 12:59:01 -08001581 (mm && atomic_read(&mm->mm_users) > 1)) {
Oleg Nesterov2d61b862006-03-18 20:41:10 +03001582 return -EINVAL;
JANAK DESAIa0a7ec32006-02-07 12:59:01 -08001583 }
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001584
1585 return 0;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001586}
1587
1588/*
JANAK DESAIa016f332006-02-07 12:59:02 -08001589 * Unshare file descriptor table if it is being shared
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001590 */
1591static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)
1592{
1593 struct files_struct *fd = current->files;
JANAK DESAIa016f332006-02-07 12:59:02 -08001594 int error = 0;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001595
1596 if ((unshare_flags & CLONE_FILES) &&
JANAK DESAIa016f332006-02-07 12:59:02 -08001597 (fd && atomic_read(&fd->count) > 1)) {
1598 *new_fdp = dup_fd(fd, &error);
1599 if (!*new_fdp)
1600 return error;
1601 }
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001602
1603 return 0;
1604}
1605
1606/*
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001607 * unshare allows a process to 'unshare' part of the process
1608 * context which was originally shared using clone. copy_*
1609 * functions used by do_fork() cannot be used here directly
1610 * because they modify an inactive task_struct that is being
1611 * constructed. Here we are modifying the current, active,
1612 * task_struct.
1613 */
Heiko Carstens6559eed82009-01-14 14:14:32 +01001614SYSCALL_DEFINE1(unshare, unsigned long, unshare_flags)
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001615{
1616 int err = 0;
1617 struct fs_struct *fs, *new_fs = NULL;
Oleg Nesterovdae3c5a2006-12-08 02:36:09 -08001618 struct sighand_struct *new_sigh = NULL;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001619 struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;
1620 struct files_struct *fd, *new_fd = NULL;
Pavel Emelyanovcf7b7082007-10-18 23:39:54 -07001621 struct nsproxy *new_nsproxy = NULL;
Manfred Spraul9edff4a2008-04-29 01:00:57 -07001622 int do_sysvsem = 0;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001623
1624 check_unshare_flags(&unshare_flags);
1625
Eric W. Biederman06f9d4f2006-03-22 00:07:40 -08001626 /* Return -EINVAL for all unsupported flags */
1627 err = -EINVAL;
1628 if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|
Kirill Korotaev25b21cb2006-10-02 02:18:19 -07001629 CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|
Serge Hallyn18b6e042008-10-15 16:38:45 -05001630 CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWNET))
Eric W. Biederman06f9d4f2006-03-22 00:07:40 -08001631 goto bad_unshare_out;
1632
Manfred Spraul6013f672008-04-29 01:00:59 -07001633 /*
1634 * CLONE_NEWIPC must also detach from the undolist: after switching
1635 * to a new ipc namespace, the semaphore arrays from the old
1636 * namespace are unreachable.
1637 */
1638 if (unshare_flags & (CLONE_NEWIPC|CLONE_SYSVSEM))
Manfred Spraul9edff4a2008-04-29 01:00:57 -07001639 do_sysvsem = 1;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001640 if ((err = unshare_thread(unshare_flags)))
1641 goto bad_unshare_out;
1642 if ((err = unshare_fs(unshare_flags, &new_fs)))
1643 goto bad_unshare_cleanup_thread;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001644 if ((err = unshare_sighand(unshare_flags, &new_sigh)))
Badari Pulavartye3222c42007-05-08 00:25:21 -07001645 goto bad_unshare_cleanup_fs;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001646 if ((err = unshare_vm(unshare_flags, &new_mm)))
1647 goto bad_unshare_cleanup_sigh;
1648 if ((err = unshare_fd(unshare_flags, &new_fd)))
1649 goto bad_unshare_cleanup_vm;
Badari Pulavartye3222c42007-05-08 00:25:21 -07001650 if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,
1651 new_fs)))
Manfred Spraul9edff4a2008-04-29 01:00:57 -07001652 goto bad_unshare_cleanup_fd;
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001653
Manfred Spraul9edff4a2008-04-29 01:00:57 -07001654 if (new_fs || new_mm || new_fd || do_sysvsem || new_nsproxy) {
1655 if (do_sysvsem) {
1656 /*
1657 * CLONE_SYSVSEM is equivalent to sys_exit().
1658 */
1659 exit_sem(current);
1660 }
Serge E. Hallynab516012006-10-02 02:18:06 -07001661
Serge Hallync0b2fc32006-10-02 02:18:18 -07001662 if (new_nsproxy) {
Pavel Emelyanovcf7b7082007-10-18 23:39:54 -07001663 switch_task_namespaces(current, new_nsproxy);
1664 new_nsproxy = NULL;
Serge Hallync0b2fc32006-10-02 02:18:18 -07001665 }
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001666
Pavel Emelyanovcf7b7082007-10-18 23:39:54 -07001667 task_lock(current);
1668
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001669 if (new_fs) {
1670 fs = current->fs;
Al Viro498052b2009-03-30 07:20:30 -04001671 write_lock(&fs->lock);
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001672 current->fs = new_fs;
Al Viro498052b2009-03-30 07:20:30 -04001673 if (--fs->users)
1674 new_fs = NULL;
1675 else
1676 new_fs = fs;
1677 write_unlock(&fs->lock);
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001678 }
1679
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001680 if (new_mm) {
1681 mm = current->mm;
1682 active_mm = current->active_mm;
1683 current->mm = new_mm;
1684 current->active_mm = new_mm;
1685 activate_mm(active_mm, new_mm);
1686 new_mm = mm;
1687 }
1688
1689 if (new_fd) {
1690 fd = current->files;
1691 current->files = new_fd;
1692 new_fd = fd;
1693 }
1694
1695 task_unlock(current);
1696 }
1697
Serge Hallync0b2fc32006-10-02 02:18:18 -07001698 if (new_nsproxy)
Linus Torvalds444f3782007-01-30 13:35:18 -08001699 put_nsproxy(new_nsproxy);
Serge Hallync0b2fc32006-10-02 02:18:18 -07001700
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001701bad_unshare_cleanup_fd:
1702 if (new_fd)
1703 put_files_struct(new_fd);
1704
1705bad_unshare_cleanup_vm:
1706 if (new_mm)
1707 mmput(new_mm);
1708
1709bad_unshare_cleanup_sigh:
1710 if (new_sigh)
1711 if (atomic_dec_and_test(&new_sigh->count))
1712 kmem_cache_free(sighand_cachep, new_sigh);
1713
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001714bad_unshare_cleanup_fs:
1715 if (new_fs)
Al Viro498052b2009-03-30 07:20:30 -04001716 free_fs_struct(new_fs);
JANAK DESAIcf2e3402006-02-07 12:58:58 -08001717
1718bad_unshare_cleanup_thread:
1719bad_unshare_out:
1720 return err;
1721}
Al Viro3b125382008-04-22 05:31:30 -04001722
1723/*
1724 * Helper to unshare the files of the current task.
1725 * We don't want to expose copy_files internals to
1726 * the exec layer of the kernel.
1727 */
1728
1729int unshare_files(struct files_struct **displaced)
1730{
1731 struct task_struct *task = current;
Al Viro50704512008-04-26 05:25:00 +01001732 struct files_struct *copy = NULL;
Al Viro3b125382008-04-22 05:31:30 -04001733 int error;
1734
1735 error = unshare_fd(CLONE_FILES, &copy);
1736 if (error || !copy) {
1737 *displaced = NULL;
1738 return error;
1739 }
1740 *displaced = task->files;
1741 task_lock(task);
1742 task->files = copy;
1743 task_unlock(task);
1744 return 0;
1745}