[CONNECTOR]: async connector mode.
[linux-2.6/verdex.git] / kernel / fork.c
blob533ce27f4b2c0938f91c948aa682bc992579ba96
1 /*
2 * linux/kernel/fork.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
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()'
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>
38 #include <linux/rcupdate.h>
39 #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>
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>
54 * Protected counters by write_lock_irq(&tasklist_lock)
56 unsigned long total_forks; /* Handle normal Linux uptimes. */
57 int nr_threads; /* The idle threads do not count.. */
59 int max_threads; /* tunable limit on nr_threads */
61 DEFINE_PER_CPU(unsigned long, process_counts) = 0;
63 __cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
65 EXPORT_SYMBOL(tasklist_lock);
67 int nr_processes(void)
69 int cpu;
70 int total = 0;
72 for_each_online_cpu(cpu)
73 total += per_cpu(process_counts, cpu);
75 return total;
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))
81 static kmem_cache_t *task_struct_cachep;
82 #endif
84 /* SLAB cache for signal_struct structures (tsk->signal) */
85 kmem_cache_t *signal_cachep;
87 /* SLAB cache for sighand_struct structures (tsk->sighand) */
88 kmem_cache_t *sighand_cachep;
90 /* SLAB cache for files_struct structures (tsk->files) */
91 kmem_cache_t *files_cachep;
93 /* SLAB cache for fs_struct structures (tsk->fs) */
94 kmem_cache_t *fs_cachep;
96 /* SLAB cache for vm_area_struct structures */
97 kmem_cache_t *vm_area_cachep;
99 /* SLAB cache for mm_struct structures (tsk->mm) */
100 static kmem_cache_t *mm_cachep;
102 void free_task(struct task_struct *tsk)
104 free_thread_info(tsk->thread_info);
105 free_task_struct(tsk);
107 EXPORT_SYMBOL(free_task);
109 void __put_task_struct(struct task_struct *tsk)
111 WARN_ON(!(tsk->exit_state & (EXIT_DEAD | EXIT_ZOMBIE)));
112 WARN_ON(atomic_read(&tsk->usage));
113 WARN_ON(tsk == current);
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);
121 if (!profile_handoff_task(tsk))
122 free_task(tsk);
125 void __init fork_init(unsigned long mempages)
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
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.
142 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
145 * we need to allow at least 20 threads to boot a system
147 if(max_threads < 20)
148 max_threads = 20;
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];
156 static struct task_struct *dup_task_struct(struct task_struct *orig)
158 struct task_struct *tsk;
159 struct thread_info *ti;
161 prepare_to_copy(orig);
163 tsk = alloc_task_struct();
164 if (!tsk)
165 return NULL;
167 ti = alloc_thread_info(tsk);
168 if (!ti) {
169 free_task_struct(tsk);
170 return NULL;
173 *ti = *orig->thread_info;
174 *tsk = *orig;
175 tsk->thread_info = ti;
176 ti->task = tsk;
178 /* One for us, one for whoever does the "release_task()" (usually parent) */
179 atomic_set(&tsk->usage,2);
180 atomic_set(&tsk->fs_excl, 0);
181 return tsk;
184 #ifdef CONFIG_MMU
185 static inline int dup_mmap(struct mm_struct * mm, struct mm_struct * oldmm)
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;
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;
199 mm->cached_hole_size = ~0UL;
200 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;
209 for (mpnt = current->mm->mmap ; mpnt ; mpnt = mpnt->vm_next) {
210 struct file *file;
212 if (mpnt->vm_flags & VM_DONTCOPY) {
213 long pages = vma_pages(mpnt);
214 mm->total_vm -= pages;
215 __vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
216 -pages);
217 continue;
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;
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);
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);
256 * Link in the new vma and copy the page table entries:
257 * 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.
261 spin_lock(&mm->page_table_lock);
262 *pprev = tmp;
263 pprev = &tmp->vm_next;
265 __vma_link_rb(mm, tmp, rb_link, rb_parent);
266 rb_link = &tmp->vm_rb.rb_right;
267 rb_parent = &tmp->vm_rb;
269 mm->map_count++;
270 retval = copy_page_range(mm, current->mm, tmp);
271 spin_unlock(&mm->page_table_lock);
273 if (tmp->vm_ops && tmp->vm_ops->open)
274 tmp->vm_ops->open(tmp);
276 if (retval)
277 goto out;
279 retval = 0;
281 out:
282 flush_tlb_mm(current->mm);
283 up_write(&oldmm->mmap_sem);
284 return retval;
285 fail_nomem_policy:
286 kmem_cache_free(vm_area_cachep, tmp);
287 fail_nomem:
288 retval = -ENOMEM;
289 vm_unacct_memory(charge);
290 goto out;
293 static inline int mm_alloc_pgd(struct mm_struct * mm)
295 mm->pgd = pgd_alloc(mm);
296 if (unlikely(!mm->pgd))
297 return -ENOMEM;
298 return 0;
301 static inline void mm_free_pgd(struct mm_struct * mm)
303 pgd_free(mm->pgd);
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 */
311 __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
313 #define allocate_mm() (kmem_cache_alloc(mm_cachep, SLAB_KERNEL))
314 #define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
316 #include <linux/init_task.h>
318 static struct mm_struct * mm_init(struct mm_struct * mm)
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;
331 mm->cached_hole_size = ~0UL;
333 if (likely(!mm_alloc_pgd(mm))) {
334 mm->def_flags = 0;
335 return mm;
337 free_mm(mm);
338 return NULL;
342 * Allocate and initialize an mm_struct.
344 struct mm_struct * mm_alloc(void)
346 struct mm_struct * mm;
348 mm = allocate_mm();
349 if (mm) {
350 memset(mm, 0, sizeof(*mm));
351 mm = mm_init(mm);
353 return mm;
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.
361 void fastcall __mmdrop(struct mm_struct *mm)
363 BUG_ON(mm == &init_mm);
364 mm_free_pgd(mm);
365 destroy_context(mm);
366 free_mm(mm);
370 * Decrement the use count and release all resources for an mm.
372 void mmput(struct mm_struct *mm)
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);
382 put_swap_token(mm);
383 mmdrop(mm);
386 EXPORT_SYMBOL_GPL(mmput);
389 * get_task_mm - acquire a reference to the task's mm
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.
397 struct mm_struct *get_task_mm(struct task_struct *task)
399 struct mm_struct *mm;
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);
409 task_unlock(task);
410 return mm;
412 EXPORT_SYMBOL_GPL(get_task_mm);
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.
418 * mm_release is called after a mm_struct has been removed
419 * from the current process.
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
427 void mm_release(struct task_struct *tsk, struct mm_struct *mm)
429 struct completion *vfork_done = tsk->vfork_done;
431 /* Get rid of any cached register state */
432 deactivate_mm(tsk, mm);
434 /* notify parent sleeping on vfork() */
435 if (vfork_done) {
436 tsk->vfork_done = NULL;
437 complete(vfork_done);
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;
444 * We don't check the error code - if userspace has
445 * not set up a proper pointer then tough luck.
447 put_user(0, tidptr);
448 sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
452 static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
454 struct mm_struct * mm, *oldmm;
455 int retval;
457 tsk->min_flt = tsk->maj_flt = 0;
458 tsk->nvcsw = tsk->nivcsw = 0;
460 tsk->mm = NULL;
461 tsk->active_mm = NULL;
464 * Are we cloning a kernel thread?
466 * We need to steal a active VM for that..
468 oldmm = current->mm;
469 if (!oldmm)
470 return 0;
472 if (clone_flags & CLONE_VM) {
473 atomic_inc(&oldmm->mm_users);
474 mm = oldmm;
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.
481 spin_unlock_wait(&oldmm->page_table_lock);
482 goto good_mm;
485 retval = -ENOMEM;
486 mm = allocate_mm();
487 if (!mm)
488 goto fail_nomem;
490 /* Copy the current MM stuff.. */
491 memcpy(mm, oldmm, sizeof(*mm));
492 if (!mm_init(mm))
493 goto fail_nomem;
495 if (init_new_context(tsk,mm))
496 goto fail_nocontext;
498 retval = dup_mmap(mm, oldmm);
499 if (retval)
500 goto free_pt;
502 mm->hiwater_rss = get_mm_counter(mm,rss);
503 mm->hiwater_vm = mm->total_vm;
505 good_mm:
506 tsk->mm = mm;
507 tsk->active_mm = mm;
508 return 0;
510 free_pt:
511 mmput(mm);
512 fail_nomem:
513 return retval;
515 fail_nocontext:
517 * If init_new_context() failed, we cannot use mmput() to free the mm
518 * because it calls destroy_context()
520 mm_free_pgd(mm);
521 free_mm(mm);
522 return retval;
525 static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old)
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;
545 read_unlock(&old->lock);
547 return fs;
550 struct fs_struct *copy_fs_struct(struct fs_struct *old)
552 return __copy_fs_struct(old);
555 EXPORT_SYMBOL_GPL(copy_fs_struct);
557 static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
559 if (clone_flags & CLONE_FS) {
560 atomic_inc(&current->fs->count);
561 return 0;
563 tsk->fs = __copy_fs_struct(current->fs);
564 if (!tsk->fs)
565 return -ENOMEM;
566 return 0;
569 static int count_open_files(struct fdtable *fdt)
571 int size = fdt->max_fdset;
572 int i;
574 /* Find the last open fd */
575 for (i = size/(8*sizeof(long)); i > 0; ) {
576 if (fdt->open_fds->fds_bits[--i])
577 break;
579 i = (i+1) * 8 * sizeof(long);
580 return i;
583 static struct files_struct *alloc_files(void)
585 struct files_struct *newf;
586 struct fdtable *fdt;
588 newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
589 if (!newf)
590 goto out;
592 atomic_set(&newf->count, 1);
594 spin_lock_init(&newf->file_lock);
595 fdt = &newf->fdtab;
596 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];
602 INIT_RCU_HEAD(&fdt->rcu);
603 fdt->free_files = NULL;
604 fdt->next = NULL;
605 rcu_assign_pointer(newf->fdt, fdt);
606 out:
607 return newf;
610 static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
612 struct files_struct *oldf, *newf;
613 struct file **old_fds, **new_fds;
614 int open_files, size, i, error = 0, expand;
615 struct fdtable *old_fdt, *new_fdt;
618 * A background process may not have any files ...
620 oldf = current->files;
621 if (!oldf)
622 goto out;
624 if (clone_flags & CLONE_FILES) {
625 atomic_inc(&oldf->count);
626 goto out;
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.
634 tsk->files = NULL;
635 error = -ENOMEM;
636 newf = alloc_files();
637 if (!newf)
638 goto out;
640 spin_lock(&oldf->file_lock);
641 old_fdt = files_fdtable(oldf);
642 new_fdt = files_fdtable(newf);
643 size = old_fdt->max_fdset;
644 open_files = count_open_files(old_fdt);
645 expand = 0;
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.
651 if (open_files > new_fdt->max_fdset) {
652 new_fdt->max_fdset = 0;
653 expand = 1;
655 if (open_files > new_fdt->max_fds) {
656 new_fdt->max_fds = 0;
657 expand = 1;
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;
668 new_fdt = files_fdtable(newf);
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.
674 spin_lock(&oldf->file_lock);
675 old_fdt = files_fdtable(oldf);
678 old_fds = old_fdt->fd;
679 new_fds = new_fdt->fd;
681 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);
684 for (i = open_files; i != 0; i--) {
685 struct file *f = *old_fds++;
686 if (f) {
687 get_file(f);
688 } else {
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.
695 FD_CLR(open_files - i, new_fdt->open_fds);
697 rcu_assign_pointer(*new_fds++, f);
699 spin_unlock(&oldf->file_lock);
701 /* compute the remainder to be cleared */
702 size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
704 /* This is long word aligned thus could use a optimized version */
705 memset(new_fds, 0, size);
707 if (new_fdt->max_fdset > open_files) {
708 int left = (new_fdt->max_fdset-open_files)/8;
709 int start = open_files / (8 * sizeof(unsigned long));
711 memset(&new_fdt->open_fds->fds_bits[start], 0, left);
712 memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
715 tsk->files = newf;
716 error = 0;
717 out:
718 return error;
720 out_release:
721 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);
724 kmem_cache_free(files_cachep, newf);
725 goto out;
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.
734 int unshare_files(void)
736 struct files_struct *files = current->files;
737 int rc;
739 if(!files)
740 BUG();
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)
746 atomic_inc(&files->count);
747 return 0;
749 rc = copy_files(0, current);
750 if(rc)
751 current->files = files;
752 return rc;
755 EXPORT_SYMBOL(unshare_files);
757 static inline int copy_sighand(unsigned long clone_flags, struct task_struct * tsk)
759 struct sighand_struct *sig;
761 if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
762 atomic_inc(&current->sighand->count);
763 return 0;
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;
775 static inline int copy_signal(unsigned long clone_flags, struct task_struct * tsk)
777 struct signal_struct *sig;
778 int ret;
780 if (clone_flags & CLONE_THREAD) {
781 atomic_inc(&current->signal->count);
782 atomic_inc(&current->signal->live);
783 return 0;
785 sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
786 tsk->signal = sig;
787 if (!sig)
788 return -ENOMEM;
790 ret = copy_thread_group_keys(tsk);
791 if (ret < 0) {
792 kmem_cache_free(signal_cachep, sig);
793 return ret;
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);
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);
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;
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;
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]);
831 task_lock(current->group_leader);
832 memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
833 task_unlock(current->group_leader);
835 if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
837 * New sole thread in the process gets an expiry time
838 * of the whole CPU time limit.
840 tsk->it_prof_expires =
841 secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
844 return 0;
847 static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
849 unsigned long new_flags = p->flags;
851 new_flags &= ~PF_SUPERPRIV;
852 new_flags |= PF_FORKNOEXEC;
853 if (!(clone_flags & CLONE_PTRACE))
854 p->ptrace = 0;
855 p->flags = new_flags;
858 asmlinkage long sys_set_tid_address(int __user *tidptr)
860 current->clear_child_tid = tidptr;
862 return current->pid;
866 * This creates a new process as a copy of the old one,
867 * but does not actually start it yet.
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.
873 static 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)
881 int retval;
882 struct task_struct *p = NULL;
884 if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
885 return ERR_PTR(-EINVAL);
888 * Thread groups must share signals as well, and detached threads
889 * can only be started up within the thread group.
891 if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
892 return ERR_PTR(-EINVAL);
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.
899 if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
900 return ERR_PTR(-EINVAL);
902 retval = security_task_create(clone_flags);
903 if (retval)
904 goto fork_out;
906 retval = -ENOMEM;
907 p = dup_task_struct(current);
908 if (!p)
909 goto fork_out;
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;
919 atomic_inc(&p->user->__count);
920 atomic_inc(&p->user->processes);
921 get_group_info(p->group_info);
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.
928 if (nr_threads >= max_threads)
929 goto bad_fork_cleanup_count;
931 if (!try_module_get(p->thread_info->exec_domain->module))
932 goto bad_fork_cleanup_count;
934 if (p->binfmt && !try_module_get(p->binfmt->module))
935 goto bad_fork_cleanup_put_domain;
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;
945 p->proc_dentry = NULL;
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);
953 clear_tsk_thread_flag(p, TIF_SIGPENDING);
954 init_sigpending(&p->pending);
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);
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]);
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;
985 #endif
987 p->tgid = p->pid;
988 if (clone_flags & CLONE_THREAD)
989 p->tgid = current->tgid;
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;
1016 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1018 * Clear TID on mm_release()?
1020 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
1023 * Syscall tracing should be turned off in the child regardless
1024 * of CLONE_PTRACE.
1026 clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
1027 #ifdef TIF_SYSCALL_EMU
1028 clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
1029 #endif
1031 /* Our parent execution domain becomes current domain
1032 These must match for thread signalling to apply */
1034 p->parent_exec_id = p->self_exec_id;
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;
1042 * Ok, make it visible to the rest of the system.
1043 * We dont wake it up yet.
1045 p->group_leader = p;
1046 INIT_LIST_HEAD(&p->ptrace_children);
1047 INIT_LIST_HEAD(&p->ptrace_list);
1049 /* Perform scheduler related setup. Assign this task to a CPU. */
1050 sched_fork(p, clone_flags);
1052 /* Need tasklist lock for parent etc handling! */
1053 write_lock_irq(&tasklist_lock);
1056 * The task hasn't been attached yet, so its cpus_allowed mask will
1057 * not be changed, nor will its assigned CPU.
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.
1064 p->cpus_allowed = current->cpus_allowed;
1065 if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
1066 !cpu_online(task_cpu(p))))
1067 set_task_cpu(p, smp_processor_id());
1070 * Check for pending SIGKILL! The new thread should not be allowed
1071 * to slip out of an OOM kill. (or normal SIGKILL.)
1073 if (sigismember(&current->pending.signal, SIGKILL)) {
1074 write_unlock_irq(&tasklist_lock);
1075 retval = -EINTR;
1076 goto bad_fork_cleanup_namespace;
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;
1086 if (clone_flags & CLONE_THREAD) {
1087 spin_lock(&current->sighand->siglock);
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.
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;
1099 p->group_leader = current->group_leader;
1101 if (current->signal->group_stop_count > 0) {
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.
1107 current->signal->group_stop_count++;
1108 set_tsk_thread_flag(p, TIF_SIGPENDING);
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])) {
1120 * Have child wake up on its first tick to check
1121 * for process CPU timers.
1123 p->it_prof_expires = jiffies_to_cputime(1);
1126 spin_unlock(&current->sighand->siglock);
1130 * inherit ioprio
1132 p->ioprio = current->ioprio;
1134 SET_LINKS(p);
1135 if (unlikely(p->ptrace & PT_PTRACED))
1136 __ptrace_link(p, current->parent);
1138 cpuset_fork(p);
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)++;
1149 if (!current->signal->tty && p->signal->tty)
1150 p->signal->tty = NULL;
1152 nr_threads++;
1153 total_forks++;
1154 write_unlock_irq(&tasklist_lock);
1155 retval = 0;
1157 fork_out:
1158 if (retval)
1159 return ERR_PTR(retval);
1160 return p;
1162 bad_fork_cleanup_namespace:
1163 exit_namespace(p);
1164 bad_fork_cleanup_keys:
1165 exit_keys(p);
1166 bad_fork_cleanup_mm:
1167 if (p->mm)
1168 mmput(p->mm);
1169 bad_fork_cleanup_signal:
1170 exit_signal(p);
1171 bad_fork_cleanup_sighand:
1172 exit_sighand(p);
1173 bad_fork_cleanup_fs:
1174 exit_fs(p); /* blocking */
1175 bad_fork_cleanup_files:
1176 exit_files(p); /* blocking */
1177 bad_fork_cleanup_semundo:
1178 exit_sem(p);
1179 bad_fork_cleanup_audit:
1180 audit_free(p);
1181 bad_fork_cleanup_security:
1182 security_task_free(p);
1183 bad_fork_cleanup_policy:
1184 #ifdef CONFIG_NUMA
1185 mpol_free(p->mempolicy);
1186 #endif
1187 bad_fork_cleanup:
1188 if (p->binfmt)
1189 module_put(p->binfmt->module);
1190 bad_fork_cleanup_put_domain:
1191 module_put(p->thread_info->exec_domain->module);
1192 bad_fork_cleanup_count:
1193 put_group_info(p->group_info);
1194 atomic_dec(&p->user->processes);
1195 free_uid(p->user);
1196 bad_fork_free:
1197 free_task(p);
1198 goto fork_out;
1201 struct pt_regs * __devinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
1203 memset(regs, 0, sizeof(struct pt_regs));
1204 return regs;
1207 task_t * __devinit fork_idle(int cpu)
1209 task_t *task;
1210 struct pt_regs regs;
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;
1220 static inline int fork_traceflag (unsigned clone_flags)
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;
1233 return 0;
1237 * Ok, this is the main fork-routine.
1239 * It copies the process, and if successful kick-starts
1240 * it and waits for it to finish using the VM if required.
1242 long 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)
1249 struct task_struct *p;
1250 int trace = 0;
1251 long pid = alloc_pidmap();
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;
1261 p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
1263 * Do this prior waking up the new thread - the thread pointer
1264 * might get invalid after that point, if the thread exits quickly.
1266 if (!IS_ERR(p)) {
1267 struct completion vfork;
1269 if (clone_flags & CLONE_VFORK) {
1270 p->vfork_done = &vfork;
1271 init_completion(&vfork);
1274 if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
1276 * We'll start up with an immediate SIGSTOP.
1278 sigaddset(&p->pending.signal, SIGSTOP);
1279 set_tsk_thread_flag(p, TIF_SIGPENDING);
1282 if (!(clone_flags & CLONE_STOPPED))
1283 wake_up_new_task(p, clone_flags);
1284 else
1285 p->state = TASK_STOPPED;
1287 if (unlikely (trace)) {
1288 current->ptrace_message = pid;
1289 ptrace_notify ((trace << 8) | SIGTRAP);
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);
1297 } else {
1298 free_pidmap(pid);
1299 pid = PTR_ERR(p);
1301 return pid;
1304 void __init proc_caches_init(void)
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);