fork.c (778d3b0ff0654ad7092bf823fd32010066b12365) fork.c (fb0a685cb95a0267a96153af2f72486f27be5847)
1/*
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

--- 66 unchanged lines hidden (view full) ---

75#include <asm/tlbflush.h>
76
77#include <trace/events/sched.h>
78
79/*
80 * Protected counters by write_lock_irq(&tasklist_lock)
81 */
82unsigned long total_forks; /* Handle normal Linux uptimes. */
1/*
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

--- 66 unchanged lines hidden (view full) ---

75#include <asm/tlbflush.h>
76
77#include <trace/events/sched.h>
78
79/*
80 * Protected counters by write_lock_irq(&tasklist_lock)
81 */
82unsigned long total_forks; /* Handle normal Linux uptimes. */
83int nr_threads; /* The idle threads do not count.. */
83int nr_threads; /* The idle threads do not count.. */
84
85int max_threads; /* tunable limit on nr_threads */
86
87DEFINE_PER_CPU(unsigned long, process_counts) = 0;
88
89__cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
90
91#ifdef CONFIG_PROVE_RCU

--- 135 unchanged lines hidden (view full) ---

227 * value: the thread structures can take up at most half
228 * of memory.
229 */
230 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
231
232 /*
233 * we need to allow at least 20 threads to boot a system
234 */
84
85int max_threads; /* tunable limit on nr_threads */
86
87DEFINE_PER_CPU(unsigned long, process_counts) = 0;
88
89__cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
90
91#ifdef CONFIG_PROVE_RCU

--- 135 unchanged lines hidden (view full) ---

227 * value: the thread structures can take up at most half
228 * of memory.
229 */
230 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
231
232 /*
233 * we need to allow at least 20 threads to boot a system
234 */
235 if(max_threads < 20)
235 if (max_threads < 20)
236 max_threads = 20;
237
238 init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
239 init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
240 init_task.signal->rlim[RLIMIT_SIGPENDING] =
241 init_task.signal->rlim[RLIMIT_NPROC];
242}
243

--- 19 unchanged lines hidden (view full) ---

263 return NULL;
264
265 ti = alloc_thread_info_node(tsk, node);
266 if (!ti) {
267 free_task_struct(tsk);
268 return NULL;
269 }
270
236 max_threads = 20;
237
238 init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
239 init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
240 init_task.signal->rlim[RLIMIT_SIGPENDING] =
241 init_task.signal->rlim[RLIMIT_NPROC];
242}
243

--- 19 unchanged lines hidden (view full) ---

263 return NULL;
264
265 ti = alloc_thread_info_node(tsk, node);
266 if (!ti) {
267 free_task_struct(tsk);
268 return NULL;
269 }
270
271 err = arch_dup_task_struct(tsk, orig);
271 err = arch_dup_task_struct(tsk, orig);
272 if (err)
273 goto out;
274
275 tsk->stack = ti;
276
277 err = prop_local_init_single(&tsk->dirties);
278 if (err)
279 goto out;
280
281 setup_thread_stack(tsk, orig);
282 clear_user_return_notifier(tsk);
283 clear_tsk_need_resched(tsk);
284 stackend = end_of_stack(tsk);
285 *stackend = STACK_END_MAGIC; /* for overflow detection */
286
287#ifdef CONFIG_CC_STACKPROTECTOR
288 tsk->stack_canary = get_random_int();
289#endif
290
272 if (err)
273 goto out;
274
275 tsk->stack = ti;
276
277 err = prop_local_init_single(&tsk->dirties);
278 if (err)
279 goto out;
280
281 setup_thread_stack(tsk, orig);
282 clear_user_return_notifier(tsk);
283 clear_tsk_need_resched(tsk);
284 stackend = end_of_stack(tsk);
285 *stackend = STACK_END_MAGIC; /* for overflow detection */
286
287#ifdef CONFIG_CC_STACKPROTECTOR
288 tsk->stack_canary = get_random_int();
289#endif
290
291 /* One for us, one for whoever does the "release_task()" (usually parent) */
292 atomic_set(&tsk->usage,2);
291 /*
292 * One for us, one for whoever does the "release_task()" (usually
293 * parent)
294 */
295 atomic_set(&tsk->usage, 2);
293#ifdef CONFIG_BLK_DEV_IO_TRACE
294 tsk->btrace_seq = 0;
295#endif
296 tsk->splice_pipe = NULL;
297
298 account_kernel_stack(ti, 1);
299
300 return tsk;

