1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/slab.h>
15#include <linux/init.h>
16#include <linux/unistd.h>
17#include <linux/module.h>
18#include <linux/vmalloc.h>
19#include <linux/completion.h>
20#include <linux/mnt_namespace.h>
21#include <linux/personality.h>
22#include <linux/mempolicy.h>
23#include <linux/sem.h>
24#include <linux/file.h>
25#include <linux/key.h>
26#include <linux/binfmts.h>
27#include <linux/mman.h>
28#include <linux/fs.h>
29#include <linux/nsproxy.h>
30#include <linux/capability.h>
31#include <linux/cpu.h>
32#include <linux/cgroup.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/task_io_accounting_ops.h>
39#include <linux/rcupdate.h>
40#include <linux/ptrace.h>
41#include <linux/mount.h>
42#include <linux/audit.h>
43#include <linux/profile.h>
44#include <linux/rmap.h>
45#include <linux/acct.h>
46#include <linux/tsacct_kern.h>
47#include <linux/cn_proc.h>
48#include <linux/freezer.h>
49#include <linux/delayacct.h>
50#include <linux/taskstats_kern.h>
51#include <linux/random.h>
52#include <linux/tty.h>
53#include <linux/proc_fs.h>
54
55#include <asm/pgtable.h>
56#include <asm/pgalloc.h>
57#include <asm/uaccess.h>
58#include <asm/mmu_context.h>
59#include <asm/cacheflush.h>
60#include <asm/tlbflush.h>
61
62
63
64
65unsigned long total_forks;
66int nr_threads;
67
68int max_threads;
69
70DEFINE_PER_CPU(unsigned long, process_counts) = 0;
71
72__cacheline_aligned DEFINE_RWLOCK(tasklist_lock);
73
74int nr_processes(void)
75{
76 int cpu;
77 int total = 0;
78
79 for_each_online_cpu(cpu)
80 total += per_cpu(process_counts, cpu);
81
82 return total;
83}
84
85#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
86# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
87# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))
88static struct kmem_cache *task_struct_cachep;
89#endif
90
91
92static struct kmem_cache *signal_cachep;
93
94
95struct kmem_cache *sighand_cachep;
96
97
98struct kmem_cache *files_cachep;
99
100
101struct kmem_cache *fs_cachep;
102
103
104struct kmem_cache *vm_area_cachep;
105
106
107static struct kmem_cache *mm_cachep;
108
109void free_task(struct task_struct *tsk)
110{
111 prop_local_destroy_single(&tsk->dirties);
112 free_thread_info(tsk->stack);
113 rt_mutex_debug_task_free(tsk);
114 free_task_struct(tsk);
115}
116EXPORT_SYMBOL(free_task);
117
118void __put_task_struct(struct task_struct *tsk)
119{
120 WARN_ON(!tsk->exit_state);
121 WARN_ON(atomic_read(&tsk->usage));
122 WARN_ON(tsk == current);
123
124 security_task_free(tsk);
125 free_uid(tsk->user);
126 put_group_info(tsk->group_info);
127 delayacct_tsk_free(tsk);
128
129 if (!profile_handoff_task(tsk))
130 free_task(tsk);
131}
132
133void __init fork_init(unsigned long mempages)
134{
135#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
136#ifndef ARCH_MIN_TASKALIGN
137#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES
138#endif
139
140 task_struct_cachep =
141 kmem_cache_create("task_struct", sizeof(struct task_struct),
142 ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);
143#endif
144
145
146
147
148
149
150 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
151
152
153
154
155 if(max_threads < 20)
156 max_threads = 20;
157
158 init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
159 init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
160 init_task.signal->rlim[RLIMIT_SIGPENDING] =
161 init_task.signal->rlim[RLIMIT_NPROC];
162}
163
164static struct task_struct *dup_task_struct(struct task_struct *orig)
165{
166 struct task_struct *tsk;
167 struct thread_info *ti;
168 int err;
169
170 prepare_to_copy(orig);
171
172 tsk = alloc_task_struct();
173 if (!tsk)
174 return NULL;
175
176 ti = alloc_thread_info(tsk);
177 if (!ti) {
178 free_task_struct(tsk);
179 return NULL;
180 }
181
182 *tsk = *orig;
183 tsk->stack = ti;
184
185 err = prop_local_init_single(&tsk->dirties);
186 if (err) {
187 free_thread_info(ti);
188 free_task_struct(tsk);
189 return NULL;
190 }
191
192 setup_thread_stack(tsk, orig);
193
194#ifdef CONFIG_CC_STACKPROTECTOR
195 tsk->stack_canary = get_random_int();
196#endif
197
198
199 atomic_set(&tsk->usage,2);
200 atomic_set(&tsk->fs_excl, 0);
201#ifdef CONFIG_BLK_DEV_IO_TRACE
202 tsk->btrace_seq = 0;
203#endif
204 tsk->splice_pipe = NULL;
205 return tsk;
206}
207
208#ifdef CONFIG_MMU
209static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
210{
211 struct vm_area_struct *mpnt, *tmp, **pprev;
212 struct rb_node **rb_link, *rb_parent;
213 int retval;
214 unsigned long charge;
215 struct mempolicy *pol;
216
217 down_write(&oldmm->mmap_sem);
218 flush_cache_dup_mm(oldmm);
219
220
221
222 down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
223
224 mm->locked_vm = 0;
225 mm->mmap = NULL;
226 mm->mmap_cache = NULL;
227 mm->free_area_cache = oldmm->mmap_base;
228 mm->cached_hole_size = ~0UL;
229 mm->map_count = 0;
230 cpus_clear(mm->cpu_vm_mask);
231 mm->mm_rb = RB_ROOT;
232 rb_link = &mm->mm_rb.rb_node;
233 rb_parent = NULL;
234 pprev = &mm->mmap;
235
236 for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
237 struct file *file;
238
239 if (mpnt->vm_flags & VM_DONTCOPY) {
240 long pages = vma_pages(mpnt);
241 mm->total_vm -= pages;
242 vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
243 -pages);
244 continue;
245 }
246 charge = 0;
247 if (mpnt->vm_flags & VM_ACCOUNT) {
248 unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
249 if (security_vm_enough_memory(len))
250 goto fail_nomem;
251 charge = len;
252 }
253 tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
254 if (!tmp)
255 goto fail_nomem;
256 *tmp = *mpnt;
257 pol = mpol_copy(vma_policy(mpnt));
258 retval = PTR_ERR(pol);
259 if (IS_ERR(pol))
260 goto fail_nomem_policy;
261 vma_set_policy(tmp, pol);
262 tmp->vm_flags &= ~VM_LOCKED;
263 tmp->vm_mm = mm;
264 tmp->vm_next = NULL;
265 anon_vma_link(tmp);
266 file = tmp->vm_file;
267 if (file) {
268 struct inode *inode = file->f_path.dentry->d_inode;
269 get_file(file);
270 if (tmp->vm_flags & VM_DENYWRITE)
271 atomic_dec(&inode->i_writecount);
272
273
274 spin_lock(&file->f_mapping->i_mmap_lock);
275 tmp->vm_truncate_count = mpnt->vm_truncate_count;
276 flush_dcache_mmap_lock(file->f_mapping);
277 vma_prio_tree_add(tmp, mpnt);
278 flush_dcache_mmap_unlock(file->f_mapping);
279 spin_unlock(&file->f_mapping->i_mmap_lock);
280 }
281
282
283
284
285 *pprev = tmp;
286 pprev = &tmp->vm_next;
287
288 __vma_link_rb(mm, tmp, rb_link, rb_parent);
289 rb_link = &tmp->vm_rb.rb_right;
290 rb_parent = &tmp->vm_rb;
291
292 mm->map_count++;
293 retval = copy_page_range(mm, oldmm, mpnt);
294
295 if (tmp->vm_ops && tmp->vm_ops->open)
296 tmp->vm_ops->open(tmp);
297
298 if (retval)
299 goto out;
300 }
301
302 arch_dup_mmap(oldmm, mm);
303 retval = 0;
304out:
305 up_write(&mm->mmap_sem);
306 flush_tlb_mm(oldmm);
307 up_write(&oldmm->mmap_sem);
308 return retval;
309fail_nomem_policy:
310 kmem_cache_free(vm_area_cachep, tmp);
311fail_nomem:
312 retval = -ENOMEM;
313 vm_unacct_memory(charge);
314 goto out;
315}
316
317static inline int mm_alloc_pgd(struct mm_struct * mm)
318{
319 mm->pgd = pgd_alloc(mm);
320 if (unlikely(!mm->pgd))
321 return -ENOMEM;
322 return 0;
323}
324
325static inline void mm_free_pgd(struct mm_struct * mm)
326{
327 pgd_free(mm->pgd);
328}
329#else
330#define dup_mmap(mm, oldmm) (0)
331#define mm_alloc_pgd(mm) (0)
332#define mm_free_pgd(mm)
333#endif
334
335__cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
336
337#define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
338#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
339
340#include <linux/init_task.h>
341
342static struct mm_struct * mm_init(struct mm_struct * mm)
343{
344 atomic_set(&mm->mm_users, 1);
345 atomic_set(&mm->mm_count, 1);
346 init_rwsem(&mm->mmap_sem);
347 INIT_LIST_HEAD(&mm->mmlist);
348 mm->flags = (current->mm) ? current->mm->flags
349 : MMF_DUMP_FILTER_DEFAULT;
350 mm->core_waiters = 0;
351 mm->nr_ptes = 0;
352 set_mm_counter(mm, file_rss, 0);
353 set_mm_counter(mm, anon_rss, 0);
354 spin_lock_init(&mm->page_table_lock);
355 rwlock_init(&mm->ioctx_list_lock);
356 mm->ioctx_list = NULL;
357 mm->free_area_cache = TASK_UNMAPPED_BASE;
358 mm->cached_hole_size = ~0UL;
359
360 if (likely(!mm_alloc_pgd(mm))) {
361 mm->def_flags = 0;
362 return mm;
363 }
364 free_mm(mm);
365 return NULL;
366}
367
368
369
370
371struct mm_struct * mm_alloc(void)
372{
373 struct mm_struct * mm;
374
375 mm = allocate_mm();
376 if (mm) {
377 memset(mm, 0, sizeof(*mm));
378 mm = mm_init(mm);
379 }
380 return mm;
381}
382
383
384
385
386
387
388void fastcall __mmdrop(struct mm_struct *mm)
389{
390 BUG_ON(mm == &init_mm);
391 mm_free_pgd(mm);
392 destroy_context(mm);
393 free_mm(mm);
394}
395
396
397
398
399void mmput(struct mm_struct *mm)
400{
401 might_sleep();
402
403 if (atomic_dec_and_test(&mm->mm_users)) {
404 exit_aio(mm);
405 exit_mmap(mm);
406 if (!list_empty(&mm->mmlist)) {
407 spin_lock(&mmlist_lock);
408 list_del(&mm->mmlist);
409 spin_unlock(&mmlist_lock);
410 }
411 put_swap_token(mm);
412 mmdrop(mm);
413 }
414}
415EXPORT_SYMBOL_GPL(mmput);
416
417
418
419
420
421
422
423
424
425
426struct mm_struct *get_task_mm(struct task_struct *task)
427{
428 struct mm_struct *mm;
429
430 task_lock(task);
431 mm = task->mm;
432 if (mm) {
433 if (task->flags & PF_BORROWED_MM)
434 mm = NULL;
435 else
436 atomic_inc(&mm->mm_users);
437 }
438 task_unlock(task);
439 return mm;
440}
441EXPORT_SYMBOL_GPL(get_task_mm);
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456void mm_release(struct task_struct *tsk, struct mm_struct *mm)
457{
458 struct completion *vfork_done = tsk->vfork_done;
459
460
461 deactivate_mm(tsk, mm);
462
463
464 if (vfork_done) {
465 tsk->vfork_done = NULL;
466 complete(vfork_done);
467 }
468
469
470
471
472
473
474
475 if (tsk->clear_child_tid
476 && !(tsk->flags & PF_SIGNALED)
477 && atomic_read(&mm->mm_users) > 1) {
478 u32 __user * tidptr = tsk->clear_child_tid;
479 tsk->clear_child_tid = NULL;
480
481
482
483
484
485 put_user(0, tidptr);
486 sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
487 }
488}
489
490
491
492
493
494static struct mm_struct *dup_mm(struct task_struct *tsk)
495{
496 struct mm_struct *mm, *oldmm = current->mm;
497 int err;
498
499 if (!oldmm)
500 return NULL;
501
502 mm = allocate_mm();
503 if (!mm)
504 goto fail_nomem;
505
506 memcpy(mm, oldmm, sizeof(*mm));
507
508
509 mm->token_priority = 0;
510 mm->last_interval = 0;
511
512 if (!mm_init(mm))
513 goto fail_nomem;
514
515 if (init_new_context(tsk, mm))
516 goto fail_nocontext;
517
518 err = dup_mmap(mm, oldmm);
519 if (err)
520 goto free_pt;
521
522 mm->hiwater_rss = get_mm_rss(mm);
523 mm->hiwater_vm = mm->total_vm;
524
525 return mm;
526
527free_pt:
528 mmput(mm);
529
530fail_nomem:
531 return NULL;
532
533fail_nocontext:
534
535
536
537
538 mm_free_pgd(mm);
539 free_mm(mm);
540 return NULL;
541}
542
543static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
544{
545 struct mm_struct * mm, *oldmm;
546 int retval;
547
548 tsk->min_flt = tsk->maj_flt = 0;
549 tsk->nvcsw = tsk->nivcsw = 0;
550
551 tsk->mm = NULL;
552 tsk->active_mm = NULL;
553
554
555
556
557
558
559 oldmm = current->mm;
560 if (!oldmm)
561 return 0;
562
563 if (clone_flags & CLONE_VM) {
564 atomic_inc(&oldmm->mm_users);
565 mm = oldmm;
566 goto good_mm;
567 }
568
569 retval = -ENOMEM;
570 mm = dup_mm(tsk);
571 if (!mm)
572 goto fail_nomem;
573
574good_mm:
575
576 mm->token_priority = 0;
577 mm->last_interval = 0;
578
579 tsk->mm = mm;
580 tsk->active_mm = mm;
581 return 0;
582
583fail_nomem:
584 return retval;
585}
586
587static struct fs_struct *__copy_fs_struct(struct fs_struct *old)
588{
589 struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
590
591 if (fs) {
592 atomic_set(&fs->count, 1);
593 rwlock_init(&fs->lock);
594 fs->umask = old->umask;
595 read_lock(&old->lock);
596 fs->rootmnt = mntget(old->rootmnt);
597 fs->root = dget(old->root);
598 fs->pwdmnt = mntget(old->pwdmnt);
599 fs->pwd = dget(old->pwd);
600 if (old->altroot) {
601 fs->altrootmnt = mntget(old->altrootmnt);
602 fs->altroot = dget(old->altroot);
603 } else {
604 fs->altrootmnt = NULL;
605 fs->altroot = NULL;
606 }
607 read_unlock(&old->lock);
608 }
609 return fs;
610}
611
612struct fs_struct *copy_fs_struct(struct fs_struct *old)
613{
614 return __copy_fs_struct(old);
615}
616
617EXPORT_SYMBOL_GPL(copy_fs_struct);
618
619static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)
620{
621 if (clone_flags & CLONE_FS) {
622 atomic_inc(¤t->fs->count);
623 return 0;
624 }
625 tsk->fs = __copy_fs_struct(current->fs);
626 if (!tsk->fs)
627 return -ENOMEM;
628 return 0;
629}
630
631static int count_open_files(struct fdtable *fdt)
632{
633 int size = fdt->max_fds;
634 int i;
635
636
637 for (i = size/(8*sizeof(long)); i > 0; ) {
638 if (fdt->open_fds->fds_bits[--i])
639 break;
640 }
641 i = (i+1) * 8 * sizeof(long);
642 return i;
643}
644
645static struct files_struct *alloc_files(void)
646{
647 struct files_struct *newf;
648 struct fdtable *fdt;
649
650 newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
651 if (!newf)
652 goto out;
653
654 atomic_set(&newf->count, 1);
655
656 spin_lock_init(&newf->file_lock);
657 newf->next_fd = 0;
658 fdt = &newf->fdtab;
659 fdt->max_fds = NR_OPEN_DEFAULT;
660 fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
661 fdt->open_fds = (fd_set *)&newf->open_fds_init;
662 fdt->fd = &newf->fd_array[0];
663 INIT_RCU_HEAD(&fdt->rcu);
664 fdt->next = NULL;
665 rcu_assign_pointer(newf->fdt, fdt);
666out:
667 return newf;
668}
669
670
671
672
673
674
675static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
676{
677 struct files_struct *newf;
678 struct file **old_fds, **new_fds;
679 int open_files, size, i;
680 struct fdtable *old_fdt, *new_fdt;
681
682 *errorp = -ENOMEM;
683 newf = alloc_files();
684 if (!newf)
685 goto out;
686
687 spin_lock(&oldf->file_lock);
688 old_fdt = files_fdtable(oldf);
689 new_fdt = files_fdtable(newf);
690 open_files = count_open_files(old_fdt);
691
692
693
694
695
696 if (open_files > new_fdt->max_fds) {
697 new_fdt->max_fds = 0;
698 spin_unlock(&oldf->file_lock);
699 spin_lock(&newf->file_lock);
700 *errorp = expand_files(newf, open_files-1);
701 spin_unlock(&newf->file_lock);
702 if (*errorp < 0)
703 goto out_release;
704 new_fdt = files_fdtable(newf);
705
706
707
708
709
710 spin_lock(&oldf->file_lock);
711 old_fdt = files_fdtable(oldf);
712 }
713
714 old_fds = old_fdt->fd;
715 new_fds = new_fdt->fd;
716
717 memcpy(new_fdt->open_fds->fds_bits,
718 old_fdt->open_fds->fds_bits, open_files/8);
719 memcpy(new_fdt->close_on_exec->fds_bits,
720 old_fdt->close_on_exec->fds_bits, open_files/8);
721
722 for (i = open_files; i != 0; i--) {
723 struct file *f = *old_fds++;
724 if (f) {
725 get_file(f);
726 } else {
727
728
729
730
731
732
733 FD_CLR(open_files - i, new_fdt->open_fds);
734 }
735 rcu_assign_pointer(*new_fds++, f);
736 }
737 spin_unlock(&oldf->file_lock);
738
739
740 size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
741
742
743 memset(new_fds, 0, size);
744
745 if (new_fdt->max_fds > open_files) {
746 int left = (new_fdt->max_fds-open_files)/8;
747 int start = open_files / (8 * sizeof(unsigned long));
748
749 memset(&new_fdt->open_fds->fds_bits[start], 0, left);
750 memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
751 }
752
753 return newf;
754
755out_release:
756 kmem_cache_free(files_cachep, newf);
757out:
758 return NULL;
759}
760
761static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
762{
763 struct files_struct *oldf, *newf;
764 int error = 0;
765
766
767
768
769 oldf = current->files;
770 if (!oldf)
771 goto out;
772
773 if (clone_flags & CLONE_FILES) {
774 atomic_inc(&oldf->count);
775 goto out;
776 }
777
778
779
780
781
782
783 tsk->files = NULL;
784 newf = dup_fd(oldf, &error);
785 if (!newf)
786 goto out;
787
788 tsk->files = newf;
789 error = 0;
790out:
791 return error;
792}
793
794
795
796
797
798
799
800int unshare_files(void)
801{
802 struct files_struct *files = current->files;
803 int rc;
804
805 BUG_ON(!files);
806
807
808
809 if(atomic_read(&files->count) == 1)
810 {
811 atomic_inc(&files->count);
812 return 0;
813 }
814 rc = copy_files(0, current);
815 if(rc)
816 current->files = files;
817 return rc;
818}
819
820EXPORT_SYMBOL(unshare_files);
821
822static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
823{
824 struct sighand_struct *sig;
825
826 if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
827 atomic_inc(¤t->sighand->count);
828 return 0;
829 }
830 sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
831 rcu_assign_pointer(tsk->sighand, sig);
832 if (!sig)
833 return -ENOMEM;
834 atomic_set(&sig->count, 1);
835 memcpy(sig->action, current->sighand->action, sizeof(sig->action));
836 return 0;
837}
838
839void __cleanup_sighand(struct sighand_struct *sighand)
840{
841 if (atomic_dec_and_test(&sighand->count))
842 kmem_cache_free(sighand_cachep, sighand);
843}
844
845static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
846{
847 struct signal_struct *sig;
848 int ret;
849
850 if (clone_flags & CLONE_THREAD) {
851 atomic_inc(¤t->signal->count);
852 atomic_inc(¤t->signal->live);
853 return 0;
854 }
855 sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
856 tsk->signal = sig;
857 if (!sig)
858 return -ENOMEM;
859
860 ret = copy_thread_group_keys(tsk);
861 if (ret < 0) {
862 kmem_cache_free(signal_cachep, sig);
863 return ret;
864 }
865
866 atomic_set(&sig->count, 1);
867 atomic_set(&sig->live, 1);
868 init_waitqueue_head(&sig->wait_chldexit);
869 sig->flags = 0;
870 sig->group_exit_code = 0;
871 sig->group_exit_task = NULL;
872 sig->group_stop_count = 0;
873 sig->curr_target = NULL;
874 init_sigpending(&sig->shared_pending);
875 INIT_LIST_HEAD(&sig->posix_timers);
876
877 hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
878 sig->it_real_incr.tv64 = 0;
879 sig->real_timer.function = it_real_fn;
880 sig->tsk = tsk;
881
882 sig->it_virt_expires = cputime_zero;
883 sig->it_virt_incr = cputime_zero;
884 sig->it_prof_expires = cputime_zero;
885 sig->it_prof_incr = cputime_zero;
886
887 sig->leader = 0;
888 sig->tty_old_pgrp = NULL;
889
890 sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
891 sig->gtime = cputime_zero;
892 sig->cgtime = cputime_zero;
893 sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
894 sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
895 sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;
896 sig->sum_sched_runtime = 0;
897 INIT_LIST_HEAD(&sig->cpu_timers[0]);
898 INIT_LIST_HEAD(&sig->cpu_timers[1]);
899 INIT_LIST_HEAD(&sig->cpu_timers[2]);
900 taskstats_tgid_init(sig);
901
902 task_lock(current->group_leader);
903 memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
904 task_unlock(current->group_leader);
905
906 if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
907
908
909
910
911 tsk->it_prof_expires =
912 secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
913 }
914 acct_init_pacct(&sig->pacct);
915
916 tty_audit_fork(sig);
917
918 return 0;
919}
920
921void __cleanup_signal(struct signal_struct *sig)
922{
923 exit_thread_group_keys(sig);
924 kmem_cache_free(signal_cachep, sig);
925}
926
927static void cleanup_signal(struct task_struct *tsk)
928{
929 struct signal_struct *sig = tsk->signal;
930
931 atomic_dec(&sig->live);
932
933 if (atomic_dec_and_test(&sig->count))
934 __cleanup_signal(sig);
935}
936
937static void copy_flags(unsigned long clone_flags, struct task_struct *p)
938{
939 unsigned long new_flags = p->flags;
940
941 new_flags &= ~PF_SUPERPRIV;
942 new_flags |= PF_FORKNOEXEC;
943 if (!(clone_flags & CLONE_PTRACE))
944 p->ptrace = 0;
945 p->flags = new_flags;
946 clear_freeze_flag(p);
947}
948
949asmlinkage long sys_set_tid_address(int __user *tidptr)
950{
951 current->clear_child_tid = tidptr;
952
953 return task_pid_vnr(current);
954}
955
956static void rt_mutex_init_task(struct task_struct *p)
957{
958 spin_lock_init(&p->pi_lock);
959#ifdef CONFIG_RT_MUTEXES
960 plist_head_init(&p->pi_waiters, &p->pi_lock);
961 p->pi_blocked_on = NULL;
962#endif
963}
964
965
966
967
968
969
970
971
972
973static struct task_struct *copy_process(unsigned long clone_flags,
974 unsigned long stack_start,
975 struct pt_regs *regs,
976 unsigned long stack_size,
977 int __user *child_tidptr,
978 struct pid *pid)
979{
980 int retval;
981 struct task_struct *p;
982 int cgroup_callbacks_done = 0;
983
984 if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
985 return ERR_PTR(-EINVAL);
986
987
988
989
990
991 if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
992 return ERR_PTR(-EINVAL);
993
994
995
996
997
998
999 if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
1000 return ERR_PTR(-EINVAL);
1001
1002 retval = security_task_create(clone_flags);
1003 if (retval)
1004 goto fork_out;
1005
1006 retval = -ENOMEM;
1007 p = dup_task_struct(current);
1008 if (!p)
1009 goto fork_out;
1010
1011 rt_mutex_init_task(p);
1012
1013#ifdef CONFIG_TRACE_IRQFLAGS
1014 DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
1015 DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
1016#endif
1017 retval = -EAGAIN;
1018 if (atomic_read(&p->user->processes) >=
1019 p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
1020 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
1021 p->user != current->nsproxy->user_ns->root_user)
1022 goto bad_fork_free;
1023 }
1024
1025 atomic_inc(&p->user->__count);
1026 atomic_inc(&p->user->processes);
1027 get_group_info(p->group_info);
1028
1029
1030
1031
1032
1033
1034 if (nr_threads >= max_threads)
1035 goto bad_fork_cleanup_count;
1036
1037 if (!try_module_get(task_thread_info(p)->exec_domain->module))
1038 goto bad_fork_cleanup_count;
1039
1040 if (p->binfmt && !try_module_get(p->binfmt->module))
1041 goto bad_fork_cleanup_put_domain;
1042
1043 p->did_exec = 0;
1044 delayacct_tsk_init(p);
1045 copy_flags(clone_flags, p);
1046 INIT_LIST_HEAD(&p->children);
1047 INIT_LIST_HEAD(&p->sibling);
1048 p->vfork_done = NULL;
1049 spin_lock_init(&p->alloc_lock);
1050
1051 clear_tsk_thread_flag(p, TIF_SIGPENDING);
1052 init_sigpending(&p->pending);
1053
1054 p->utime = cputime_zero;
1055 p->stime = cputime_zero;
1056 p->gtime = cputime_zero;
1057 p->utimescaled = cputime_zero;
1058 p->stimescaled = cputime_zero;
1059 p->prev_utime = cputime_zero;
1060 p->prev_stime = cputime_zero;
1061
1062#ifdef CONFIG_TASK_XACCT
1063 p->rchar = 0;
1064 p->wchar = 0;
1065 p->syscr = 0;
1066 p->syscw = 0;
1067#endif
1068 task_io_accounting_init(p);
1069 acct_clear_integrals(p);
1070
1071 p->it_virt_expires = cputime_zero;
1072 p->it_prof_expires = cputime_zero;
1073 p->it_sched_expires = 0;
1074 INIT_LIST_HEAD(&p->cpu_timers[0]);
1075 INIT_LIST_HEAD(&p->cpu_timers[1]);
1076 INIT_LIST_HEAD(&p->cpu_timers[2]);
1077
1078 p->lock_depth = -1;
1079 do_posix_clock_monotonic_gettime(&p->start_time);
1080 p->real_start_time = p->start_time;
1081 monotonic_to_bootbased(&p->real_start_time);
1082#ifdef CONFIG_SECURITY
1083 p->security = NULL;
1084#endif
1085 p->io_context = NULL;
1086 p->audit_context = NULL;
1087 cgroup_fork(p);
1088#ifdef CONFIG_NUMA
1089 p->mempolicy = mpol_copy(p->mempolicy);
1090 if (IS_ERR(p->mempolicy)) {
1091 retval = PTR_ERR(p->mempolicy);
1092 p->mempolicy = NULL;
1093 goto bad_fork_cleanup_cgroup;
1094 }
1095 mpol_fix_fork_child_flag(p);
1096#endif
1097#ifdef CONFIG_TRACE_IRQFLAGS
1098 p->irq_events = 0;
1099#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
1100 p->hardirqs_enabled = 1;
1101#else
1102 p->hardirqs_enabled = 0;
1103#endif
1104 p->hardirq_enable_ip = 0;
1105 p->hardirq_enable_event = 0;
1106 p->hardirq_disable_ip = _THIS_IP_;
1107 p->hardirq_disable_event = 0;
1108 p->softirqs_enabled = 1;
1109 p->softirq_enable_ip = _THIS_IP_;
1110 p->softirq_enable_event = 0;
1111 p->softirq_disable_ip = 0;
1112 p->softirq_disable_event = 0;
1113 p->hardirq_context = 0;
1114 p->softirq_context = 0;
1115#endif
1116#ifdef CONFIG_LOCKDEP
1117 p->lockdep_depth = 0;
1118 p->curr_chain_key = 0;
1119 p->lockdep_recursion = 0;
1120#endif
1121
1122#ifdef CONFIG_DEBUG_MUTEXES
1123 p->blocked_on = NULL;
1124#endif
1125
1126
1127 sched_fork(p, clone_flags);
1128
1129 if ((retval = security_task_alloc(p)))
1130 goto bad_fork_cleanup_policy;
1131 if ((retval = audit_alloc(p)))
1132 goto bad_fork_cleanup_security;
1133
1134 if ((retval = copy_semundo(clone_flags, p)))
1135 goto bad_fork_cleanup_audit;
1136 if ((retval = copy_files(clone_flags, p)))
1137 goto bad_fork_cleanup_semundo;
1138 if ((retval = copy_fs(clone_flags, p)))
1139 goto bad_fork_cleanup_files;
1140 if ((retval = copy_sighand(clone_flags, p)))
1141 goto bad_fork_cleanup_fs;
1142 if ((retval = copy_signal(clone_flags, p)))
1143 goto bad_fork_cleanup_sighand;
1144 if ((retval = copy_mm(clone_flags, p)))
1145 goto bad_fork_cleanup_signal;
1146 if ((retval = copy_keys(clone_flags, p)))
1147 goto bad_fork_cleanup_mm;
1148 if ((retval = copy_namespaces(clone_flags, p)))
1149 goto bad_fork_cleanup_keys;
1150 retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
1151 if (retval)
1152 goto bad_fork_cleanup_namespaces;
1153
1154 if (pid != &init_struct_pid) {
1155 retval = -ENOMEM;
1156 pid = alloc_pid(task_active_pid_ns(p));
1157 if (!pid)
1158 goto bad_fork_cleanup_namespaces;
1159
1160 if (clone_flags & CLONE_NEWPID) {
1161 retval = pid_ns_prepare_proc(task_active_pid_ns(p));
1162 if (retval < 0)
1163 goto bad_fork_free_pid;
1164 }
1165 }
1166
1167 p->pid = pid_nr(pid);
1168 p->tgid = p->pid;
1169 if (clone_flags & CLONE_THREAD)
1170 p->tgid = current->tgid;
1171
1172 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1173
1174
1175
1176 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
1177#ifdef CONFIG_FUTEX
1178 p->robust_list = NULL;
1179#ifdef CONFIG_COMPAT
1180 p->compat_robust_list = NULL;
1181#endif
1182 INIT_LIST_HEAD(&p->pi_state_list);
1183 p->pi_state_cache = NULL;
1184#endif
1185
1186
1187
1188 if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
1189 p->sas_ss_sp = p->sas_ss_size = 0;
1190
1191
1192
1193
1194
1195 clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
1196#ifdef TIF_SYSCALL_EMU
1197 clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
1198#endif
1199
1200
1201
1202 p->parent_exec_id = p->self_exec_id;
1203
1204
1205 p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
1206 p->pdeath_signal = 0;
1207 p->exit_state = 0;
1208
1209
1210
1211
1212
1213 p->group_leader = p;
1214 INIT_LIST_HEAD(&p->thread_group);
1215 INIT_LIST_HEAD(&p->ptrace_children);
1216 INIT_LIST_HEAD(&p->ptrace_list);
1217
1218
1219
1220
1221 cgroup_fork_callbacks(p);
1222 cgroup_callbacks_done = 1;
1223
1224
1225 write_lock_irq(&tasklist_lock);
1226
1227
1228 p->ioprio = current->ioprio;
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239 p->cpus_allowed = current->cpus_allowed;
1240 if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
1241 !cpu_online(task_cpu(p))))
1242 set_task_cpu(p, smp_processor_id());
1243
1244
1245 if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
1246 p->real_parent = current->real_parent;
1247 else
1248 p->real_parent = current;
1249 p->parent = p->real_parent;
1250
1251 spin_lock(¤t->sighand->siglock);
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261 recalc_sigpending();
1262 if (signal_pending(current)) {
1263 spin_unlock(¤t->sighand->siglock);
1264 write_unlock_irq(&tasklist_lock);
1265 retval = -ERESTARTNOINTR;
1266 goto bad_fork_free_pid;
1267 }
1268
1269 if (clone_flags & CLONE_THREAD) {
1270 p->group_leader = current->group_leader;
1271 list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
1272
1273 if (!cputime_eq(current->signal->it_virt_expires,
1274 cputime_zero) ||
1275 !cputime_eq(current->signal->it_prof_expires,
1276 cputime_zero) ||
1277 current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
1278 !list_empty(¤t->signal->cpu_timers[0]) ||
1279 !list_empty(¤t->signal->cpu_timers[1]) ||
1280 !list_empty(¤t->signal->cpu_timers[2])) {
1281
1282
1283
1284
1285 p->it_prof_expires = jiffies_to_cputime(1);
1286 }
1287 }
1288
1289 if (likely(p->pid)) {
1290 add_parent(p);
1291 if (unlikely(p->ptrace & PT_PTRACED))
1292 __ptrace_link(p, current->parent);
1293
1294 if (thread_group_leader(p)) {
1295 if (clone_flags & CLONE_NEWPID)
1296 p->nsproxy->pid_ns->child_reaper = p;
1297
1298 p->signal->tty = current->signal->tty;
1299 set_task_pgrp(p, task_pgrp_nr(current));
1300 set_task_session(p, task_session_nr(current));
1301 attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
1302 attach_pid(p, PIDTYPE_SID, task_session(current));
1303 list_add_tail_rcu(&p->tasks, &init_task.tasks);
1304 __get_cpu_var(process_counts)++;
1305 }
1306 attach_pid(p, PIDTYPE_PID, pid);
1307 nr_threads++;
1308 }
1309
1310 total_forks++;
1311 spin_unlock(¤t->sighand->siglock);
1312 write_unlock_irq(&tasklist_lock);
1313 proc_fork_connector(p);
1314 cgroup_post_fork(p);
1315 return p;
1316
1317bad_fork_free_pid:
1318 if (pid != &init_struct_pid)
1319 free_pid(pid);
1320bad_fork_cleanup_namespaces:
1321 exit_task_namespaces(p);
1322bad_fork_cleanup_keys:
1323 exit_keys(p);
1324bad_fork_cleanup_mm:
1325 if (p->mm)
1326 mmput(p->mm);
1327bad_fork_cleanup_signal:
1328 cleanup_signal(p);
1329bad_fork_cleanup_sighand:
1330 __cleanup_sighand(p->sighand);
1331bad_fork_cleanup_fs:
1332 exit_fs(p);
1333bad_fork_cleanup_files:
1334 exit_files(p);
1335bad_fork_cleanup_semundo:
1336 exit_sem(p);
1337bad_fork_cleanup_audit:
1338 audit_free(p);
1339bad_fork_cleanup_security:
1340 security_task_free(p);
1341bad_fork_cleanup_policy:
1342#ifdef CONFIG_NUMA
1343 mpol_free(p->mempolicy);
1344bad_fork_cleanup_cgroup:
1345#endif
1346 cgroup_exit(p, cgroup_callbacks_done);
1347 delayacct_tsk_free(p);
1348 if (p->binfmt)
1349 module_put(p->binfmt->module);
1350bad_fork_cleanup_put_domain:
1351 module_put(task_thread_info(p)->exec_domain->module);
1352bad_fork_cleanup_count:
1353 put_group_info(p->group_info);
1354 atomic_dec(&p->user->processes);
1355 free_uid(p->user);
1356bad_fork_free:
1357 free_task(p);
1358fork_out:
1359 return ERR_PTR(retval);
1360}
1361
1362noinline struct pt_regs * __devinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
1363{
1364 memset(regs, 0, sizeof(struct pt_regs));
1365 return regs;
1366}
1367
1368struct task_struct * __cpuinit fork_idle(int cpu)
1369{
1370 struct task_struct *task;
1371 struct pt_regs regs;
1372
1373 task = copy_process(CLONE_VM, 0, idle_regs(®s), 0, NULL,
1374 &init_struct_pid);
1375 if (!IS_ERR(task))
1376 init_idle(task, cpu);
1377
1378 return task;
1379}
1380
1381static int fork_traceflag(unsigned clone_flags)
1382{
1383 if (clone_flags & CLONE_UNTRACED)
1384 return 0;
1385 else if (clone_flags & CLONE_VFORK) {
1386 if (current->ptrace & PT_TRACE_VFORK)
1387 return PTRACE_EVENT_VFORK;
1388 } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
1389 if (current->ptrace & PT_TRACE_CLONE)
1390 return PTRACE_EVENT_CLONE;
1391 } else if (current->ptrace & PT_TRACE_FORK)
1392 return PTRACE_EVENT_FORK;
1393
1394 return 0;
1395}
1396
1397
1398
1399
1400
1401
1402
1403long do_fork(unsigned long clone_flags,
1404 unsigned long stack_start,
1405 struct pt_regs *regs,
1406 unsigned long stack_size,
1407 int __user *parent_tidptr,
1408 int __user *child_tidptr)
1409{
1410 struct task_struct *p;
1411 int trace = 0;
1412 long nr;
1413
1414 if (unlikely(current->ptrace)) {
1415 trace = fork_traceflag (clone_flags);
1416 if (trace)
1417 clone_flags |= CLONE_PTRACE;
1418 }
1419
1420 p = copy_process(clone_flags, stack_start, regs, stack_size,
1421 child_tidptr, NULL);
1422
1423
1424
1425
1426 if (!IS_ERR(p)) {
1427 struct completion vfork;
1428
1429
1430
1431
1432
1433 nr = (clone_flags & CLONE_NEWPID) ?
1434 task_pid_nr_ns(p, current->nsproxy->pid_ns) :
1435 task_pid_vnr(p);
1436
1437 if (clone_flags & CLONE_PARENT_SETTID)
1438 put_user(nr, parent_tidptr);
1439
1440 if (clone_flags & CLONE_VFORK) {
1441 p->vfork_done = &vfork;
1442 init_completion(&vfork);
1443 }
1444
1445 if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
1446
1447
1448
1449 sigaddset(&p->pending.signal, SIGSTOP);
1450 set_tsk_thread_flag(p, TIF_SIGPENDING);
1451 }
1452
1453 if (!(clone_flags & CLONE_STOPPED))
1454 wake_up_new_task(p, clone_flags);
1455 else
1456 p->state = TASK_STOPPED;
1457
1458 if (unlikely (trace)) {
1459 current->ptrace_message = nr;
1460 ptrace_notify ((trace << 8) | SIGTRAP);
1461 }
1462
1463 if (clone_flags & CLONE_VFORK) {
1464 freezer_do_not_count();
1465 wait_for_completion(&vfork);
1466 freezer_count();
1467 if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
1468 current->ptrace_message = nr;
1469 ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
1470 }
1471 }
1472 } else {
1473 nr = PTR_ERR(p);
1474 }
1475 return nr;
1476}
1477
1478#ifndef ARCH_MIN_MMSTRUCT_ALIGN
1479#define ARCH_MIN_MMSTRUCT_ALIGN 0
1480#endif
1481
1482static void sighand_ctor(struct kmem_cache *cachep, void *data)
1483{
1484 struct sighand_struct *sighand = data;
1485
1486 spin_lock_init(&sighand->siglock);
1487 init_waitqueue_head(&sighand->signalfd_wqh);
1488}
1489
1490void __init proc_caches_init(void)
1491{
1492 sighand_cachep = kmem_cache_create("sighand_cache",
1493 sizeof(struct sighand_struct), 0,
1494 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,
1495 sighand_ctor);
1496 signal_cachep = kmem_cache_create("signal_cache",
1497 sizeof(struct signal_struct), 0,
1498 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1499 files_cachep = kmem_cache_create("files_cache",
1500 sizeof(struct files_struct), 0,
1501 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1502 fs_cachep = kmem_cache_create("fs_cache",
1503 sizeof(struct fs_struct), 0,
1504 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1505 vm_area_cachep = kmem_cache_create("vm_area_struct",
1506 sizeof(struct vm_area_struct), 0,
1507 SLAB_PANIC, NULL);
1508 mm_cachep = kmem_cache_create("mm_struct",
1509 sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
1510 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1511}
1512
1513
1514
1515
1516
1517static void check_unshare_flags(unsigned long *flags_ptr)
1518{
1519
1520
1521
1522
1523 if (*flags_ptr & CLONE_THREAD)
1524 *flags_ptr |= CLONE_VM;
1525
1526
1527
1528
1529 if (*flags_ptr & CLONE_VM)
1530 *flags_ptr |= CLONE_SIGHAND;
1531
1532
1533
1534
1535
1536 if ((*flags_ptr & CLONE_SIGHAND) &&
1537 (atomic_read(¤t->signal->count) > 1))
1538 *flags_ptr |= CLONE_THREAD;
1539
1540
1541
1542
1543 if (*flags_ptr & CLONE_NEWNS)
1544 *flags_ptr |= CLONE_FS;
1545}
1546
1547
1548
1549
1550static int unshare_thread(unsigned long unshare_flags)
1551{
1552 if (unshare_flags & CLONE_THREAD)
1553 return -EINVAL;
1554
1555 return 0;
1556}
1557
1558
1559
1560
1561static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)
1562{
1563 struct fs_struct *fs = current->fs;
1564
1565 if ((unshare_flags & CLONE_FS) &&
1566 (fs && atomic_read(&fs->count) > 1)) {
1567 *new_fsp = __copy_fs_struct(current->fs);
1568 if (!*new_fsp)
1569 return -ENOMEM;
1570 }
1571
1572 return 0;
1573}
1574
1575
1576
1577
1578static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)
1579{
1580 struct sighand_struct *sigh = current->sighand;
1581
1582 if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)
1583 return -EINVAL;
1584 else
1585 return 0;
1586}
1587
1588
1589
1590
1591static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)
1592{
1593 struct mm_struct *mm = current->mm;
1594
1595 if ((unshare_flags & CLONE_VM) &&
1596 (mm && atomic_read(&mm->mm_users) > 1)) {
1597 return -EINVAL;
1598 }
1599
1600 return 0;
1601}
1602
1603
1604
1605
1606static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)
1607{
1608 struct files_struct *fd = current->files;
1609 int error = 0;
1610
1611 if ((unshare_flags & CLONE_FILES) &&
1612 (fd && atomic_read(&fd->count) > 1)) {
1613 *new_fdp = dup_fd(fd, &error);
1614 if (!*new_fdp)
1615 return error;
1616 }
1617
1618 return 0;
1619}
1620
1621
1622
1623
1624
1625static int unshare_semundo(unsigned long unshare_flags, struct sem_undo_list **new_ulistp)
1626{
1627 if (unshare_flags & CLONE_SYSVSEM)
1628 return -EINVAL;
1629
1630 return 0;
1631}
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641asmlinkage long sys_unshare(unsigned long unshare_flags)
1642{
1643 int err = 0;
1644 struct fs_struct *fs, *new_fs = NULL;
1645 struct sighand_struct *new_sigh = NULL;
1646 struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;
1647 struct files_struct *fd, *new_fd = NULL;
1648 struct sem_undo_list *new_ulist = NULL;
1649 struct nsproxy *new_nsproxy = NULL;
1650
1651 check_unshare_flags(&unshare_flags);
1652
1653
1654 err = -EINVAL;
1655 if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|
1656 CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|
1657 CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWUSER|
1658 CLONE_NEWNET))
1659 goto bad_unshare_out;
1660
1661 if ((err = unshare_thread(unshare_flags)))
1662 goto bad_unshare_out;
1663 if ((err = unshare_fs(unshare_flags, &new_fs)))
1664 goto bad_unshare_cleanup_thread;
1665 if ((err = unshare_sighand(unshare_flags, &new_sigh)))
1666 goto bad_unshare_cleanup_fs;
1667 if ((err = unshare_vm(unshare_flags, &new_mm)))
1668 goto bad_unshare_cleanup_sigh;
1669 if ((err = unshare_fd(unshare_flags, &new_fd)))
1670 goto bad_unshare_cleanup_vm;
1671 if ((err = unshare_semundo(unshare_flags, &new_ulist)))
1672 goto bad_unshare_cleanup_fd;
1673 if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,
1674 new_fs)))
1675 goto bad_unshare_cleanup_semundo;
1676
1677 if (new_fs || new_mm || new_fd || new_ulist || new_nsproxy) {
1678
1679 if (new_nsproxy) {
1680 switch_task_namespaces(current, new_nsproxy);
1681 new_nsproxy = NULL;
1682 }
1683
1684 task_lock(current);
1685
1686 if (new_fs) {
1687 fs = current->fs;
1688 current->fs = new_fs;
1689 new_fs = fs;
1690 }
1691
1692 if (new_mm) {
1693 mm = current->mm;
1694 active_mm = current->active_mm;
1695 current->mm = new_mm;
1696 current->active_mm = new_mm;
1697 activate_mm(active_mm, new_mm);
1698 new_mm = mm;
1699 }
1700
1701 if (new_fd) {
1702 fd = current->files;
1703 current->files = new_fd;
1704 new_fd = fd;
1705 }
1706
1707 task_unlock(current);
1708 }
1709
1710 if (new_nsproxy)
1711 put_nsproxy(new_nsproxy);
1712
1713bad_unshare_cleanup_semundo:
1714bad_unshare_cleanup_fd:
1715 if (new_fd)
1716 put_files_struct(new_fd);
1717
1718bad_unshare_cleanup_vm:
1719 if (new_mm)
1720 mmput(new_mm);
1721
1722bad_unshare_cleanup_sigh:
1723 if (new_sigh)
1724 if (atomic_dec_and_test(&new_sigh->count))
1725 kmem_cache_free(sighand_cachep, new_sigh);
1726
1727bad_unshare_cleanup_fs:
1728 if (new_fs)
1729 put_fs_struct(new_fs);
1730
1731bad_unshare_cleanup_thread:
1732bad_unshare_out:
1733 return err;
1734}
1735