blob: 8a069612eac39e285afc9bc9314311e5980ef536 [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
14#include <linux/config.h>
15#include <linux/slab.h>
16#include <linux/init.h>
17#include <linux/unistd.h>
18#include <linux/smp_lock.h>
19#include <linux/module.h>
20#include <linux/vmalloc.h>
21#include <linux/completion.h>
22#include <linux/namespace.h>
23#include <linux/personality.h>
24#include <linux/mempolicy.h>
25#include <linux/sem.h>
26#include <linux/file.h>
27#include <linux/key.h>
28#include <linux/binfmts.h>
29#include <linux/mman.h>
30#include <linux/fs.h>
31#include <linux/cpu.h>
32#include <linux/cpuset.h>
33#include <linux/security.h>
34#include <linux/swap.h>
35#include <linux/syscalls.h>
36#include <linux/jiffies.h>
37#include <linux/futex.h>
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -070038#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/ptrace.h>
40#include <linux/mount.h>
41#include <linux/audit.h>
42#include <linux/profile.h>
43#include <linux/rmap.h>
44#include <linux/acct.h>
45
46#include <asm/pgtable.h>
47#include <asm/pgalloc.h>
48#include <asm/uaccess.h>
49#include <asm/mmu_context.h>
50#include <asm/cacheflush.h>
51#include <asm/tlbflush.h>
52
53/*
54 * Protected counters by write_lock_irq(&tasklist_lock)
55 */
56unsigned long total_forks; /* Handle normal Linux uptimes. */
57int nr_threads; /* The idle threads do not count.. */
58
59int max_threads; /* tunable limit on nr_threads */
60
61DEFINE_PER_CPU(unsigned long, process_counts) = 0;
62
63 __cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
64
65EXPORT_SYMBOL(tasklist_lock);
66
67int nr_processes(void)
68{
69 int cpu;
70 int total = 0;
71
72 for_each_online_cpu(cpu)
73 total += per_cpu(process_counts, cpu);
74
75 return total;
76}
77
78#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
79# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
80# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))
81static kmem_cache_t *task_struct_cachep;
82#endif
83
84/* SLAB cache for signal_struct structures (tsk->signal) */
85kmem_cache_t *signal_cachep;
86
87/* SLAB cache for sighand_struct structures (tsk->sighand) */
88kmem_cache_t *sighand_cachep;
89
90/* SLAB cache for files_struct structures (tsk->files) */
91kmem_cache_t *files_cachep;
92
93/* SLAB cache for fs_struct structures (tsk->fs) */
94kmem_cache_t *fs_cachep;
95
96/* SLAB cache for vm_area_struct structures */
97kmem_cache_t *vm_area_cachep;
98
99/* SLAB cache for mm_struct structures (tsk->mm) */
100static kmem_cache_t *mm_cachep;
101
102void free_task(struct task_struct *tsk)
103{
104 free_thread_info(tsk->thread_info);
105 free_task_struct(tsk);
106}
107EXPORT_SYMBOL(free_task);
108
109void __put_task_struct(struct task_struct *tsk)
110{
111 WARN_ON(!(tsk->exit_state & (EXIT_DEAD | EXIT_ZOMBIE)));
112 WARN_ON(atomic_read(&tsk->usage));
113 WARN_ON(tsk == current);
114
115 if (unlikely(tsk->audit_context))
116 audit_free(tsk);
117 security_task_free(tsk);
118 free_uid(tsk->user);
119 put_group_info(tsk->group_info);
120
121 if (!profile_handoff_task(tsk))
122 free_task(tsk);
123}
124
125void __init fork_init(unsigned long mempages)
126{
127#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
128#ifndef ARCH_MIN_TASKALIGN
129#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES
130#endif
131 /* create a slab on which task_structs can be allocated */
132 task_struct_cachep =
133 kmem_cache_create("task_struct", sizeof(struct task_struct),
134 ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL, NULL);
135#endif
136
137 /*
138 * The default maximum number of threads is set to a safe
139 * value: the thread structures can take up at most half
140 * of memory.
141 */
142 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
143
144 /*
145 * we need to allow at least 20 threads to boot a system
146 */
147 if(max_threads < 20)
148 max_threads = 20;
149
150 init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
151 init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
152 init_task.signal->rlim[RLIMIT_SIGPENDING] =
153 init_task.signal->rlim[RLIMIT_NPROC];
154}
155
156static struct task_struct *dup_task_struct(struct task_struct *orig)
157{
158 struct task_struct *tsk;
159 struct thread_info *ti;
160
161 prepare_to_copy(orig);
162
163 tsk = alloc_task_struct();
164 if (!tsk)
165 return NULL;
166
167 ti = alloc_thread_info(tsk);
168 if (!ti) {
169 free_task_struct(tsk);
170 return NULL;
171 }
172
173 *ti = *orig->thread_info;
174 *tsk = *orig;
175 tsk->thread_info = ti;
176 ti->task = tsk;
177
178 /* One for us, one for whoever does the "release_task()" (usually parent) */
179 atomic_set(&tsk->usage,2);
Giancarlo Formicuccia4b5d37a2005-09-09 13:01:22 -0700180 atomic_set(&tsk->fs_excl, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return tsk;
182}
183
184#ifdef CONFIG_MMU
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700185static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700187 struct vm_area_struct *mpnt, *tmp, **pprev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 struct rb_node **rb_link, *rb_parent;
189 int retval;
190 unsigned long charge;
191 struct mempolicy *pol;
192
193 down_write(&oldmm->mmap_sem);
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700194 flush_cache_mm(oldmm);
Hugh Dickins7ee78232005-10-29 18:16:08 -0700195 down_write(&mm->mmap_sem);
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 mm->locked_vm = 0;
198 mm->mmap = NULL;
199 mm->mmap_cache = NULL;
200 mm->free_area_cache = oldmm->mmap_base;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700201 mm->cached_hole_size = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 mm->map_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 cpus_clear(mm->cpu_vm_mask);
204 mm->mm_rb = RB_ROOT;
205 rb_link = &mm->mm_rb.rb_node;
206 rb_parent = NULL;
207 pprev = &mm->mmap;
208
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700209 for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 struct file *file;
211
212 if (mpnt->vm_flags & VM_DONTCOPY) {
Hugh Dickins3b6bfcd2005-07-12 13:58:09 -0700213 long pages = vma_pages(mpnt);
214 mm->total_vm -= pages;
Hugh Dickinsab50b8e2005-10-29 18:15:56 -0700215 vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
Hugh Dickins3b6bfcd2005-07-12 13:58:09 -0700216 -pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 continue;
218 }
219 charge = 0;
220 if (mpnt->vm_flags & VM_ACCOUNT) {
221 unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
222 if (security_vm_enough_memory(len))
223 goto fail_nomem;
224 charge = len;
225 }
226 tmp = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
227 if (!tmp)
228 goto fail_nomem;
229 *tmp = *mpnt;
230 pol = mpol_copy(vma_policy(mpnt));
231 retval = PTR_ERR(pol);
232 if (IS_ERR(pol))
233 goto fail_nomem_policy;
234 vma_set_policy(tmp, pol);
235 tmp->vm_flags &= ~VM_LOCKED;
236 tmp->vm_mm = mm;
237 tmp->vm_next = NULL;
238 anon_vma_link(tmp);
239 file = tmp->vm_file;
240 if (file) {
241 struct inode *inode = file->f_dentry->d_inode;
242 get_file(file);
243 if (tmp->vm_flags & VM_DENYWRITE)
244 atomic_dec(&inode->i_writecount);
245
246 /* insert tmp into the share list, just after mpnt */
247 spin_lock(&file->f_mapping->i_mmap_lock);
248 tmp->vm_truncate_count = mpnt->vm_truncate_count;
249 flush_dcache_mmap_lock(file->f_mapping);
250 vma_prio_tree_add(tmp, mpnt);
251 flush_dcache_mmap_unlock(file->f_mapping);
252 spin_unlock(&file->f_mapping->i_mmap_lock);
253 }
254
255 /*
Hugh Dickins7ee78232005-10-29 18:16:08 -0700256 * Link in the new vma and copy the page table entries.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 *pprev = tmp;
259 pprev = &tmp->vm_next;
260
261 __vma_link_rb(mm, tmp, rb_link, rb_parent);
262 rb_link = &tmp->vm_rb.rb_right;
263 rb_parent = &tmp->vm_rb;
264
265 mm->map_count++;
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700266 retval = copy_page_range(mm, oldmm, tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 if (tmp->vm_ops && tmp->vm_ops->open)
269 tmp->vm_ops->open(tmp);
270
271 if (retval)
272 goto out;
273 }
274 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275out:
Hugh Dickins7ee78232005-10-29 18:16:08 -0700276 up_write(&mm->mmap_sem);
Hugh Dickinsfd3e42f2005-10-29 18:16:06 -0700277 flush_tlb_mm(oldmm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 up_write(&oldmm->mmap_sem);
279 return retval;
280fail_nomem_policy:
281 kmem_cache_free(vm_area_cachep, tmp);
282fail_nomem:
283 retval = -ENOMEM;
284 vm_unacct_memory(charge);
285 goto out;
286}
287
288static inline int mm_alloc_pgd(struct mm_struct * mm)
289{
290 mm->pgd = pgd_alloc(mm);
291 if (unlikely(!mm->pgd))
292 return -ENOMEM;
293 return 0;
294}
295
296static inline void mm_free_pgd(struct mm_struct * mm)
297{
298 pgd_free(mm->pgd);
299}
300#else
301#define dup_mmap(mm, oldmm) (0)
302#define mm_alloc_pgd(mm) (0)
303#define mm_free_pgd(mm)
304#endif /* CONFIG_MMU */
305
306 __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
307
308#define allocate_mm() (kmem_cache_alloc(mm_cachep, SLAB_KERNEL))
309#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
310
311#include <linux/init_task.h>
312
313static struct mm_struct * mm_init(struct mm_struct * mm)
314{
315 atomic_set(&mm->mm_users, 1);
316 atomic_set(&mm->mm_count, 1);
317 init_rwsem(&mm->mmap_sem);
318 INIT_LIST_HEAD(&mm->mmlist);
319 mm->core_waiters = 0;
320 mm->nr_ptes = 0;
Hugh Dickins42946212005-10-29 18:16:05 -0700321 set_mm_counter(mm, file_rss, 0);
Hugh Dickins404351e2005-10-29 18:16:04 -0700322 set_mm_counter(mm, anon_rss, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 spin_lock_init(&mm->page_table_lock);
324 rwlock_init(&mm->ioctx_list_lock);
325 mm->ioctx_list = NULL;
326 mm->default_kioctx = (struct kioctx)INIT_KIOCTX(mm->default_kioctx, *mm);
327 mm->free_area_cache = TASK_UNMAPPED_BASE;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700328 mm->cached_hole_size = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 if (likely(!mm_alloc_pgd(mm))) {
331 mm->def_flags = 0;
332 return mm;
333 }
334 free_mm(mm);
335 return NULL;
336}
337
338/*
339 * Allocate and initialize an mm_struct.
340 */
341struct mm_struct * mm_alloc(void)
342{
343 struct mm_struct * mm;
344
345 mm = allocate_mm();
346 if (mm) {
347 memset(mm, 0, sizeof(*mm));
348 mm = mm_init(mm);
349 }
350 return mm;
351}
352
353/*
354 * Called when the last reference to the mm
355 * is dropped: either by a lazy thread or by
356 * mmput. Free the page directory and the mm.
357 */
358void fastcall __mmdrop(struct mm_struct *mm)
359{
360 BUG_ON(mm == &init_mm);
361 mm_free_pgd(mm);
362 destroy_context(mm);
363 free_mm(mm);
364}
365
366/*
367 * Decrement the use count and release all resources for an mm.
368 */
369void mmput(struct mm_struct *mm)
370{
371 if (atomic_dec_and_test(&mm->mm_users)) {
372 exit_aio(mm);
373 exit_mmap(mm);
374 if (!list_empty(&mm->mmlist)) {
375 spin_lock(&mmlist_lock);
376 list_del(&mm->mmlist);
377 spin_unlock(&mmlist_lock);
378 }
379 put_swap_token(mm);
380 mmdrop(mm);
381 }
382}
383EXPORT_SYMBOL_GPL(mmput);
384
385/**
386 * get_task_mm - acquire a reference to the task's mm
387 *
388 * Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning
389 * this kernel workthread has transiently adopted a user mm with use_mm,
390 * to do its AIO) is not set and if so returns a reference to it, after
391 * bumping up the use count. User must release the mm via mmput()
392 * after use. Typically used by /proc and ptrace.
393 */
394struct mm_struct *get_task_mm(struct task_struct *task)
395{
396 struct mm_struct *mm;
397
398 task_lock(task);
399 mm = task->mm;
400 if (mm) {
401 if (task->flags & PF_BORROWED_MM)
402 mm = NULL;
403 else
404 atomic_inc(&mm->mm_users);
405 }
406 task_unlock(task);
407 return mm;
408}
409EXPORT_SYMBOL_GPL(get_task_mm);
410
411/* Please note the differences between mmput and mm_release.
412 * mmput is called whenever we stop holding onto a mm_struct,
413 * error success whatever.
414 *
415 * mm_release is called after a mm_struct has been removed
416 * from the current process.
417 *
418 * This difference is important for error handling, when we
419 * only half set up a mm_struct for a new process and need to restore
420 * the old one. Because we mmput the new mm_struct before
421 * restoring the old one. . .
422 * Eric Biederman 10 January 1998
423 */
424void mm_release(struct task_struct *tsk, struct mm_struct *mm)
425{
426 struct completion *vfork_done = tsk->vfork_done;
427
428 /* Get rid of any cached register state */
429 deactivate_mm(tsk, mm);
430
431 /* notify parent sleeping on vfork() */
432 if (vfork_done) {
433 tsk->vfork_done = NULL;
434 complete(vfork_done);
435 }
436 if (tsk->clear_child_tid && atomic_read(&mm->mm_users) > 1) {
437 u32 __user * tidptr = tsk->clear_child_tid;
438 tsk->clear_child_tid = NULL;
439
440 /*
441 * We don't check the error code - if userspace has
442 * not set up a proper pointer then tough luck.
443 */
444 put_user(0, tidptr);
445 sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
446 }
447}
448
449static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
450{
451 struct mm_struct * mm, *oldmm;
452 int retval;
453
454 tsk->min_flt = tsk->maj_flt = 0;
455 tsk->nvcsw = tsk->nivcsw = 0;
456
457 tsk->mm = NULL;
458 tsk->active_mm = NULL;
459
460 /*
461 * Are we cloning a kernel thread?
462 *
463 * We need to steal a active VM for that..
464 */
465 oldmm = current->mm;
466 if (!oldmm)
467 return 0;
468
469 if (clone_flags & CLONE_VM) {
470 atomic_inc(&oldmm->mm_users);
471 mm = oldmm;
472 /*
473 * There are cases where the PTL is held to ensure no
474 * new threads start up in user mode using an mm, which
475 * allows optimizing out ipis; the tlb_gather_mmu code
476 * is an example.
477 */
478 spin_unlock_wait(&oldmm->page_table_lock);
479 goto good_mm;
480 }
481
482 retval = -ENOMEM;
483 mm = allocate_mm();
484 if (!mm)
485 goto fail_nomem;
486
487 /* Copy the current MM stuff.. */
488 memcpy(mm, oldmm, sizeof(*mm));
489 if (!mm_init(mm))
490 goto fail_nomem;
491
492 if (init_new_context(tsk,mm))
493 goto fail_nocontext;
494
495 retval = dup_mmap(mm, oldmm);
496 if (retval)
497 goto free_pt;
498
Hugh Dickins42946212005-10-29 18:16:05 -0700499 mm->hiwater_rss = get_mm_rss(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 mm->hiwater_vm = mm->total_vm;
501
502good_mm:
503 tsk->mm = mm;
504 tsk->active_mm = mm;
505 return 0;
506
507free_pt:
508 mmput(mm);
509fail_nomem:
510 return retval;
511
512fail_nocontext:
513 /*
514 * If init_new_context() failed, we cannot use mmput() to free the mm
515 * because it calls destroy_context()
516 */
517 mm_free_pgd(mm);
518 free_mm(mm);
519 return retval;
520}
521
522static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old)
523{
524 struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
525 /* We don't need to lock fs - think why ;-) */
526 if (fs) {
527 atomic_set(&fs->count, 1);
528 rwlock_init(&fs->lock);
529 fs->umask = old->umask;
530 read_lock(&old->lock);
531 fs->rootmnt = mntget(old->rootmnt);
532 fs->root = dget(old->root);
533 fs->pwdmnt = mntget(old->pwdmnt);
534 fs->pwd = dget(old->pwd);
535 if (old->altroot) {
536 fs->altrootmnt = mntget(old->altrootmnt);
537 fs->altroot = dget(old->altroot);
538 } else {
539 fs->altrootmnt = NULL;
540 fs->altroot = NULL;
541 }
542 read_unlock(&old->lock);
543 }
544 return fs;
545}
546
547struct fs_struct *copy_fs_struct(struct fs_struct *old)
548{
549 return __copy_fs_struct(old);
550}
551
552EXPORT_SYMBOL_GPL(copy_fs_struct);
553
554static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
555{
556 if (clone_flags & CLONE_FS) {
557 atomic_inc(&current->fs->count);
558 return 0;
559 }
560 tsk->fs = __copy_fs_struct(current->fs);
561 if (!tsk->fs)
562 return -ENOMEM;
563 return 0;
564}
565
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700566static int count_open_files(struct fdtable *fdt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700568 int size = fdt->max_fdset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 int i;
570
571 /* Find the last open fd */
572 for (i = size/(8*sizeof(long)); i > 0; ) {
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700573 if (fdt->open_fds->fds_bits[--i])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 break;
575 }
576 i = (i+1) * 8 * sizeof(long);
577 return i;
578}
579
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700580static struct files_struct *alloc_files(void)
581{
582 struct files_struct *newf;
583 struct fdtable *fdt;
584
585 newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
586 if (!newf)
587 goto out;
588
589 atomic_set(&newf->count, 1);
590
591 spin_lock_init(&newf->file_lock);
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700592 fdt = &newf->fdtab;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700593 fdt->next_fd = 0;
594 fdt->max_fds = NR_OPEN_DEFAULT;
595 fdt->max_fdset = __FD_SETSIZE;
596 fdt->close_on_exec = &newf->close_on_exec_init;
597 fdt->open_fds = &newf->open_fds_init;
598 fdt->fd = &newf->fd_array[0];
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700599 INIT_RCU_HEAD(&fdt->rcu);
600 fdt->free_files = NULL;
601 fdt->next = NULL;
602 rcu_assign_pointer(newf->fdt, fdt);
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700603out:
604 return newf;
605}
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
608{
609 struct files_struct *oldf, *newf;
610 struct file **old_fds, **new_fds;
611 int open_files, size, i, error = 0, expand;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700612 struct fdtable *old_fdt, *new_fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614 /*
615 * A background process may not have any files ...
616 */
617 oldf = current->files;
618 if (!oldf)
619 goto out;
620
621 if (clone_flags & CLONE_FILES) {
622 atomic_inc(&oldf->count);
623 goto out;
624 }
625
626 /*
627 * Note: we may be using current for both targets (See exec.c)
628 * This works because we cache current->files (old) as oldf. Don't
629 * break this.
630 */
631 tsk->files = NULL;
632 error = -ENOMEM;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700633 newf = alloc_files();
634 if (!newf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 goto out;
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 spin_lock(&oldf->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700638 old_fdt = files_fdtable(oldf);
639 new_fdt = files_fdtable(newf);
640 size = old_fdt->max_fdset;
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700641 open_files = count_open_files(old_fdt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 expand = 0;
643
644 /*
645 * Check whether we need to allocate a larger fd array or fd set.
646 * Note: we're not a clone task, so the open count won't change.
647 */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700648 if (open_files > new_fdt->max_fdset) {
649 new_fdt->max_fdset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 expand = 1;
651 }
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700652 if (open_files > new_fdt->max_fds) {
653 new_fdt->max_fds = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 expand = 1;
655 }
656
657 /* if the old fdset gets grown now, we'll only copy up to "size" fds */
658 if (expand) {
659 spin_unlock(&oldf->file_lock);
660 spin_lock(&newf->file_lock);
661 error = expand_files(newf, open_files-1);
662 spin_unlock(&newf->file_lock);
663 if (error < 0)
664 goto out_release;
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700665 new_fdt = files_fdtable(newf);
666 /*
667 * Reacquire the oldf lock and a pointer to its fd table
668 * who knows it may have a new bigger fd table. We need
669 * the latest pointer.
670 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 spin_lock(&oldf->file_lock);
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700672 old_fdt = files_fdtable(oldf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
674
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700675 old_fds = old_fdt->fd;
676 new_fds = new_fdt->fd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700678 memcpy(new_fdt->open_fds->fds_bits, old_fdt->open_fds->fds_bits, open_files/8);
679 memcpy(new_fdt->close_on_exec->fds_bits, old_fdt->close_on_exec->fds_bits, open_files/8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
681 for (i = open_files; i != 0; i--) {
682 struct file *f = *old_fds++;
683 if (f) {
684 get_file(f);
685 } else {
686 /*
687 * The fd may be claimed in the fd bitmap but not yet
688 * instantiated in the files array if a sibling thread
689 * is partway through open(). So make sure that this
690 * fd is available to the new process.
691 */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700692 FD_CLR(open_files - i, new_fdt->open_fds);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700694 rcu_assign_pointer(*new_fds++, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
696 spin_unlock(&oldf->file_lock);
697
698 /* compute the remainder to be cleared */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700699 size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 /* This is long word aligned thus could use a optimized version */
702 memset(new_fds, 0, size);
703
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700704 if (new_fdt->max_fdset > open_files) {
705 int left = (new_fdt->max_fdset-open_files)/8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 int start = open_files / (8 * sizeof(unsigned long));
707
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700708 memset(&new_fdt->open_fds->fds_bits[start], 0, left);
709 memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
711
712 tsk->files = newf;
713 error = 0;
714out:
715 return error;
716
717out_release:
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700718 free_fdset (new_fdt->close_on_exec, new_fdt->max_fdset);
719 free_fdset (new_fdt->open_fds, new_fdt->max_fdset);
720 free_fd_array(new_fdt->fd, new_fdt->max_fds);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 kmem_cache_free(files_cachep, newf);
722 goto out;
723}
724
725/*
726 * Helper to unshare the files of the current task.
727 * We don't want to expose copy_files internals to
728 * the exec layer of the kernel.
729 */
730
731int unshare_files(void)
732{
733 struct files_struct *files = current->files;
734 int rc;
735
736 if(!files)
737 BUG();
738
739 /* This can race but the race causes us to copy when we don't
740 need to and drop the copy */
741 if(atomic_read(&files->count) == 1)
742 {
743 atomic_inc(&files->count);
744 return 0;
745 }
746 rc = copy_files(0, current);
747 if(rc)
748 current->files = files;
749 return rc;
750}
751
752EXPORT_SYMBOL(unshare_files);
753
754static inline int copy_sighand(unsigned long clone_flags, struct task_struct * tsk)
755{
756 struct sighand_struct *sig;
757
758 if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
759 atomic_inc(&current->sighand->count);
760 return 0;
761 }
762 sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
763 tsk->sighand = sig;
764 if (!sig)
765 return -ENOMEM;
766 spin_lock_init(&sig->siglock);
767 atomic_set(&sig->count, 1);
768 memcpy(sig->action, current->sighand->action, sizeof(sig->action));
769 return 0;
770}
771
772static inline int copy_signal(unsigned long clone_flags, struct task_struct * tsk)
773{
774 struct signal_struct *sig;
775 int ret;
776
777 if (clone_flags & CLONE_THREAD) {
778 atomic_inc(&current->signal->count);
779 atomic_inc(&current->signal->live);
780 return 0;
781 }
782 sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
783 tsk->signal = sig;
784 if (!sig)
785 return -ENOMEM;
786
787 ret = copy_thread_group_keys(tsk);
788 if (ret < 0) {
789 kmem_cache_free(signal_cachep, sig);
790 return ret;
791 }
792
793 atomic_set(&sig->count, 1);
794 atomic_set(&sig->live, 1);
795 init_waitqueue_head(&sig->wait_chldexit);
796 sig->flags = 0;
797 sig->group_exit_code = 0;
798 sig->group_exit_task = NULL;
799 sig->group_stop_count = 0;
800 sig->curr_target = NULL;
801 init_sigpending(&sig->shared_pending);
802 INIT_LIST_HEAD(&sig->posix_timers);
803
804 sig->it_real_value = sig->it_real_incr = 0;
805 sig->real_timer.function = it_real_fn;
806 sig->real_timer.data = (unsigned long) tsk;
807 init_timer(&sig->real_timer);
808
809 sig->it_virt_expires = cputime_zero;
810 sig->it_virt_incr = cputime_zero;
811 sig->it_prof_expires = cputime_zero;
812 sig->it_prof_incr = cputime_zero;
813
814 sig->tty = current->signal->tty;
815 sig->pgrp = process_group(current);
816 sig->session = current->signal->session;
817 sig->leader = 0; /* session leadership doesn't inherit */
818 sig->tty_old_pgrp = 0;
819
820 sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
821 sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
822 sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
823 sig->sched_time = 0;
824 INIT_LIST_HEAD(&sig->cpu_timers[0]);
825 INIT_LIST_HEAD(&sig->cpu_timers[1]);
826 INIT_LIST_HEAD(&sig->cpu_timers[2]);
827
828 task_lock(current->group_leader);
829 memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
830 task_unlock(current->group_leader);
831
832 if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
833 /*
834 * New sole thread in the process gets an expiry time
835 * of the whole CPU time limit.
836 */
837 tsk->it_prof_expires =
838 secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
839 }
840
841 return 0;
842}
843
844static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
845{
846 unsigned long new_flags = p->flags;
847
Alan Sternd1209d02005-10-19 21:23:51 -0700848 new_flags &= ~(PF_SUPERPRIV | PF_NOFREEZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 new_flags |= PF_FORKNOEXEC;
850 if (!(clone_flags & CLONE_PTRACE))
851 p->ptrace = 0;
852 p->flags = new_flags;
853}
854
855asmlinkage long sys_set_tid_address(int __user *tidptr)
856{
857 current->clear_child_tid = tidptr;
858
859 return current->pid;
860}
861
862/*
863 * This creates a new process as a copy of the old one,
864 * but does not actually start it yet.
865 *
866 * It copies the registers, and all the appropriate
867 * parts of the process environment (as per the clone
868 * flags). The actual kick-off is left to the caller.
869 */
870static task_t *copy_process(unsigned long clone_flags,
871 unsigned long stack_start,
872 struct pt_regs *regs,
873 unsigned long stack_size,
874 int __user *parent_tidptr,
875 int __user *child_tidptr,
876 int pid)
877{
878 int retval;
879 struct task_struct *p = NULL;
880
881 if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
882 return ERR_PTR(-EINVAL);
883
884 /*
885 * Thread groups must share signals as well, and detached threads
886 * can only be started up within the thread group.
887 */
888 if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
889 return ERR_PTR(-EINVAL);
890
891 /*
892 * Shared signal handlers imply shared VM. By way of the above,
893 * thread groups also imply shared VM. Blocking this case allows
894 * for various simplifications in other code.
895 */
896 if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
897 return ERR_PTR(-EINVAL);
898
899 retval = security_task_create(clone_flags);
900 if (retval)
901 goto fork_out;
902
903 retval = -ENOMEM;
904 p = dup_task_struct(current);
905 if (!p)
906 goto fork_out;
907
908 retval = -EAGAIN;
909 if (atomic_read(&p->user->processes) >=
910 p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
911 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
912 p->user != &root_user)
913 goto bad_fork_free;
914 }
915
916 atomic_inc(&p->user->__count);
917 atomic_inc(&p->user->processes);
918 get_group_info(p->group_info);
919
920 /*
921 * If multiple threads are within copy_process(), then this check
922 * triggers too late. This doesn't hurt, the check is only there
923 * to stop root fork bombs.
924 */
925 if (nr_threads >= max_threads)
926 goto bad_fork_cleanup_count;
927
928 if (!try_module_get(p->thread_info->exec_domain->module))
929 goto bad_fork_cleanup_count;
930
931 if (p->binfmt && !try_module_get(p->binfmt->module))
932 goto bad_fork_cleanup_put_domain;
933
934 p->did_exec = 0;
935 copy_flags(clone_flags, p);
936 p->pid = pid;
937 retval = -EFAULT;
938 if (clone_flags & CLONE_PARENT_SETTID)
939 if (put_user(p->pid, parent_tidptr))
940 goto bad_fork_cleanup;
941
942 p->proc_dentry = NULL;
943
944 INIT_LIST_HEAD(&p->children);
945 INIT_LIST_HEAD(&p->sibling);
946 p->vfork_done = NULL;
947 spin_lock_init(&p->alloc_lock);
948 spin_lock_init(&p->proc_lock);
949
950 clear_tsk_thread_flag(p, TIF_SIGPENDING);
951 init_sigpending(&p->pending);
952
953 p->utime = cputime_zero;
954 p->stime = cputime_zero;
955 p->sched_time = 0;
956 p->rchar = 0; /* I/O counter: bytes read */
957 p->wchar = 0; /* I/O counter: bytes written */
958 p->syscr = 0; /* I/O counter: read syscalls */
959 p->syscw = 0; /* I/O counter: write syscalls */
960 acct_clear_integrals(p);
961
962 p->it_virt_expires = cputime_zero;
963 p->it_prof_expires = cputime_zero;
964 p->it_sched_expires = 0;
965 INIT_LIST_HEAD(&p->cpu_timers[0]);
966 INIT_LIST_HEAD(&p->cpu_timers[1]);
967 INIT_LIST_HEAD(&p->cpu_timers[2]);
968
969 p->lock_depth = -1; /* -1 = no lock */
970 do_posix_clock_monotonic_gettime(&p->start_time);
971 p->security = NULL;
972 p->io_context = NULL;
973 p->io_wait = NULL;
974 p->audit_context = NULL;
975#ifdef CONFIG_NUMA
976 p->mempolicy = mpol_copy(p->mempolicy);
977 if (IS_ERR(p->mempolicy)) {
978 retval = PTR_ERR(p->mempolicy);
979 p->mempolicy = NULL;
980 goto bad_fork_cleanup;
981 }
982#endif
983
984 p->tgid = p->pid;
985 if (clone_flags & CLONE_THREAD)
986 p->tgid = current->tgid;
987
988 if ((retval = security_task_alloc(p)))
989 goto bad_fork_cleanup_policy;
990 if ((retval = audit_alloc(p)))
991 goto bad_fork_cleanup_security;
992 /* copy all the process information */
993 if ((retval = copy_semundo(clone_flags, p)))
994 goto bad_fork_cleanup_audit;
995 if ((retval = copy_files(clone_flags, p)))
996 goto bad_fork_cleanup_semundo;
997 if ((retval = copy_fs(clone_flags, p)))
998 goto bad_fork_cleanup_files;
999 if ((retval = copy_sighand(clone_flags, p)))
1000 goto bad_fork_cleanup_fs;
1001 if ((retval = copy_signal(clone_flags, p)))
1002 goto bad_fork_cleanup_sighand;
1003 if ((retval = copy_mm(clone_flags, p)))
1004 goto bad_fork_cleanup_signal;
1005 if ((retval = copy_keys(clone_flags, p)))
1006 goto bad_fork_cleanup_mm;
1007 if ((retval = copy_namespace(clone_flags, p)))
1008 goto bad_fork_cleanup_keys;
1009 retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
1010 if (retval)
1011 goto bad_fork_cleanup_namespace;
1012
1013 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1014 /*
1015 * Clear TID on mm_release()?
1016 */
1017 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
1018
1019 /*
1020 * Syscall tracing should be turned off in the child regardless
1021 * of CLONE_PTRACE.
1022 */
1023 clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
Laurent Viviered75e8d2005-09-03 15:57:18 -07001024#ifdef TIF_SYSCALL_EMU
1025 clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
1026#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
1028 /* Our parent execution domain becomes current domain
1029 These must match for thread signalling to apply */
1030
1031 p->parent_exec_id = p->self_exec_id;
1032
1033 /* ok, now we should be set up.. */
1034 p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
1035 p->pdeath_signal = 0;
1036 p->exit_state = 0;
1037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 /*
1039 * Ok, make it visible to the rest of the system.
1040 * We dont wake it up yet.
1041 */
1042 p->group_leader = p;
1043 INIT_LIST_HEAD(&p->ptrace_children);
1044 INIT_LIST_HEAD(&p->ptrace_list);
1045
Nick Piggin476d1392005-06-25 14:57:29 -07001046 /* Perform scheduler related setup. Assign this task to a CPU. */
1047 sched_fork(p, clone_flags);
1048
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 /* Need tasklist lock for parent etc handling! */
1050 write_lock_irq(&tasklist_lock);
1051
1052 /*
Nick Piggin476d1392005-06-25 14:57:29 -07001053 * The task hasn't been attached yet, so its cpus_allowed mask will
1054 * not be changed, nor will its assigned CPU.
1055 *
1056 * The cpus_allowed mask of the parent may have changed after it was
1057 * copied first time - so re-copy it here, then check the child's CPU
1058 * to ensure it is on a valid CPU (and if not, just force it back to
1059 * parent's CPU). This avoids alot of nasty races.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 */
1061 p->cpus_allowed = current->cpus_allowed;
Srivatsa Vaddagiri26ff6ad2005-09-16 19:27:40 -07001062 if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
1063 !cpu_online(task_cpu(p))))
Nick Piggin476d1392005-06-25 14:57:29 -07001064 set_task_cpu(p, smp_processor_id());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 /*
1067 * Check for pending SIGKILL! The new thread should not be allowed
1068 * to slip out of an OOM kill. (or normal SIGKILL.)
1069 */
1070 if (sigismember(&current->pending.signal, SIGKILL)) {
1071 write_unlock_irq(&tasklist_lock);
1072 retval = -EINTR;
1073 goto bad_fork_cleanup_namespace;
1074 }
1075
1076 /* CLONE_PARENT re-uses the old parent */
1077 if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
1078 p->real_parent = current->real_parent;
1079 else
1080 p->real_parent = current;
1081 p->parent = p->real_parent;
1082
1083 if (clone_flags & CLONE_THREAD) {
1084 spin_lock(&current->sighand->siglock);
1085 /*
1086 * Important: if an exit-all has been started then
1087 * do not create this new thread - the whole thread
1088 * group is supposed to exit anyway.
1089 */
1090 if (current->signal->flags & SIGNAL_GROUP_EXIT) {
1091 spin_unlock(&current->sighand->siglock);
1092 write_unlock_irq(&tasklist_lock);
1093 retval = -EAGAIN;
1094 goto bad_fork_cleanup_namespace;
1095 }
1096 p->group_leader = current->group_leader;
1097
1098 if (current->signal->group_stop_count > 0) {
1099 /*
1100 * There is an all-stop in progress for the group.
1101 * We ourselves will stop as soon as we check signals.
1102 * Make the new thread part of that group stop too.
1103 */
1104 current->signal->group_stop_count++;
1105 set_tsk_thread_flag(p, TIF_SIGPENDING);
1106 }
1107
1108 if (!cputime_eq(current->signal->it_virt_expires,
1109 cputime_zero) ||
1110 !cputime_eq(current->signal->it_prof_expires,
1111 cputime_zero) ||
1112 current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
1113 !list_empty(&current->signal->cpu_timers[0]) ||
1114 !list_empty(&current->signal->cpu_timers[1]) ||
1115 !list_empty(&current->signal->cpu_timers[2])) {
1116 /*
1117 * Have child wake up on its first tick to check
1118 * for process CPU timers.
1119 */
1120 p->it_prof_expires = jiffies_to_cputime(1);
1121 }
1122
1123 spin_unlock(&current->sighand->siglock);
1124 }
1125
Jens Axboe22e2c502005-06-27 10:55:12 +02001126 /*
1127 * inherit ioprio
1128 */
1129 p->ioprio = current->ioprio;
1130
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 SET_LINKS(p);
1132 if (unlikely(p->ptrace & PT_PTRACED))
1133 __ptrace_link(p, current->parent);
1134
1135 cpuset_fork(p);
1136
1137 attach_pid(p, PIDTYPE_PID, p->pid);
1138 attach_pid(p, PIDTYPE_TGID, p->tgid);
1139 if (thread_group_leader(p)) {
1140 attach_pid(p, PIDTYPE_PGID, process_group(p));
1141 attach_pid(p, PIDTYPE_SID, p->signal->session);
1142 if (p->pid)
1143 __get_cpu_var(process_counts)++;
1144 }
1145
Jason Baronb0d62e62005-09-09 13:02:01 -07001146 if (!current->signal->tty && p->signal->tty)
1147 p->signal->tty = NULL;
1148
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 nr_threads++;
1150 total_forks++;
1151 write_unlock_irq(&tasklist_lock);
1152 retval = 0;
1153
1154fork_out:
1155 if (retval)
1156 return ERR_PTR(retval);
1157 return p;
1158
1159bad_fork_cleanup_namespace:
1160 exit_namespace(p);
1161bad_fork_cleanup_keys:
1162 exit_keys(p);
1163bad_fork_cleanup_mm:
1164 if (p->mm)
1165 mmput(p->mm);
1166bad_fork_cleanup_signal:
1167 exit_signal(p);
1168bad_fork_cleanup_sighand:
1169 exit_sighand(p);
1170bad_fork_cleanup_fs:
1171 exit_fs(p); /* blocking */
1172bad_fork_cleanup_files:
1173 exit_files(p); /* blocking */
1174bad_fork_cleanup_semundo:
1175 exit_sem(p);
1176bad_fork_cleanup_audit:
1177 audit_free(p);
1178bad_fork_cleanup_security:
1179 security_task_free(p);
1180bad_fork_cleanup_policy:
1181#ifdef CONFIG_NUMA
1182 mpol_free(p->mempolicy);
1183#endif
1184bad_fork_cleanup:
1185 if (p->binfmt)
1186 module_put(p->binfmt->module);
1187bad_fork_cleanup_put_domain:
1188 module_put(p->thread_info->exec_domain->module);
1189bad_fork_cleanup_count:
1190 put_group_info(p->group_info);
1191 atomic_dec(&p->user->processes);
1192 free_uid(p->user);
1193bad_fork_free:
1194 free_task(p);
1195 goto fork_out;
1196}
1197
1198struct pt_regs * __devinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
1199{
1200 memset(regs, 0, sizeof(struct pt_regs));
1201 return regs;
1202}
1203
1204task_t * __devinit fork_idle(int cpu)
1205{
1206 task_t *task;
1207 struct pt_regs regs;
1208
1209 task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL, NULL, 0);
1210 if (!task)
1211 return ERR_PTR(-ENOMEM);
1212 init_idle(task, cpu);
1213 unhash_process(task);
1214 return task;
1215}
1216
1217static inline int fork_traceflag (unsigned clone_flags)
1218{
1219 if (clone_flags & CLONE_UNTRACED)
1220 return 0;
1221 else if (clone_flags & CLONE_VFORK) {
1222 if (current->ptrace & PT_TRACE_VFORK)
1223 return PTRACE_EVENT_VFORK;
1224 } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
1225 if (current->ptrace & PT_TRACE_CLONE)
1226 return PTRACE_EVENT_CLONE;
1227 } else if (current->ptrace & PT_TRACE_FORK)
1228 return PTRACE_EVENT_FORK;
1229
1230 return 0;
1231}
1232
1233/*
1234 * Ok, this is the main fork-routine.
1235 *
1236 * It copies the process, and if successful kick-starts
1237 * it and waits for it to finish using the VM if required.
1238 */
1239long do_fork(unsigned long clone_flags,
1240 unsigned long stack_start,
1241 struct pt_regs *regs,
1242 unsigned long stack_size,
1243 int __user *parent_tidptr,
1244 int __user *child_tidptr)
1245{
1246 struct task_struct *p;
1247 int trace = 0;
1248 long pid = alloc_pidmap();
1249
1250 if (pid < 0)
1251 return -EAGAIN;
1252 if (unlikely(current->ptrace)) {
1253 trace = fork_traceflag (clone_flags);
1254 if (trace)
1255 clone_flags |= CLONE_PTRACE;
1256 }
1257
1258 p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
1259 /*
1260 * Do this prior waking up the new thread - the thread pointer
1261 * might get invalid after that point, if the thread exits quickly.
1262 */
1263 if (!IS_ERR(p)) {
1264 struct completion vfork;
1265
1266 if (clone_flags & CLONE_VFORK) {
1267 p->vfork_done = &vfork;
1268 init_completion(&vfork);
1269 }
1270
1271 if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
1272 /*
1273 * We'll start up with an immediate SIGSTOP.
1274 */
1275 sigaddset(&p->pending.signal, SIGSTOP);
1276 set_tsk_thread_flag(p, TIF_SIGPENDING);
1277 }
1278
1279 if (!(clone_flags & CLONE_STOPPED))
1280 wake_up_new_task(p, clone_flags);
1281 else
1282 p->state = TASK_STOPPED;
1283
1284 if (unlikely (trace)) {
1285 current->ptrace_message = pid;
1286 ptrace_notify ((trace << 8) | SIGTRAP);
1287 }
1288
1289 if (clone_flags & CLONE_VFORK) {
1290 wait_for_completion(&vfork);
1291 if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))
1292 ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
1293 }
1294 } else {
1295 free_pidmap(pid);
1296 pid = PTR_ERR(p);
1297 }
1298 return pid;
1299}
1300
1301void __init proc_caches_init(void)
1302{
1303 sighand_cachep = kmem_cache_create("sighand_cache",
1304 sizeof(struct sighand_struct), 0,
1305 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1306 signal_cachep = kmem_cache_create("signal_cache",
1307 sizeof(struct signal_struct), 0,
1308 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1309 files_cachep = kmem_cache_create("files_cache",
1310 sizeof(struct files_struct), 0,
1311 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1312 fs_cachep = kmem_cache_create("fs_cache",
1313 sizeof(struct fs_struct), 0,
1314 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1315 vm_area_cachep = kmem_cache_create("vm_area_struct",
1316 sizeof(struct vm_area_struct), 0,
1317 SLAB_PANIC, NULL, NULL);
1318 mm_cachep = kmem_cache_create("mm_struct",
1319 sizeof(struct mm_struct), 0,
1320 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1321}