--- 131 unchanged lines hidden (view full) ---

432fail_nomem_policy:
433 kmem_cache_free(vm_area_cachep, tmp);
434fail_nomem:
435 retval = -ENOMEM;
436 vm_unacct_memory(charge);
437 goto out;
438}
439
296#ifdef CONFIG_BLK_DEV_IO_TRACE
297 tsk->btrace_seq = 0;
298#endif
299 tsk->splice_pipe = NULL;
300
301 account_kernel_stack(ti, 1);
302
303 return tsk;

--- 131 unchanged lines hidden (view full) ---

435fail_nomem_policy:
436 kmem_cache_free(vm_area_cachep, tmp);
437fail_nomem:
438 retval = -ENOMEM;
439 vm_unacct_memory(charge);
440 goto out;
441}
442
440static inline int mm_alloc_pgd(struct mm_struct * mm)
443static inline int mm_alloc_pgd(struct mm_struct *mm)
441{
442 mm->pgd = pgd_alloc(mm);
443 if (unlikely(!mm->pgd))
444 return -ENOMEM;
445 return 0;
446}
447
444{
445 mm->pgd = pgd_alloc(mm);
446 if (unlikely(!mm->pgd))
447 return -ENOMEM;
448 return 0;
449}
450
448static inline void mm_free_pgd(struct mm_struct * mm)
451static inline void mm_free_pgd(struct mm_struct *mm)
449{
450 pgd_free(mm, mm->pgd);
451}
452#else
453#define dup_mmap(mm, oldmm) (0)
454#define mm_alloc_pgd(mm) (0)
455#define mm_free_pgd(mm)
456#endif /* CONFIG_MMU */

--- 20 unchanged lines hidden (view full) ---

477static void mm_init_aio(struct mm_struct *mm)
478{
479#ifdef CONFIG_AIO
480 spin_lock_init(&mm->ioctx_lock);
481 INIT_HLIST_HEAD(&mm->ioctx_list);
482#endif
483}
484
452{
453 pgd_free(mm, mm->pgd);
454}
455#else
456#define dup_mmap(mm, oldmm) (0)
457#define mm_alloc_pgd(mm) (0)
458#define mm_free_pgd(mm)
459#endif /* CONFIG_MMU */

--- 20 unchanged lines hidden (view full) ---

