blob: 280bd44ac4411634c0eb845c01be8ca3a5f22b7c [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
185static inline int dup_mmap(struct mm_struct * mm, struct mm_struct * oldmm)
186{
187 struct vm_area_struct * mpnt, *tmp, **pprev;
188 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);
194 flush_cache_mm(current->mm);
195 mm->locked_vm = 0;
196 mm->mmap = NULL;
197 mm->mmap_cache = NULL;
198 mm->free_area_cache = oldmm->mmap_base;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700199 mm->cached_hole_size = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 mm->map_count = 0;
201 set_mm_counter(mm, rss, 0);
202 set_mm_counter(mm, anon_rss, 0);
203 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
209 for (mpnt = current->mm->mmap ; mpnt ; mpnt = mpnt->vm_next) {
210 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -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 /*
256 * Link in the new vma and copy the page table entries:
Hugh Dickins45918e12005-06-21 17:15:08 -0700257 * link in first so that swapoff can see swap entries.
258 * Note that, exceptionally, here the vma is inserted
259 * without holding mm->mmap_sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 */
261 spin_lock(&mm->page_table_lock);
262 *pprev = tmp;
263 pprev = &tmp->vm_next;
264
265 __vma_link_rb(mm, tmp, rb_link, rb_parent);
266 rb_link = &tmp->vm_rb.rb_right;
267 rb_parent = &tmp->vm_rb;
268
269 mm->map_count++;
270 retval = copy_page_range(mm, current->mm, tmp);
271 spin_unlock(&mm->page_table_lock);
272
273 if (tmp->vm_ops && tmp->vm_ops->open)
274 tmp->vm_ops->open(tmp);
275
276 if (retval)
277 goto out;
278 }
279 retval = 0;
280
281out:
282 flush_tlb_mm(current->mm);
283 up_write(&oldmm->mmap_sem);
284 return retval;
285fail_nomem_policy:
286 kmem_cache_free(vm_area_cachep, tmp);
287fail_nomem:
288 retval = -ENOMEM;
289 vm_unacct_memory(charge);
290 goto out;
291}
292
293static inline int mm_alloc_pgd(struct mm_struct * mm)
294{
295 mm->pgd = pgd_alloc(mm);
296 if (unlikely(!mm->pgd))
297 return -ENOMEM;
298 return 0;
299}
300
301static inline void mm_free_pgd(struct mm_struct * mm)
302{
303 pgd_free(mm->pgd);
304}
305#else
306#define dup_mmap(mm, oldmm) (0)
307#define mm_alloc_pgd(mm) (0)
308#define mm_free_pgd(mm)
309#endif /* CONFIG_MMU */
310
311 __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
312
313#define allocate_mm() (kmem_cache_alloc(mm_cachep, SLAB_KERNEL))
314#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
315
316#include <linux/init_task.h>
317
318static struct mm_struct * mm_init(struct mm_struct * mm)
319{
320 atomic_set(&mm->mm_users, 1);
321 atomic_set(&mm->mm_count, 1);
322 init_rwsem(&mm->mmap_sem);
323 INIT_LIST_HEAD(&mm->mmlist);
324 mm->core_waiters = 0;
325 mm->nr_ptes = 0;
326 spin_lock_init(&mm->page_table_lock);
327 rwlock_init(&mm->ioctx_list_lock);
328 mm->ioctx_list = NULL;
329 mm->default_kioctx = (struct kioctx)INIT_KIOCTX(mm->default_kioctx, *mm);
330 mm->free_area_cache = TASK_UNMAPPED_BASE;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700331 mm->cached_hole_size = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333 if (likely(!mm_alloc_pgd(mm))) {
334 mm->def_flags = 0;
335 return mm;
336 }
337 free_mm(mm);
338 return NULL;
339}
340
341/*
342 * Allocate and initialize an mm_struct.
343 */
344struct mm_struct * mm_alloc(void)
345{
346 struct mm_struct * mm;
347
348 mm = allocate_mm();
349 if (mm) {
350 memset(mm, 0, sizeof(*mm));
351 mm = mm_init(mm);
352 }
353 return mm;
354}
355
356/*
357 * Called when the last reference to the mm
358 * is dropped: either by a lazy thread or by
359 * mmput. Free the page directory and the mm.
360 */
361void fastcall __mmdrop(struct mm_struct *mm)
362{
363 BUG_ON(mm == &init_mm);
364 mm_free_pgd(mm);
365 destroy_context(mm);
366 free_mm(mm);
367}
368
369/*
370 * Decrement the use count and release all resources for an mm.
371 */
372void mmput(struct mm_struct *mm)
373{
374 if (atomic_dec_and_test(&mm->mm_users)) {
375 exit_aio(mm);
376 exit_mmap(mm);
377 if (!list_empty(&mm->mmlist)) {
378 spin_lock(&mmlist_lock);
379 list_del(&mm->mmlist);
380 spin_unlock(&mmlist_lock);
381 }
382 put_swap_token(mm);
383 mmdrop(mm);
384 }
385}
386EXPORT_SYMBOL_GPL(mmput);
387
388/**
389 * get_task_mm - acquire a reference to the task's mm
390 *
391 * Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning
392 * this kernel workthread has transiently adopted a user mm with use_mm,
393 * to do its AIO) is not set and if so returns a reference to it, after
394 * bumping up the use count. User must release the mm via mmput()
395 * after use. Typically used by /proc and ptrace.
396 */
397struct mm_struct *get_task_mm(struct task_struct *task)
398{
399 struct mm_struct *mm;
400
401 task_lock(task);
402 mm = task->mm;
403 if (mm) {
404 if (task->flags & PF_BORROWED_MM)
405 mm = NULL;
406 else
407 atomic_inc(&mm->mm_users);
408 }
409 task_unlock(task);
410 return mm;
411}
412EXPORT_SYMBOL_GPL(get_task_mm);
413
414/* Please note the differences between mmput and mm_release.
415 * mmput is called whenever we stop holding onto a mm_struct,
416 * error success whatever.
417 *
418 * mm_release is called after a mm_struct has been removed
419 * from the current process.
420 *
421 * This difference is important for error handling, when we
422 * only half set up a mm_struct for a new process and need to restore
423 * the old one. Because we mmput the new mm_struct before
424 * restoring the old one. . .
425 * Eric Biederman 10 January 1998
426 */
427void mm_release(struct task_struct *tsk, struct mm_struct *mm)
428{
429 struct completion *vfork_done = tsk->vfork_done;
430
431 /* Get rid of any cached register state */
432 deactivate_mm(tsk, mm);
433
434 /* notify parent sleeping on vfork() */
435 if (vfork_done) {
436 tsk->vfork_done = NULL;
437 complete(vfork_done);
438 }
439 if (tsk->clear_child_tid && atomic_read(&mm->mm_users) > 1) {
440 u32 __user * tidptr = tsk->clear_child_tid;
441 tsk->clear_child_tid = NULL;
442
443 /*
444 * We don't check the error code - if userspace has
445 * not set up a proper pointer then tough luck.
446 */
447 put_user(0, tidptr);
448 sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
449 }
450}
451
452static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
453{
454 struct mm_struct * mm, *oldmm;
455 int retval;
456
457 tsk->min_flt = tsk->maj_flt = 0;
458 tsk->nvcsw = tsk->nivcsw = 0;
459
460 tsk->mm = NULL;
461 tsk->active_mm = NULL;
462
463 /*
464 * Are we cloning a kernel thread?
465 *
466 * We need to steal a active VM for that..
467 */
468 oldmm = current->mm;
469 if (!oldmm)
470 return 0;
471
472 if (clone_flags & CLONE_VM) {
473 atomic_inc(&oldmm->mm_users);
474 mm = oldmm;
475 /*
476 * There are cases where the PTL is held to ensure no
477 * new threads start up in user mode using an mm, which
478 * allows optimizing out ipis; the tlb_gather_mmu code
479 * is an example.
480 */
481 spin_unlock_wait(&oldmm->page_table_lock);
482 goto good_mm;
483 }
484
485 retval = -ENOMEM;
486 mm = allocate_mm();
487 if (!mm)
488 goto fail_nomem;
489
490 /* Copy the current MM stuff.. */
491 memcpy(mm, oldmm, sizeof(*mm));
492 if (!mm_init(mm))
493 goto fail_nomem;
494
495 if (init_new_context(tsk,mm))
496 goto fail_nocontext;
497
498 retval = dup_mmap(mm, oldmm);
499 if (retval)
500 goto free_pt;
501
502 mm->hiwater_rss = get_mm_counter(mm,rss);
503 mm->hiwater_vm = mm->total_vm;
504
505good_mm:
506 tsk->mm = mm;
507 tsk->active_mm = mm;
508 return 0;
509
510free_pt:
511 mmput(mm);
512fail_nomem:
513 return retval;
514
515fail_nocontext:
516 /*
517 * If init_new_context() failed, we cannot use mmput() to free the mm
518 * because it calls destroy_context()
519 */
520 mm_free_pgd(mm);
521 free_mm(mm);
522 return retval;
523}
524
525static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old)
526{
527 struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
528 /* We don't need to lock fs - think why ;-) */
529 if (fs) {
530 atomic_set(&fs->count, 1);
531 rwlock_init(&fs->lock);
532 fs->umask = old->umask;
533 read_lock(&old->lock);
534 fs->rootmnt = mntget(old->rootmnt);
535 fs->root = dget(old->root);
536 fs->pwdmnt = mntget(old->pwdmnt);
537 fs->pwd = dget(old->pwd);
538 if (old->altroot) {
539 fs->altrootmnt = mntget(old->altrootmnt);
540 fs->altroot = dget(old->altroot);
541 } else {
542 fs->altrootmnt = NULL;
543 fs->altroot = NULL;
544 }
545 read_unlock(&old->lock);
546 }
547 return fs;
548}
549
550struct fs_struct *copy_fs_struct(struct fs_struct *old)
551{
552 return __copy_fs_struct(old);
553}
554
555EXPORT_SYMBOL_GPL(copy_fs_struct);
556
557static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
558{
559 if (clone_flags & CLONE_FS) {
560 atomic_inc(&current->fs->count);
561 return 0;
562 }
563 tsk->fs = __copy_fs_struct(current->fs);
564 if (!tsk->fs)
565 return -ENOMEM;
566 return 0;
567}
568
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700569static int count_open_files(struct fdtable *fdt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700571 int size = fdt->max_fdset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 int i;
573
574 /* Find the last open fd */
575 for (i = size/(8*sizeof(long)); i > 0; ) {
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700576 if (fdt->open_fds->fds_bits[--i])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 break;
578 }
579 i = (i+1) * 8 * sizeof(long);
580 return i;
581}
582
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700583static struct files_struct *alloc_files(void)
584{
585 struct files_struct *newf;
586 struct fdtable *fdt;
587
588 newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
589 if (!newf)
590 goto out;
591
592 atomic_set(&newf->count, 1);
593
594 spin_lock_init(&newf->file_lock);
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700595 fdt = &newf->fdtab;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700596 fdt->next_fd = 0;
597 fdt->max_fds = NR_OPEN_DEFAULT;
598 fdt->max_fdset = __FD_SETSIZE;
599 fdt->close_on_exec = &newf->close_on_exec_init;
600 fdt->open_fds = &newf->open_fds_init;
601 fdt->fd = &newf->fd_array[0];
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700602 INIT_RCU_HEAD(&fdt->rcu);
603 fdt->free_files = NULL;
604 fdt->next = NULL;
605 rcu_assign_pointer(newf->fdt, fdt);
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700606out:
607 return newf;
608}
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
611{
612 struct files_struct *oldf, *newf;
613 struct file **old_fds, **new_fds;
614 int open_files, size, i, error = 0, expand;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700615 struct fdtable *old_fdt, *new_fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 /*
618 * A background process may not have any files ...
619 */
620 oldf = current->files;
621 if (!oldf)
622 goto out;
623
624 if (clone_flags & CLONE_FILES) {
625 atomic_inc(&oldf->count);
626 goto out;
627 }
628
629 /*
630 * Note: we may be using current for both targets (See exec.c)
631 * This works because we cache current->files (old) as oldf. Don't
632 * break this.
633 */
634 tsk->files = NULL;
635 error = -ENOMEM;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700636 newf = alloc_files();
637 if (!newf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 goto out;
639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 spin_lock(&oldf->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700641 old_fdt = files_fdtable(oldf);
642 new_fdt = files_fdtable(newf);
643 size = old_fdt->max_fdset;
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700644 open_files = count_open_files(old_fdt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 expand = 0;
646
647 /*
648 * Check whether we need to allocate a larger fd array or fd set.
649 * Note: we're not a clone task, so the open count won't change.
650 */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700651 if (open_files > new_fdt->max_fdset) {
652 new_fdt->max_fdset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 expand = 1;
654 }
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700655 if (open_files > new_fdt->max_fds) {
656 new_fdt->max_fds = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 expand = 1;
658 }
659
660 /* if the old fdset gets grown now, we'll only copy up to "size" fds */
661 if (expand) {
662 spin_unlock(&oldf->file_lock);
663 spin_lock(&newf->file_lock);
664 error = expand_files(newf, open_files-1);
665 spin_unlock(&newf->file_lock);
666 if (error < 0)
667 goto out_release;
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700668 new_fdt = files_fdtable(newf);
669 /*
670 * Reacquire the oldf lock and a pointer to its fd table
671 * who knows it may have a new bigger fd table. We need
672 * the latest pointer.
673 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 spin_lock(&oldf->file_lock);
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700675 old_fdt = files_fdtable(oldf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 }
677
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700678 old_fds = old_fdt->fd;
679 new_fds = new_fdt->fd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700681 memcpy(new_fdt->open_fds->fds_bits, old_fdt->open_fds->fds_bits, open_files/8);
682 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 -0700683
684 for (i = open_files; i != 0; i--) {
685 struct file *f = *old_fds++;
686 if (f) {
687 get_file(f);
688 } else {
689 /*
690 * The fd may be claimed in the fd bitmap but not yet
691 * instantiated in the files array if a sibling thread
692 * is partway through open(). So make sure that this
693 * fd is available to the new process.
694 */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700695 FD_CLR(open_files - i, new_fdt->open_fds);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700697 rcu_assign_pointer(*new_fds++, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 }
699 spin_unlock(&oldf->file_lock);
700
701 /* compute the remainder to be cleared */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700702 size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
704 /* This is long word aligned thus could use a optimized version */
705 memset(new_fds, 0, size);
706
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700707 if (new_fdt->max_fdset > open_files) {
708 int left = (new_fdt->max_fdset-open_files)/8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 int start = open_files / (8 * sizeof(unsigned long));
710
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700711 memset(&new_fdt->open_fds->fds_bits[start], 0, left);
712 memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
714
715 tsk->files = newf;
716 error = 0;
717out:
718 return error;
719
720out_release:
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700721 free_fdset (new_fdt->close_on_exec, new_fdt->max_fdset);
722 free_fdset (new_fdt->open_fds, new_fdt->max_fdset);
723 free_fd_array(new_fdt->fd, new_fdt->max_fds);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 kmem_cache_free(files_cachep, newf);
725 goto out;
726}
727
728/*
729 * Helper to unshare the files of the current task.
730 * We don't want to expose copy_files internals to
731 * the exec layer of the kernel.
732 */
733
734int unshare_files(void)
735{
736 struct files_struct *files = current->files;
737 int rc;
738
739 if(!files)
740 BUG();
741
742 /* This can race but the race causes us to copy when we don't
743 need to and drop the copy */
744 if(atomic_read(&files->count) == 1)
745 {
746 atomic_inc(&files->count);
747 return 0;
748 }
749 rc = copy_files(0, current);
750 if(rc)
751 current->files = files;
752 return rc;
753}
754
755EXPORT_SYMBOL(unshare_files);
756
757static inline int copy_sighand(unsigned long clone_flags, struct task_struct * tsk)
758{
759 struct sighand_struct *sig;
760
761 if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
762 atomic_inc(&current->sighand->count);
763 return 0;
764 }
765 sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
766 tsk->sighand = sig;
767 if (!sig)
768 return -ENOMEM;
769 spin_lock_init(&sig->siglock);
770 atomic_set(&sig->count, 1);
771 memcpy(sig->action, current->sighand->action, sizeof(sig->action));
772 return 0;
773}
774
775static inline int copy_signal(unsigned long clone_flags, struct task_struct * tsk)
776{
777 struct signal_struct *sig;
778 int ret;
779
780 if (clone_flags & CLONE_THREAD) {
781 atomic_inc(&current->signal->count);
782 atomic_inc(&current->signal->live);
783 return 0;
784 }
785 sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
786 tsk->signal = sig;
787 if (!sig)
788 return -ENOMEM;
789
790 ret = copy_thread_group_keys(tsk);
791 if (ret < 0) {
792 kmem_cache_free(signal_cachep, sig);
793 return ret;
794 }
795
796 atomic_set(&sig->count, 1);
797 atomic_set(&sig->live, 1);
798 init_waitqueue_head(&sig->wait_chldexit);
799 sig->flags = 0;
800 sig->group_exit_code = 0;
801 sig->group_exit_task = NULL;
802 sig->group_stop_count = 0;
803 sig->curr_target = NULL;
804 init_sigpending(&sig->shared_pending);
805 INIT_LIST_HEAD(&sig->posix_timers);
806
807 sig->it_real_value = sig->it_real_incr = 0;
808 sig->real_timer.function = it_real_fn;
809 sig->real_timer.data = (unsigned long) tsk;
810 init_timer(&sig->real_timer);
811
812 sig->it_virt_expires = cputime_zero;
813 sig->it_virt_incr = cputime_zero;
814 sig->it_prof_expires = cputime_zero;
815 sig->it_prof_incr = cputime_zero;
816
817 sig->tty = current->signal->tty;
818 sig->pgrp = process_group(current);
819 sig->session = current->signal->session;
820 sig->leader = 0; /* session leadership doesn't inherit */
821 sig->tty_old_pgrp = 0;
822
823 sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
824 sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
825 sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
826 sig->sched_time = 0;
827 INIT_LIST_HEAD(&sig->cpu_timers[0]);
828 INIT_LIST_HEAD(&sig->cpu_timers[1]);
829 INIT_LIST_HEAD(&sig->cpu_timers[2]);
830
831 task_lock(current->group_leader);
832 memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
833 task_unlock(current->group_leader);
834
835 if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
836 /*
837 * New sole thread in the process gets an expiry time
838 * of the whole CPU time limit.
839 */
840 tsk->it_prof_expires =
841 secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
842 }
843
844 return 0;
845}
846
847static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
848{
849 unsigned long new_flags = p->flags;
850
Alan Sternd1209d02005-10-19 21:23:51 -0700851 new_flags &= ~(PF_SUPERPRIV | PF_NOFREEZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 new_flags |= PF_FORKNOEXEC;
853 if (!(clone_flags & CLONE_PTRACE))
854 p->ptrace = 0;
855 p->flags = new_flags;
856}
857
858asmlinkage long sys_set_tid_address(int __user *tidptr)
859{
860 current->clear_child_tid = tidptr;
861
862 return current->pid;
863}
864
865/*
866 * This creates a new process as a copy of the old one,
867 * but does not actually start it yet.
868 *
869 * It copies the registers, and all the appropriate
870 * parts of the process environment (as per the clone
871 * flags). The actual kick-off is left to the caller.
872 */
873static task_t *copy_process(unsigned long clone_flags,
874 unsigned long stack_start,
875 struct pt_regs *regs,
876 unsigned long stack_size,
877 int __user *parent_tidptr,
878 int __user *child_tidptr,
879 int pid)
880{
881 int retval;
882 struct task_struct *p = NULL;
883
884 if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
885 return ERR_PTR(-EINVAL);
886
887 /*
888 * Thread groups must share signals as well, and detached threads
889 * can only be started up within the thread group.
890 */
891 if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
892 return ERR_PTR(-EINVAL);
893
894 /*
895 * Shared signal handlers imply shared VM. By way of the above,
896 * thread groups also imply shared VM. Blocking this case allows
897 * for various simplifications in other code.
898 */
899 if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
900 return ERR_PTR(-EINVAL);
901
902 retval = security_task_create(clone_flags);
903 if (retval)
904 goto fork_out;
905
906 retval = -ENOMEM;
907 p = dup_task_struct(current);
908 if (!p)
909 goto fork_out;
910
911 retval = -EAGAIN;
912 if (atomic_read(&p->user->processes) >=
913 p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
914 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
915 p->user != &root_user)
916 goto bad_fork_free;
917 }
918
919 atomic_inc(&p->user->__count);
920 atomic_inc(&p->user->processes);
921 get_group_info(p->group_info);
922
923 /*
924 * If multiple threads are within copy_process(), then this check
925 * triggers too late. This doesn't hurt, the check is only there
926 * to stop root fork bombs.
927 */
928 if (nr_threads >= max_threads)
929 goto bad_fork_cleanup_count;
930
931 if (!try_module_get(p->thread_info->exec_domain->module))
932 goto bad_fork_cleanup_count;
933
934 if (p->binfmt && !try_module_get(p->binfmt->module))
935 goto bad_fork_cleanup_put_domain;
936
937 p->did_exec = 0;
938 copy_flags(clone_flags, p);
939 p->pid = pid;
940 retval = -EFAULT;
941 if (clone_flags & CLONE_PARENT_SETTID)
942 if (put_user(p->pid, parent_tidptr))
943 goto bad_fork_cleanup;
944
945 p->proc_dentry = NULL;
946
947 INIT_LIST_HEAD(&p->children);
948 INIT_LIST_HEAD(&p->sibling);
949 p->vfork_done = NULL;
950 spin_lock_init(&p->alloc_lock);
951 spin_lock_init(&p->proc_lock);
952
953 clear_tsk_thread_flag(p, TIF_SIGPENDING);
954 init_sigpending(&p->pending);
955
956 p->utime = cputime_zero;
957 p->stime = cputime_zero;
958 p->sched_time = 0;
959 p->rchar = 0; /* I/O counter: bytes read */
960 p->wchar = 0; /* I/O counter: bytes written */
961 p->syscr = 0; /* I/O counter: read syscalls */
962 p->syscw = 0; /* I/O counter: write syscalls */
963 acct_clear_integrals(p);
964
965 p->it_virt_expires = cputime_zero;
966 p->it_prof_expires = cputime_zero;
967 p->it_sched_expires = 0;
968 INIT_LIST_HEAD(&p->cpu_timers[0]);
969 INIT_LIST_HEAD(&p->cpu_timers[1]);
970 INIT_LIST_HEAD(&p->cpu_timers[2]);
971
972 p->lock_depth = -1; /* -1 = no lock */
973 do_posix_clock_monotonic_gettime(&p->start_time);
974 p->security = NULL;
975 p->io_context = NULL;
976 p->io_wait = NULL;
977 p->audit_context = NULL;
978#ifdef CONFIG_NUMA
979 p->mempolicy = mpol_copy(p->mempolicy);
980 if (IS_ERR(p->mempolicy)) {
981 retval = PTR_ERR(p->mempolicy);
982 p->mempolicy = NULL;
983 goto bad_fork_cleanup;
984 }
985#endif
986
987 p->tgid = p->pid;
988 if (clone_flags & CLONE_THREAD)
989 p->tgid = current->tgid;
990
991 if ((retval = security_task_alloc(p)))
992 goto bad_fork_cleanup_policy;
993 if ((retval = audit_alloc(p)))
994 goto bad_fork_cleanup_security;
995 /* copy all the process information */
996 if ((retval = copy_semundo(clone_flags, p)))
997 goto bad_fork_cleanup_audit;
998 if ((retval = copy_files(clone_flags, p)))
999 goto bad_fork_cleanup_semundo;
1000 if ((retval = copy_fs(clone_flags, p)))
1001 goto bad_fork_cleanup_files;
1002 if ((retval = copy_sighand(clone_flags, p)))
1003 goto bad_fork_cleanup_fs;
1004 if ((retval = copy_signal(clone_flags, p)))
1005 goto bad_fork_cleanup_sighand;
1006 if ((retval = copy_mm(clone_flags, p)))
1007 goto bad_fork_cleanup_signal;
1008 if ((retval = copy_keys(clone_flags, p)))
1009 goto bad_fork_cleanup_mm;
1010 if ((retval = copy_namespace(clone_flags, p)))
1011 goto bad_fork_cleanup_keys;
1012 retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
1013 if (retval)
1014 goto bad_fork_cleanup_namespace;
1015
1016 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1017 /*
1018 * Clear TID on mm_release()?
1019 */
1020 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
1021
1022 /*
1023 * Syscall tracing should be turned off in the child regardless
1024 * of CLONE_PTRACE.
1025 */
1026 clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
Laurent Viviered75e8d2005-09-03 15:57:18 -07001027#ifdef TIF_SYSCALL_EMU
1028 clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
1029#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030
1031 /* Our parent execution domain becomes current domain
1032 These must match for thread signalling to apply */
1033
1034 p->parent_exec_id = p->self_exec_id;
1035
1036 /* ok, now we should be set up.. */
1037 p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
1038 p->pdeath_signal = 0;
1039 p->exit_state = 0;
1040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 /*
1042 * Ok, make it visible to the rest of the system.
1043 * We dont wake it up yet.
1044 */
1045 p->group_leader = p;
1046 INIT_LIST_HEAD(&p->ptrace_children);
1047 INIT_LIST_HEAD(&p->ptrace_list);
1048
Nick Piggin476d1392005-06-25 14:57:29 -07001049 /* Perform scheduler related setup. Assign this task to a CPU. */
1050 sched_fork(p, clone_flags);
1051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 /* Need tasklist lock for parent etc handling! */
1053 write_lock_irq(&tasklist_lock);
1054
1055 /*
Nick Piggin476d1392005-06-25 14:57:29 -07001056 * The task hasn't been attached yet, so its cpus_allowed mask will
1057 * not be changed, nor will its assigned CPU.
1058 *
1059 * The cpus_allowed mask of the parent may have changed after it was
1060 * copied first time - so re-copy it here, then check the child's CPU
1061 * to ensure it is on a valid CPU (and if not, just force it back to
1062 * parent's CPU). This avoids alot of nasty races.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 */
1064 p->cpus_allowed = current->cpus_allowed;
Srivatsa Vaddagiri26ff6ad2005-09-16 19:27:40 -07001065 if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
1066 !cpu_online(task_cpu(p))))
Nick Piggin476d1392005-06-25 14:57:29 -07001067 set_task_cpu(p, smp_processor_id());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
1069 /*
1070 * Check for pending SIGKILL! The new thread should not be allowed
1071 * to slip out of an OOM kill. (or normal SIGKILL.)
1072 */
1073 if (sigismember(&current->pending.signal, SIGKILL)) {
1074 write_unlock_irq(&tasklist_lock);
1075 retval = -EINTR;
1076 goto bad_fork_cleanup_namespace;
1077 }
1078
1079 /* CLONE_PARENT re-uses the old parent */
1080 if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
1081 p->real_parent = current->real_parent;
1082 else
1083 p->real_parent = current;
1084 p->parent = p->real_parent;
1085
1086 if (clone_flags & CLONE_THREAD) {
1087 spin_lock(&current->sighand->siglock);
1088 /*
1089 * Important: if an exit-all has been started then
1090 * do not create this new thread - the whole thread
1091 * group is supposed to exit anyway.
1092 */
1093 if (current->signal->flags & SIGNAL_GROUP_EXIT) {
1094 spin_unlock(&current->sighand->siglock);
1095 write_unlock_irq(&tasklist_lock);
1096 retval = -EAGAIN;
1097 goto bad_fork_cleanup_namespace;
1098 }
1099 p->group_leader = current->group_leader;
1100
1101 if (current->signal->group_stop_count > 0) {
1102 /*
1103 * There is an all-stop in progress for the group.
1104 * We ourselves will stop as soon as we check signals.
1105 * Make the new thread part of that group stop too.
1106 */
1107 current->signal->group_stop_count++;
1108 set_tsk_thread_flag(p, TIF_SIGPENDING);
1109 }
1110
1111 if (!cputime_eq(current->signal->it_virt_expires,
1112 cputime_zero) ||
1113 !cputime_eq(current->signal->it_prof_expires,
1114 cputime_zero) ||
1115 current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
1116 !list_empty(&current->signal->cpu_timers[0]) ||
1117 !list_empty(&current->signal->cpu_timers[1]) ||
1118 !list_empty(&current->signal->cpu_timers[2])) {
1119 /*
1120 * Have child wake up on its first tick to check
1121 * for process CPU timers.
1122 */
1123 p->it_prof_expires = jiffies_to_cputime(1);
1124 }
1125
1126 spin_unlock(&current->sighand->siglock);
1127 }
1128
Jens Axboe22e2c502005-06-27 10:55:12 +02001129 /*
1130 * inherit ioprio
1131 */
1132 p->ioprio = current->ioprio;
1133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 SET_LINKS(p);
1135 if (unlikely(p->ptrace & PT_PTRACED))
1136 __ptrace_link(p, current->parent);
1137
1138 cpuset_fork(p);
1139
1140 attach_pid(p, PIDTYPE_PID, p->pid);
1141 attach_pid(p, PIDTYPE_TGID, p->tgid);
1142 if (thread_group_leader(p)) {
1143 attach_pid(p, PIDTYPE_PGID, process_group(p));
1144 attach_pid(p, PIDTYPE_SID, p->signal->session);
1145 if (p->pid)
1146 __get_cpu_var(process_counts)++;
1147 }
1148
Jason Baronb0d62e62005-09-09 13:02:01 -07001149 if (!current->signal->tty && p->signal->tty)
1150 p->signal->tty = NULL;
1151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 nr_threads++;
1153 total_forks++;
1154 write_unlock_irq(&tasklist_lock);
1155 retval = 0;
1156
1157fork_out:
1158 if (retval)
1159 return ERR_PTR(retval);
1160 return p;
1161
1162bad_fork_cleanup_namespace:
1163 exit_namespace(p);
1164bad_fork_cleanup_keys:
1165 exit_keys(p);
1166bad_fork_cleanup_mm:
1167 if (p->mm)
1168 mmput(p->mm);
1169bad_fork_cleanup_signal:
1170 exit_signal(p);
1171bad_fork_cleanup_sighand:
1172 exit_sighand(p);
1173bad_fork_cleanup_fs:
1174 exit_fs(p); /* blocking */
1175bad_fork_cleanup_files:
1176 exit_files(p); /* blocking */
1177bad_fork_cleanup_semundo:
1178 exit_sem(p);
1179bad_fork_cleanup_audit:
1180 audit_free(p);
1181bad_fork_cleanup_security:
1182 security_task_free(p);
1183bad_fork_cleanup_policy:
1184#ifdef CONFIG_NUMA
1185 mpol_free(p->mempolicy);
1186#endif
1187bad_fork_cleanup:
1188 if (p->binfmt)
1189 module_put(p->binfmt->module);
1190bad_fork_cleanup_put_domain:
1191 module_put(p->thread_info->exec_domain->module);
1192bad_fork_cleanup_count:
1193 put_group_info(p->group_info);
1194 atomic_dec(&p->user->processes);
1195 free_uid(p->user);
1196bad_fork_free:
1197 free_task(p);
1198 goto fork_out;
1199}
1200
1201struct pt_regs * __devinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
1202{
1203 memset(regs, 0, sizeof(struct pt_regs));
1204 return regs;
1205}
1206
1207task_t * __devinit fork_idle(int cpu)
1208{
1209 task_t *task;
1210 struct pt_regs regs;
1211
1212 task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL, NULL, 0);
1213 if (!task)
1214 return ERR_PTR(-ENOMEM);
1215 init_idle(task, cpu);
1216 unhash_process(task);
1217 return task;
1218}
1219
1220static inline int fork_traceflag (unsigned clone_flags)
1221{
1222 if (clone_flags & CLONE_UNTRACED)
1223 return 0;
1224 else if (clone_flags & CLONE_VFORK) {
1225 if (current->ptrace & PT_TRACE_VFORK)
1226 return PTRACE_EVENT_VFORK;
1227 } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
1228 if (current->ptrace & PT_TRACE_CLONE)
1229 return PTRACE_EVENT_CLONE;
1230 } else if (current->ptrace & PT_TRACE_FORK)
1231 return PTRACE_EVENT_FORK;
1232
1233 return 0;
1234}
1235
1236/*
1237 * Ok, this is the main fork-routine.
1238 *
1239 * It copies the process, and if successful kick-starts
1240 * it and waits for it to finish using the VM if required.
1241 */
1242long do_fork(unsigned long clone_flags,
1243 unsigned long stack_start,
1244 struct pt_regs *regs,
1245 unsigned long stack_size,
1246 int __user *parent_tidptr,
1247 int __user *child_tidptr)
1248{
1249 struct task_struct *p;
1250 int trace = 0;
1251 long pid = alloc_pidmap();
1252
1253 if (pid < 0)
1254 return -EAGAIN;
1255 if (unlikely(current->ptrace)) {
1256 trace = fork_traceflag (clone_flags);
1257 if (trace)
1258 clone_flags |= CLONE_PTRACE;
1259 }
1260
1261 p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
1262 /*
1263 * Do this prior waking up the new thread - the thread pointer
1264 * might get invalid after that point, if the thread exits quickly.
1265 */
1266 if (!IS_ERR(p)) {
1267 struct completion vfork;
1268
1269 if (clone_flags & CLONE_VFORK) {
1270 p->vfork_done = &vfork;
1271 init_completion(&vfork);
1272 }
1273
1274 if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
1275 /*
1276 * We'll start up with an immediate SIGSTOP.
1277 */
1278 sigaddset(&p->pending.signal, SIGSTOP);
1279 set_tsk_thread_flag(p, TIF_SIGPENDING);
1280 }
1281
1282 if (!(clone_flags & CLONE_STOPPED))
1283 wake_up_new_task(p, clone_flags);
1284 else
1285 p->state = TASK_STOPPED;
1286
1287 if (unlikely (trace)) {
1288 current->ptrace_message = pid;
1289 ptrace_notify ((trace << 8) | SIGTRAP);
1290 }
1291
1292 if (clone_flags & CLONE_VFORK) {
1293 wait_for_completion(&vfork);
1294 if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))
1295 ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
1296 }
1297 } else {
1298 free_pidmap(pid);
1299 pid = PTR_ERR(p);
1300 }
1301 return pid;
1302}
1303
1304void __init proc_caches_init(void)
1305{
1306 sighand_cachep = kmem_cache_create("sighand_cache",
1307 sizeof(struct sighand_struct), 0,
1308 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1309 signal_cachep = kmem_cache_create("signal_cache",
1310 sizeof(struct signal_struct), 0,
1311 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1312 files_cachep = kmem_cache_create("files_cache",
1313 sizeof(struct files_struct), 0,
1314 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1315 fs_cachep = kmem_cache_create("fs_cache",
1316 sizeof(struct fs_struct), 0,
1317 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1318 vm_area_cachep = kmem_cache_create("vm_area_struct",
1319 sizeof(struct vm_area_struct), 0,
1320 SLAB_PANIC, NULL, NULL);
1321 mm_cachep = kmem_cache_create("mm_struct",
1322 sizeof(struct mm_struct), 0,
1323 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1324}