480static void mm_init_aio(struct mm_struct *mm)
481{
482#ifdef CONFIG_AIO
483 spin_lock_init(&mm->ioctx_lock);
484 INIT_HLIST_HEAD(&mm->ioctx_list);
485#endif
486}
487
485static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)
488static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p)
486{
487 atomic_set(&mm->mm_users, 1);
488 atomic_set(&mm->mm_count, 1);
489 init_rwsem(&mm->mmap_sem);
490 INIT_LIST_HEAD(&mm->mmlist);
491 mm->flags = (current->mm) ?
492 (current->mm->flags & MMF_INIT_MASK) : default_dump_filter;
493 mm->core_state = NULL;

--- 14 unchanged lines hidden (view full) ---

508
509 free_mm(mm);
510 return NULL;
511}
512
513/*
514 * Allocate and initialize an mm_struct.
515 */
489{
490 atomic_set(&mm->mm_users, 1);
491 atomic_set(&mm->mm_count, 1);
492 init_rwsem(&mm->mmap_sem);
493 INIT_LIST_HEAD(&mm->mmlist);
494 mm->flags = (current->mm) ?
495 (current->mm->flags & MMF_INIT_MASK) : default_dump_filter;
496 mm->core_state = NULL;

--- 14 unchanged lines hidden (view full) ---

511
512 free_mm(mm);
513 return NULL;
514}
515
516/*
517 * Allocate and initialize an mm_struct.
518 */
516struct mm_struct * mm_alloc(void)
519struct mm_struct *mm_alloc(void)
517{
520{
518 struct mm_struct * mm;
521 struct mm_struct *mm;
519
520 mm = allocate_mm();
521 if (!mm)
522 return NULL;
523
524 memset(mm, 0, sizeof(*mm));
525 mm_init_cpumask(mm);
526 return mm_init(mm, current);

--- 51 unchanged lines hidden (view full) ---

578void added_exe_file_vma(struct mm_struct *mm)
579{
580 mm->num_exe_file_vmas++;
581}
582
583void removed_exe_file_vma(struct mm_struct *mm)
584{
585 mm->num_exe_file_vmas--;
522
523 mm = allocate_mm();
524 if (!mm)
525 return NULL;
526
527 memset(mm, 0, sizeof(*mm));
528 mm_init_cpumask(mm);
529 return mm_init(mm, current);

--- 51 unchanged lines hidden (view full) ---

581void added_exe_file_vma(struct mm_struct *mm)
582{
583 mm->num_exe_file_vmas++;
584}
585
586void removed_exe_file_vma(struct mm_struct *mm)
587{
588 mm->num_exe_file_vmas--;
586 if ((mm->num_exe_file_vmas == 0) && mm->exe_file){
589 if ((mm->num_exe_file_vmas == 0) && mm->exe_file) {
587 fput(mm->exe_file);
588 mm->exe_file = NULL;
589 }
590
591}
592
593void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file)
594{

--- 175 unchanged lines hidden (view full) ---

770 * If init_new_context() failed, we cannot use mmput() to free the mm
771 * because it calls destroy_context()
772 */
773 mm_free_pgd(mm);
774 free_mm(mm);
775 return NULL;
776}
777
590 fput(mm->exe_file);
591 mm->exe_file = NULL;
592 }
593
594}
595
596void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file)
597{

--- 175 unchanged lines hidden (view full) ---

773 * If init_new_context() failed, we cannot use mmput() to free the mm
774 * because it calls destroy_context()
775 */
776 mm_free_pgd(mm);
777 free_mm(mm);
778 return NULL;
779}
780
778static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
781static int copy_mm(unsigned long clone_flags, struct task_struct *tsk)
779{
782{
780 struct mm_struct * mm, *oldmm;
783 struct mm_struct *mm, *oldmm;
781 int retval;
782
783 tsk->min_flt = tsk->maj_flt = 0;
784 tsk->nvcsw = tsk->nivcsw = 0;
785#ifdef CONFIG_DETECT_HUNG_TASK
786 tsk->last_switch_count = tsk->nvcsw + tsk->nivcsw;
787#endif
788

--- 50 unchanged lines hidden (view full) ---

839 return 0;
840 }
841 tsk->fs = copy_fs_struct(fs);
842 if (!tsk->fs)
843 return -ENOMEM;
844 return 0;
845}
846
784 int retval;
785
786 tsk->min_flt = tsk->maj_flt = 0;
787 tsk->nvcsw = tsk->nivcsw = 0;
788#ifdef CONFIG_DETECT_HUNG_TASK
789 tsk->last_switch_count = tsk->nvcsw + tsk->nivcsw;
790#endif
791

--- 50 unchanged lines hidden (view full) ---

842 return 0;
843 }
844 tsk->fs = copy_fs_struct(fs);
845 if (!tsk->fs)
846 return -ENOMEM;
847 return 0;
848}
849
847static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
850static int copy_files(unsigned long clone_flags, struct task_struct *tsk)
848{
849 struct files_struct *oldf, *newf;
850 int error = 0;
851
852 /*
853 * A background process may not have any files ...
854 */
855 oldf = current->files;

--- 305 unchanged lines hidden (view full) ---

1161 monotonic_to_bootbased(&p->real_start_time);
1162 p->io_context = NULL;
1163 p->audit_context = NULL;
1164 if (clone_flags & CLONE_THREAD)
1165 threadgroup_fork_read_lock(current);
1166 cgroup_fork(p);
1167#ifdef CONFIG_NUMA
1168 p->mempolicy = mpol_dup(p->mempolicy);
851{
852 struct files_struct *oldf, *newf;
853 int error = 0;
854
855 /*
856 * A background process may not have any files ...
857 */
858 oldf = current->files;

--- 305 unchanged lines hidden (view full) ---

1164 monotonic_to_bootbased(&p->real_start_time);
1165 p->io_context = NULL;
1166 p->audit_context = NULL;
1167 if (clone_flags & CLONE_THREAD)
1168 threadgroup_fork_read_lock(current);
1169 cgroup_fork(p);
1170#ifdef CONFIG_NUMA
1171 p->mempolicy = mpol_dup(p->mempolicy);
1169 if (IS_ERR(p->mempolicy)) {
1170 retval = PTR_ERR(p->mempolicy);
1171 p->mempolicy = NULL;
1172 goto bad_fork_cleanup_cgroup;
1173 }
1172 if (IS_ERR(p->mempolicy)) {
1173 retval = PTR_ERR(p->mempolicy);
1174 p->mempolicy = NULL;
1175 goto bad_fork_cleanup_cgroup;
1176 }
1174 mpol_fix_fork_child_flag(p);
1175#endif
1176#ifdef CONFIG_CPUSETS
1177 p->cpuset_mem_spread_rotor = NUMA_NO_NODE;
1178 p->cpuset_slab_spread_rotor = NUMA_NO_NODE;
1179#endif
1180#ifdef CONFIG_TRACE_IRQFLAGS
1181 p->irq_events = 0;

--- 29 unchanged lines hidden (view full) ---

1211#endif
1212
1213 /* Perform scheduler related setup. Assign this task to a CPU. */
1214 sched_fork(p);
1215
1216 retval = perf_event_init_task(p);
1217 if (retval)
1218 goto bad_fork_cleanup_policy;
1177 mpol_fix_fork_child_flag(p);
1178#endif
1179#ifdef CONFIG_CPUSETS
1180 p->cpuset_mem_spread_rotor = NUMA_NO_NODE;
1181 p->cpuset_slab_spread_rotor = NUMA_NO_NODE;
1182#endif
1183#ifdef CONFIG_TRACE_IRQFLAGS
1184 p->irq_events = 0;

--- 29 unchanged lines hidden (view full) ---

1214#endif
1215
1216 /* Perform scheduler related setup. Assign this task to a CPU. */
1217 sched_fork(p);
1218
1219 retval = perf_event_init_task(p);
1220 if (retval)
1221 goto bad_fork_cleanup_policy;
1219
1220 if ((retval = audit_alloc(p)))
1222 retval = audit_alloc(p);
1223 if (retval)
1221 goto bad_fork_cleanup_policy;
1222 /* copy all the process information */
1224 goto bad_fork_cleanup_policy;
1225 /* copy all the process information */
1223 if ((retval = copy_semundo(clone_flags, p)))
1226 retval = copy_semundo(clone_flags, p);
1227 if (retval)
1224 goto bad_fork_cleanup_audit;
1228 goto bad_fork_cleanup_audit;
1225 if ((retval = copy_files(clone_flags, p)))
1229 retval = copy_files(clone_flags, p);
1230 if (retval)
1226 goto bad_fork_cleanup_semundo;
1231 goto bad_fork_cleanup_semundo;
1227 if ((retval = copy_fs(clone_flags, p)))
1232 retval = copy_fs(clone_flags, p);
1233 if (retval)
1228 goto bad_fork_cleanup_files;
1234 goto bad_fork_cleanup_files;
1229 if ((retval = copy_sighand(clone_flags, p)))
1235 retval = copy_sighand(clone_flags, p);
1236 if (retval)
1230 goto bad_fork_cleanup_fs;
1237 goto bad_fork_cleanup_fs;
1231 if ((retval = copy_signal(clone_flags, p)))
1238 retval = copy_signal(clone_flags, p);
1239 if (retval)
1232 goto bad_fork_cleanup_sighand;
1240 goto bad_fork_cleanup_sighand;
1233 if ((retval = copy_mm(clone_flags, p)))
1241 retval = copy_mm(clone_flags, p);
1242 if (retval)
1234 goto bad_fork_cleanup_signal;
1243 goto bad_fork_cleanup_signal;
1235 if ((retval = copy_namespaces(clone_flags, p)))
1244 retval = copy_namespaces(clone_flags, p);
1245 if (retval)
1236 goto bad_fork_cleanup_mm;
1246 goto bad_fork_cleanup_mm;
1237 if ((retval = copy_io(clone_flags, p)))
1247 retval = copy_io(clone_flags, p);
1248 if (retval)
1238 goto bad_fork_cleanup_namespaces;
1239 retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);
1240 if (retval)
1241 goto bad_fork_cleanup_io;
1242
1243 if (pid != &init_struct_pid) {
1244 retval = -ENOMEM;
1245 pid = alloc_pid(p->nsproxy->pid_ns);

--- 5 unchanged lines hidden (view full) ---

1251 p->tgid = p->pid;
1252 if (clone_flags & CLONE_THREAD)
1253 p->tgid = current->tgid;
1254
1255 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1256 /*
1257 * Clear TID on mm_release()?
1258 */
1249 goto bad_fork_cleanup_namespaces;
1250 retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);
1251 if (retval)
1252 goto bad_fork_cleanup_io;
1253
1254 if (pid != &init_struct_pid) {
1255 retval = -ENOMEM;
1256 pid = alloc_pid(p->nsproxy->pid_ns);

--- 5 unchanged lines hidden (view full) ---

1262 p->tgid = p->pid;
1263 if (clone_flags & CLONE_THREAD)
1264 p->tgid = current->tgid;
1265
1266 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1267 /*
1268 * Clear TID on mm_release()?
1269 */
1259 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
1270 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr : NULL;
1260#ifdef CONFIG_BLOCK
1261 p->plug = NULL;
1262#endif
1263#ifdef CONFIG_FUTEX
1264 p->robust_list = NULL;
1265#ifdef CONFIG_COMPAT
1266 p->compat_robust_list = NULL;
1267#endif

--- 51 unchanged lines hidden (view full) ---

1319
1320 /*
1321 * Process group and session signals need to be delivered to just the
1322 * parent before the fork or both the parent and the child after the
1323 * fork. Restart if a signal comes in before we add the new process to
1324 * it's process group.
1325 * A fatal signal pending means that current will exit, so the new
1326 * thread can't slip out of an OOM kill (or normal SIGKILL).
1271#ifdef CONFIG_BLOCK
1272 p->plug = NULL;
1273#endif
1274#ifdef CONFIG_FUTEX
1275 p->robust_list = NULL;
1276#ifdef CONFIG_COMPAT
1277 p->compat_robust_list = NULL;
1278#endif

--- 51 unchanged lines hidden (view full) ---

1330
1331 /*
1332 * Process group and session signals need to be delivered to just the
1333 * parent before the fork or both the parent and the child after the
1334 * fork. Restart if a signal comes in before we add the new process to
1335 * it's process group.
1336 * A fatal signal pending means that current will exit, so the new
1337 * thread can't slip out of an OOM kill (or normal SIGKILL).
1327 */
1338 */
1328 recalc_sigpending();
1329 if (signal_pending(current)) {
1330 spin_unlock(&current->sighand->siglock);
1331 write_unlock_irq(&tasklist_lock);
1332 retval = -ERESTARTNOINTR;
1333 goto bad_fork_free_pid;
1334 }
1335

--- 344 unchanged lines hidden (view full) ---

1680 unshare_flags |= CLONE_FS;
1681 /*
1682 * CLONE_NEWIPC must also detach from the undolist: after switching
1683 * to a new ipc namespace, the semaphore arrays from the old
1684 * namespace are unreachable.
1685 */
1686 if (unshare_flags & (CLONE_NEWIPC|CLONE_SYSVSEM))
1687 do_sysvsem = 1;
1339 recalc_sigpending();
1340 if (signal_pending(current)) {
1341 spin_unlock(&current->sighand->siglock);
1342 write_unlock_irq(&tasklist_lock);
1343 retval = -ERESTARTNOINTR;
1344 goto bad_fork_free_pid;
1345 }
1346

--- 344 unchanged lines hidden (view full) ---

1691 unshare_flags |= CLONE_FS;
1692 /*
1693 * CLONE_NEWIPC must also detach from the undolist: after switching
1694 * to a new ipc namespace, the semaphore arrays from the old
1695 * namespace are unreachable.
1696 */
1697 if (unshare_flags & (CLONE_NEWIPC|CLONE_SYSVSEM))
1698 do_sysvsem = 1;
1688 if ((err = unshare_fs(unshare_flags, &new_fs)))
1699 err = unshare_fs(unshare_flags, &new_fs);
1700 if (err)
1689 goto bad_unshare_out;
1701 goto bad_unshare_out;
1690 if ((err = unshare_fd(unshare_flags, &new_fd)))
1702 err = unshare_fd(unshare_flags, &new_fd);
1703 if (err)
1691 goto bad_unshare_cleanup_fs;
1704 goto bad_unshare_cleanup_fs;
1692 if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,
1693 new_fs)))
1705 err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy, new_fs);
1706 if (err)
1694 goto bad_unshare_cleanup_fd;
1695
1696 if (new_fs || new_fd || do_sysvsem || new_nsproxy) {
1697 if (do_sysvsem) {
1698 /*
1699 * CLONE_SYSVSEM is equivalent to sys_exit().
1700 */
1701 exit_sem(current);

--- 67 unchanged lines hidden --- 		1707 goto bad_unshare_cleanup_fd;
1708
1709 if (new_fs || new_fd || do_sysvsem || new_nsproxy) {
1710 if (do_sysvsem) {
1711 /*
1712 * CLONE_SYSVSEM is equivalent to sys_exit().
1713 */
1714 exit_sem(current);

--- 67 unchanged lines hidden ---