fork.c 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752
  1. /*
  2. * linux/kernel/fork.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. */
  6. /*
  7. * 'fork.c' contains the help-routines for the 'fork' system call
  8. * (see also entry.S and others).
  9. * Fork is rather simple, once you get the hang of it, but the memory
  10. * management can be a bitch. See 'mm/memory.c': 'copy_page_range()'
  11. */
  12. #include <linux/slab.h>
  13. #include <linux/init.h>
  14. #include <linux/unistd.h>
  15. #include <linux/smp_lock.h>
  16. #include <linux/module.h>
  17. #include <linux/vmalloc.h>
  18. #include <linux/completion.h>
  19. #include <linux/mnt_namespace.h>
  20. #include <linux/personality.h>
  21. #include <linux/mempolicy.h>
  22. #include <linux/sem.h>
  23. #include <linux/file.h>
  24. #include <linux/key.h>
  25. #include <linux/binfmts.h>
  26. #include <linux/mman.h>
  27. #include <linux/fs.h>
  28. #include <linux/nsproxy.h>
  29. #include <linux/capability.h>
  30. #include <linux/cpu.h>
  31. #include <linux/cpuset.h>
  32. #include <linux/security.h>
  33. #include <linux/swap.h>
  34. #include <linux/syscalls.h>
  35. #include <linux/jiffies.h>
  36. #include <linux/futex.h>
  37. #include <linux/task_io_accounting_ops.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>
  45. #include <linux/tsacct_kern.h>
  46. #include <linux/cn_proc.h>
  47. #include <linux/delayacct.h>
  48. #include <linux/taskstats_kern.h>
  49. #include <linux/random.h>
  50. #include <asm/pgtable.h>
  51. #include <asm/pgalloc.h>
  52. #include <asm/uaccess.h>
  53. #include <asm/mmu_context.h>
  54. #include <asm/cacheflush.h>
  55. #include <asm/tlbflush.h>
  56. /*
  57. * Protected counters by write_lock_irq(&tasklist_lock)
  58. */
  59. unsigned long total_forks; /* Handle normal Linux uptimes. */
  60. int nr_threads; /* The idle threads do not count.. */
  61. int max_threads; /* tunable limit on nr_threads */
  62. DEFINE_PER_CPU(unsigned long, process_counts) = 0;
  63. __cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
  64. int nr_processes(void)
  65. {
  66. int cpu;
  67. int total = 0;
  68. for_each_online_cpu(cpu)
  69. total += per_cpu(process_counts, cpu);
  70. return total;
  71. }
  72. #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
  73. # define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
  74. # define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))
  75. static struct kmem_cache *task_struct_cachep;
  76. #endif
  77. /* SLAB cache for signal_struct structures (tsk->signal) */
  78. static struct kmem_cache *signal_cachep;
  79. /* SLAB cache for sighand_struct structures (tsk->sighand) */
  80. struct kmem_cache *sighand_cachep;
  81. /* SLAB cache for files_struct structures (tsk->files) */
  82. struct kmem_cache *files_cachep;
  83. /* SLAB cache for fs_struct structures (tsk->fs) */
  84. struct kmem_cache *fs_cachep;
  85. /* SLAB cache for vm_area_struct structures */
  86. struct kmem_cache *vm_area_cachep;
  87. /* SLAB cache for mm_struct structures (tsk->mm) */
  88. static struct kmem_cache *mm_cachep;
  89. void free_task(struct task_struct *tsk)
  90. {
  91. free_thread_info(tsk->thread_info);
  92. rt_mutex_debug_task_free(tsk);
  93. free_task_struct(tsk);
  94. }
  95. EXPORT_SYMBOL(free_task);
  96. void __put_task_struct(struct task_struct *tsk)
  97. {
  98. WARN_ON(!(tsk->exit_state & (EXIT_DEAD | EXIT_ZOMBIE)));
  99. WARN_ON(atomic_read(&tsk->usage));
  100. WARN_ON(tsk == current);
  101. sched_dead(tsk);
  102. security_task_free(tsk);
  103. free_uid(tsk->user);
  104. put_group_info(tsk->group_info);
  105. delayacct_tsk_free(tsk);
  106. if (!profile_handoff_task(tsk))
  107. free_task(tsk);
  108. }
  109. void __init fork_init(unsigned long mempages)
  110. {
  111. #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
  112. #ifndef ARCH_MIN_TASKALIGN
  113. #define ARCH_MIN_TASKALIGN L1_CACHE_BYTES
  114. #endif
  115. /* create a slab on which task_structs can be allocated */
  116. task_struct_cachep =
  117. kmem_cache_create("task_struct", sizeof(struct task_struct),
  118. ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL, NULL);
  119. #endif
  120. /*
  121. * The default maximum number of threads is set to a safe
  122. * value: the thread structures can take up at most half
  123. * of memory.
  124. */
  125. max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
  126. /*
  127. * we need to allow at least 20 threads to boot a system
  128. */
  129. if(max_threads < 20)
  130. max_threads = 20;
  131. init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
  132. init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
  133. init_task.signal->rlim[RLIMIT_SIGPENDING] =
  134. init_task.signal->rlim[RLIMIT_NPROC];
  135. }
  136. static struct task_struct *dup_task_struct(struct task_struct *orig)
  137. {
  138. struct task_struct *tsk;
  139. struct thread_info *ti;
  140. prepare_to_copy(orig);
  141. tsk = alloc_task_struct();
  142. if (!tsk)
  143. return NULL;
  144. ti = alloc_thread_info(tsk);
  145. if (!ti) {
  146. free_task_struct(tsk);
  147. return NULL;
  148. }
  149. *tsk = *orig;
  150. tsk->thread_info = ti;
  151. setup_thread_stack(tsk, orig);
  152. #ifdef CONFIG_CC_STACKPROTECTOR
  153. tsk->stack_canary = get_random_int();
  154. #endif
  155. /* One for us, one for whoever does the "release_task()" (usually parent) */
  156. atomic_set(&tsk->usage,2);
  157. atomic_set(&tsk->fs_excl, 0);
  158. #ifdef CONFIG_BLK_DEV_IO_TRACE
  159. tsk->btrace_seq = 0;
  160. #endif
  161. tsk->splice_pipe = NULL;
  162. return tsk;
  163. }
  164. #ifdef CONFIG_MMU
  165. static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
  166. {
  167. struct vm_area_struct *mpnt, *tmp, **pprev;
  168. struct rb_node **rb_link, *rb_parent;
  169. int retval;
  170. unsigned long charge;
  171. struct mempolicy *pol;
  172. down_write(&oldmm->mmap_sem);
  173. flush_cache_dup_mm(oldmm);
  174. /*
  175. * Not linked in yet - no deadlock potential:
  176. */
  177. down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
  178. mm->locked_vm = 0;
  179. mm->mmap = NULL;
  180. mm->mmap_cache = NULL;
  181. mm->free_area_cache = oldmm->mmap_base;
  182. mm->cached_hole_size = ~0UL;
  183. mm->map_count = 0;
  184. cpus_clear(mm->cpu_vm_mask);
  185. mm->mm_rb = RB_ROOT;
  186. rb_link = &mm->mm_rb.rb_node;
  187. rb_parent = NULL;
  188. pprev = &mm->mmap;
  189. for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
  190. struct file *file;
  191. if (mpnt->vm_flags & VM_DONTCOPY) {
  192. long pages = vma_pages(mpnt);
  193. mm->total_vm -= pages;
  194. vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
  195. -pages);
  196. continue;
  197. }
  198. charge = 0;
  199. if (mpnt->vm_flags & VM_ACCOUNT) {
  200. unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
  201. if (security_vm_enough_memory(len))
  202. goto fail_nomem;
  203. charge = len;
  204. }
  205. tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
  206. if (!tmp)
  207. goto fail_nomem;
  208. *tmp = *mpnt;
  209. pol = mpol_copy(vma_policy(mpnt));
  210. retval = PTR_ERR(pol);
  211. if (IS_ERR(pol))
  212. goto fail_nomem_policy;
  213. vma_set_policy(tmp, pol);
  214. tmp->vm_flags &= ~VM_LOCKED;
  215. tmp->vm_mm = mm;
  216. tmp->vm_next = NULL;
  217. anon_vma_link(tmp);
  218. file = tmp->vm_file;
  219. if (file) {
  220. struct inode *inode = file->f_path.dentry->d_inode;
  221. get_file(file);
  222. if (tmp->vm_flags & VM_DENYWRITE)
  223. atomic_dec(&inode->i_writecount);
  224. /* insert tmp into the share list, just after mpnt */
  225. spin_lock(&file->f_mapping->i_mmap_lock);
  226. tmp->vm_truncate_count = mpnt->vm_truncate_count;
  227. flush_dcache_mmap_lock(file->f_mapping);
  228. vma_prio_tree_add(tmp, mpnt);
  229. flush_dcache_mmap_unlock(file->f_mapping);
  230. spin_unlock(&file->f_mapping->i_mmap_lock);
  231. }
  232. /*
  233. * Link in the new vma and copy the page table entries.
  234. */
  235. *pprev = tmp;
  236. pprev = &tmp->vm_next;
  237. __vma_link_rb(mm, tmp, rb_link, rb_parent);
  238. rb_link = &tmp->vm_rb.rb_right;
  239. rb_parent = &tmp->vm_rb;
  240. mm->map_count++;
  241. retval = copy_page_range(mm, oldmm, mpnt);
  242. if (tmp->vm_ops && tmp->vm_ops->open)
  243. tmp->vm_ops->open(tmp);
  244. if (retval)
  245. goto out;
  246. }
  247. retval = 0;
  248. out:
  249. up_write(&mm->mmap_sem);
  250. flush_tlb_mm(oldmm);
  251. up_write(&oldmm->mmap_sem);
  252. return retval;
  253. fail_nomem_policy:
  254. kmem_cache_free(vm_area_cachep, tmp);
  255. fail_nomem:
  256. retval = -ENOMEM;
  257. vm_unacct_memory(charge);
  258. goto out;
  259. }
  260. static inline int mm_alloc_pgd(struct mm_struct * mm)
  261. {
  262. mm->pgd = pgd_alloc(mm);
  263. if (unlikely(!mm->pgd))
  264. return -ENOMEM;
  265. return 0;
  266. }
  267. static inline void mm_free_pgd(struct mm_struct * mm)
  268. {
  269. pgd_free(mm->pgd);
  270. }
  271. #else
  272. #define dup_mmap(mm, oldmm) (0)
  273. #define mm_alloc_pgd(mm) (0)
  274. #define mm_free_pgd(mm)
  275. #endif /* CONFIG_MMU */
  276. __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
  277. #define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
  278. #define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
  279. #include <linux/init_task.h>
  280. static struct mm_struct * mm_init(struct mm_struct * mm)
  281. {
  282. atomic_set(&mm->mm_users, 1);
  283. atomic_set(&mm->mm_count, 1);
  284. init_rwsem(&mm->mmap_sem);
  285. INIT_LIST_HEAD(&mm->mmlist);
  286. mm->core_waiters = 0;
  287. mm->nr_ptes = 0;
  288. set_mm_counter(mm, file_rss, 0);
  289. set_mm_counter(mm, anon_rss, 0);
  290. spin_lock_init(&mm->page_table_lock);
  291. rwlock_init(&mm->ioctx_list_lock);
  292. mm->ioctx_list = NULL;
  293. mm->free_area_cache = TASK_UNMAPPED_BASE;
  294. mm->cached_hole_size = ~0UL;
  295. if (likely(!mm_alloc_pgd(mm))) {
  296. mm->def_flags = 0;
  297. return mm;
  298. }
  299. free_mm(mm);
  300. return NULL;
  301. }
  302. /*
  303. * Allocate and initialize an mm_struct.
  304. */
  305. struct mm_struct * mm_alloc(void)
  306. {
  307. struct mm_struct * mm;
  308. mm = allocate_mm();
  309. if (mm) {
  310. memset(mm, 0, sizeof(*mm));
  311. mm = mm_init(mm);
  312. }
  313. return mm;
  314. }
  315. /*
  316. * Called when the last reference to the mm
  317. * is dropped: either by a lazy thread or by
  318. * mmput. Free the page directory and the mm.
  319. */
  320. void fastcall __mmdrop(struct mm_struct *mm)
  321. {
  322. BUG_ON(mm == &init_mm);
  323. mm_free_pgd(mm);
  324. destroy_context(mm);
  325. free_mm(mm);
  326. }
  327. /*
  328. * Decrement the use count and release all resources for an mm.
  329. */
  330. void mmput(struct mm_struct *mm)
  331. {
  332. might_sleep();
  333. if (atomic_dec_and_test(&mm->mm_users)) {
  334. exit_aio(mm);
  335. exit_mmap(mm);
  336. if (!list_empty(&mm->mmlist)) {
  337. spin_lock(&mmlist_lock);
  338. list_del(&mm->mmlist);
  339. spin_unlock(&mmlist_lock);
  340. }
  341. put_swap_token(mm);
  342. mmdrop(mm);
  343. }
  344. }
  345. EXPORT_SYMBOL_GPL(mmput);
  346. /**
  347. * get_task_mm - acquire a reference to the task's mm
  348. *
  349. * Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning
  350. * this kernel workthread has transiently adopted a user mm with use_mm,
  351. * to do its AIO) is not set and if so returns a reference to it, after
  352. * bumping up the use count. User must release the mm via mmput()
  353. * after use. Typically used by /proc and ptrace.
  354. */
  355. struct mm_struct *get_task_mm(struct task_struct *task)
  356. {
  357. struct mm_struct *mm;
  358. task_lock(task);
  359. mm = task->mm;
  360. if (mm) {
  361. if (task->flags & PF_BORROWED_MM)
  362. mm = NULL;
  363. else
  364. atomic_inc(&mm->mm_users);
  365. }
  366. task_unlock(task);
  367. return mm;
  368. }
  369. EXPORT_SYMBOL_GPL(get_task_mm);
  370. /* Please note the differences between mmput and mm_release.
  371. * mmput is called whenever we stop holding onto a mm_struct,
  372. * error success whatever.
  373. *
  374. * mm_release is called after a mm_struct has been removed
  375. * from the current process.
  376. *
  377. * This difference is important for error handling, when we
  378. * only half set up a mm_struct for a new process and need to restore
  379. * the old one. Because we mmput the new mm_struct before
  380. * restoring the old one. . .
  381. * Eric Biederman 10 January 1998
  382. */
  383. void mm_release(struct task_struct *tsk, struct mm_struct *mm)
  384. {
  385. struct completion *vfork_done = tsk->vfork_done;
  386. /* Get rid of any cached register state */
  387. deactivate_mm(tsk, mm);
  388. /* notify parent sleeping on vfork() */
  389. if (vfork_done) {
  390. tsk->vfork_done = NULL;
  391. complete(vfork_done);
  392. }
  393. /*
  394. * If we're exiting normally, clear a user-space tid field if
  395. * requested. We leave this alone when dying by signal, to leave
  396. * the value intact in a core dump, and to save the unnecessary
  397. * trouble otherwise. Userland only wants this done for a sys_exit.
  398. */
  399. if (tsk->clear_child_tid
  400. && !(tsk->flags & PF_SIGNALED)
  401. && atomic_read(&mm->mm_users) > 1) {
  402. u32 __user * tidptr = tsk->clear_child_tid;
  403. tsk->clear_child_tid = NULL;
  404. /*
  405. * We don't check the error code - if userspace has
  406. * not set up a proper pointer then tough luck.
  407. */
  408. put_user(0, tidptr);
  409. sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
  410. }
  411. }
  412. /*
  413. * Allocate a new mm structure and copy contents from the
  414. * mm structure of the passed in task structure.
  415. */
  416. static struct mm_struct *dup_mm(struct task_struct *tsk)
  417. {
  418. struct mm_struct *mm, *oldmm = current->mm;
  419. int err;
  420. if (!oldmm)
  421. return NULL;
  422. mm = allocate_mm();
  423. if (!mm)
  424. goto fail_nomem;
  425. memcpy(mm, oldmm, sizeof(*mm));
  426. /* Initializing for Swap token stuff */
  427. mm->token_priority = 0;
  428. mm->last_interval = 0;
  429. if (!mm_init(mm))
  430. goto fail_nomem;
  431. if (init_new_context(tsk, mm))
  432. goto fail_nocontext;
  433. err = dup_mmap(mm, oldmm);
  434. if (err)
  435. goto free_pt;
  436. mm->hiwater_rss = get_mm_rss(mm);
  437. mm->hiwater_vm = mm->total_vm;
  438. return mm;
  439. free_pt:
  440. mmput(mm);
  441. fail_nomem:
  442. return NULL;
  443. fail_nocontext:
  444. /*
  445. * If init_new_context() failed, we cannot use mmput() to free the mm
  446. * because it calls destroy_context()
  447. */
  448. mm_free_pgd(mm);
  449. free_mm(mm);
  450. return NULL;
  451. }
  452. static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
  453. {
  454. struct mm_struct * mm, *oldmm;
  455. int retval;
  456. tsk->min_flt = tsk->maj_flt = 0;
  457. tsk->nvcsw = tsk->nivcsw = 0;
  458. tsk->mm = NULL;
  459. tsk->active_mm = NULL;
  460. /*
  461. * Are we cloning a kernel thread?
  462. *
  463. * We need to steal a active VM for that..
  464. */
  465. oldmm = current->mm;
  466. if (!oldmm)
  467. return 0;
  468. if (clone_flags & CLONE_VM) {
  469. atomic_inc(&oldmm->mm_users);
  470. mm = oldmm;
  471. goto good_mm;
  472. }
  473. retval = -ENOMEM;
  474. mm = dup_mm(tsk);
  475. if (!mm)
  476. goto fail_nomem;
  477. good_mm:
  478. /* Initializing for Swap token stuff */
  479. mm->token_priority = 0;
  480. mm->last_interval = 0;
  481. tsk->mm = mm;
  482. tsk->active_mm = mm;
  483. return 0;
  484. fail_nomem:
  485. return retval;
  486. }
  487. static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old)
  488. {
  489. struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
  490. /* We don't need to lock fs - think why ;-) */
  491. if (fs) {
  492. atomic_set(&fs->count, 1);
  493. rwlock_init(&fs->lock);
  494. fs->umask = old->umask;
  495. read_lock(&old->lock);
  496. fs->rootmnt = mntget(old->rootmnt);
  497. fs->root = dget(old->root);
  498. fs->pwdmnt = mntget(old->pwdmnt);
  499. fs->pwd = dget(old->pwd);
  500. if (old->altroot) {
  501. fs->altrootmnt = mntget(old->altrootmnt);
  502. fs->altroot = dget(old->altroot);
  503. } else {
  504. fs->altrootmnt = NULL;
  505. fs->altroot = NULL;
  506. }
  507. read_unlock(&old->lock);
  508. }
  509. return fs;
  510. }
  511. struct fs_struct *copy_fs_struct(struct fs_struct *old)
  512. {
  513. return __copy_fs_struct(old);
  514. }
  515. EXPORT_SYMBOL_GPL(copy_fs_struct);
  516. static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
  517. {
  518. if (clone_flags & CLONE_FS) {
  519. atomic_inc(&current->fs->count);
  520. return 0;
  521. }
  522. tsk->fs = __copy_fs_struct(current->fs);
  523. if (!tsk->fs)
  524. return -ENOMEM;
  525. return 0;
  526. }
  527. static int count_open_files(struct fdtable *fdt)
  528. {
  529. int size = fdt->max_fds;
  530. int i;
  531. /* Find the last open fd */
  532. for (i = size/(8*sizeof(long)); i > 0; ) {
  533. if (fdt->open_fds->fds_bits[--i])
  534. break;
  535. }
  536. i = (i+1) * 8 * sizeof(long);
  537. return i;
  538. }
  539. static struct files_struct *alloc_files(void)
  540. {
  541. struct files_struct *newf;
  542. struct fdtable *fdt;
  543. newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
  544. if (!newf)
  545. goto out;
  546. atomic_set(&newf->count, 1);
  547. spin_lock_init(&newf->file_lock);
  548. newf->next_fd = 0;
  549. fdt = &newf->fdtab;
  550. fdt->max_fds = NR_OPEN_DEFAULT;
  551. fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
  552. fdt->open_fds = (fd_set *)&newf->open_fds_init;
  553. fdt->fd = &newf->fd_array[0];
  554. INIT_RCU_HEAD(&fdt->rcu);
  555. fdt->next = NULL;
  556. rcu_assign_pointer(newf->fdt, fdt);
  557. out:
  558. return newf;
  559. }
  560. /*
  561. * Allocate a new files structure and copy contents from the
  562. * passed in files structure.
  563. * errorp will be valid only when the returned files_struct is NULL.
  564. */
  565. static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
  566. {
  567. struct files_struct *newf;
  568. struct file **old_fds, **new_fds;
  569. int open_files, size, i;
  570. struct fdtable *old_fdt, *new_fdt;
  571. *errorp = -ENOMEM;
  572. newf = alloc_files();
  573. if (!newf)
  574. goto out;
  575. spin_lock(&oldf->file_lock);
  576. old_fdt = files_fdtable(oldf);
  577. new_fdt = files_fdtable(newf);
  578. open_files = count_open_files(old_fdt);
  579. /*
  580. * Check whether we need to allocate a larger fd array and fd set.
  581. * Note: we're not a clone task, so the open count won't change.
  582. */
  583. if (open_files > new_fdt->max_fds) {
  584. new_fdt->max_fds = 0;
  585. spin_unlock(&oldf->file_lock);
  586. spin_lock(&newf->file_lock);
  587. *errorp = expand_files(newf, open_files-1);
  588. spin_unlock(&newf->file_lock);
  589. if (*errorp < 0)
  590. goto out_release;
  591. new_fdt = files_fdtable(newf);
  592. /*
  593. * Reacquire the oldf lock and a pointer to its fd table
  594. * who knows it may have a new bigger fd table. We need
  595. * the latest pointer.
  596. */
  597. spin_lock(&oldf->file_lock);
  598. old_fdt = files_fdtable(oldf);
  599. }
  600. old_fds = old_fdt->fd;
  601. new_fds = new_fdt->fd;
  602. memcpy(new_fdt->open_fds->fds_bits,
  603. old_fdt->open_fds->fds_bits, open_files/8);
  604. memcpy(new_fdt->close_on_exec->fds_bits,
  605. old_fdt->close_on_exec->fds_bits, open_files/8);
  606. for (i = open_files; i != 0; i--) {
  607. struct file *f = *old_fds++;
  608. if (f) {
  609. get_file(f);
  610. } else {
  611. /*
  612. * The fd may be claimed in the fd bitmap but not yet
  613. * instantiated in the files array if a sibling thread
  614. * is partway through open(). So make sure that this
  615. * fd is available to the new process.
  616. */
  617. FD_CLR(open_files - i, new_fdt->open_fds);
  618. }
  619. rcu_assign_pointer(*new_fds++, f);
  620. }
  621. spin_unlock(&oldf->file_lock);
  622. /* compute the remainder to be cleared */
  623. size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
  624. /* This is long word aligned thus could use a optimized version */
  625. memset(new_fds, 0, size);
  626. if (new_fdt->max_fds > open_files) {
  627. int left = (new_fdt->max_fds-open_files)/8;
  628. int start = open_files / (8 * sizeof(unsigned long));
  629. memset(&new_fdt->open_fds->fds_bits[start], 0, left);
  630. memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
  631. }
  632. return newf;
  633. out_release:
  634. kmem_cache_free(files_cachep, newf);
  635. out:
  636. return NULL;
  637. }
  638. static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
  639. {
  640. struct files_struct *oldf, *newf;
  641. int error = 0;
  642. /*
  643. * A background process may not have any files ...
  644. */
  645. oldf = current->files;
  646. if (!oldf)
  647. goto out;
  648. if (clone_flags & CLONE_FILES) {
  649. atomic_inc(&oldf->count);
  650. goto out;
  651. }
  652. /*
  653. * Note: we may be using current for both targets (See exec.c)
  654. * This works because we cache current->files (old) as oldf. Don't
  655. * break this.
  656. */
  657. tsk->files = NULL;
  658. newf = dup_fd(oldf, &error);
  659. if (!newf)
  660. goto out;
  661. tsk->files = newf;
  662. error = 0;
  663. out:
  664. return error;
  665. }
  666. /*
  667. * Helper to unshare the files of the current task.
  668. * We don't want to expose copy_files internals to
  669. * the exec layer of the kernel.
  670. */
  671. int unshare_files(void)
  672. {
  673. struct files_struct *files = current->files;
  674. int rc;
  675. BUG_ON(!files);
  676. /* This can race but the race causes us to copy when we don't
  677. need to and drop the copy */
  678. if(atomic_read(&files->count) == 1)
  679. {
  680. atomic_inc(&files->count);
  681. return 0;
  682. }
  683. rc = copy_files(0, current);
  684. if(rc)
  685. current->files = files;
  686. return rc;
  687. }
  688. EXPORT_SYMBOL(unshare_files);
  689. static inline int copy_sighand(unsigned long clone_flags, struct task_struct * tsk)
  690. {
  691. struct sighand_struct *sig;
  692. if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
  693. atomic_inc(&current->sighand->count);
  694. return 0;
  695. }
  696. sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
  697. rcu_assign_pointer(tsk->sighand, sig);
  698. if (!sig)
  699. return -ENOMEM;
  700. atomic_set(&sig->count, 1);
  701. memcpy(sig->action, current->sighand->action, sizeof(sig->action));
  702. return 0;
  703. }
  704. void __cleanup_sighand(struct sighand_struct *sighand)
  705. {
  706. if (atomic_dec_and_test(&sighand->count))
  707. kmem_cache_free(sighand_cachep, sighand);
  708. }
  709. static inline int copy_signal(unsigned long clone_flags, struct task_struct * tsk)
  710. {
  711. struct signal_struct *sig;
  712. int ret;
  713. if (clone_flags & CLONE_THREAD) {
  714. atomic_inc(&current->signal->count);
  715. atomic_inc(&current->signal->live);
  716. return 0;
  717. }
  718. sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
  719. tsk->signal = sig;
  720. if (!sig)
  721. return -ENOMEM;
  722. ret = copy_thread_group_keys(tsk);
  723. if (ret < 0) {
  724. kmem_cache_free(signal_cachep, sig);
  725. return ret;
  726. }
  727. atomic_set(&sig->count, 1);
  728. atomic_set(&sig->live, 1);
  729. init_waitqueue_head(&sig->wait_chldexit);
  730. sig->flags = 0;
  731. sig->group_exit_code = 0;
  732. sig->group_exit_task = NULL;
  733. sig->group_stop_count = 0;
  734. sig->curr_target = NULL;
  735. init_sigpending(&sig->shared_pending);
  736. INIT_LIST_HEAD(&sig->posix_timers);
  737. hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  738. sig->it_real_incr.tv64 = 0;
  739. sig->real_timer.function = it_real_fn;
  740. sig->tsk = tsk;
  741. sig->it_virt_expires = cputime_zero;
  742. sig->it_virt_incr = cputime_zero;
  743. sig->it_prof_expires = cputime_zero;
  744. sig->it_prof_incr = cputime_zero;
  745. sig->leader = 0; /* session leadership doesn't inherit */
  746. sig->tty_old_pgrp = NULL;
  747. sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
  748. sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
  749. sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
  750. sig->sum_sched_runtime = 0;
  751. INIT_LIST_HEAD(&sig->cpu_timers[0]);
  752. INIT_LIST_HEAD(&sig->cpu_timers[1]);
  753. INIT_LIST_HEAD(&sig->cpu_timers[2]);
  754. taskstats_tgid_init(sig);
  755. task_lock(current->group_leader);
  756. memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
  757. task_unlock(current->group_leader);
  758. if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
  759. /*
  760. * New sole thread in the process gets an expiry time
  761. * of the whole CPU time limit.
  762. */
  763. tsk->it_prof_expires =
  764. secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
  765. }
  766. acct_init_pacct(&sig->pacct);
  767. return 0;
  768. }
  769. void __cleanup_signal(struct signal_struct *sig)
  770. {
  771. exit_thread_group_keys(sig);
  772. kmem_cache_free(signal_cachep, sig);
  773. }
  774. static inline void cleanup_signal(struct task_struct *tsk)
  775. {
  776. struct signal_struct *sig = tsk->signal;
  777. atomic_dec(&sig->live);
  778. if (atomic_dec_and_test(&sig->count))
  779. __cleanup_signal(sig);
  780. }
  781. static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
  782. {
  783. unsigned long new_flags = p->flags;
  784. new_flags &= ~(PF_SUPERPRIV | PF_NOFREEZE);
  785. new_flags |= PF_FORKNOEXEC;
  786. if (!(clone_flags & CLONE_PTRACE))
  787. p->ptrace = 0;
  788. p->flags = new_flags;
  789. }
  790. asmlinkage long sys_set_tid_address(int __user *tidptr)
  791. {
  792. current->clear_child_tid = tidptr;
  793. return current->pid;
  794. }
  795. static inline void rt_mutex_init_task(struct task_struct *p)
  796. {
  797. spin_lock_init(&p->pi_lock);
  798. #ifdef CONFIG_RT_MUTEXES
  799. plist_head_init(&p->pi_waiters, &p->pi_lock);
  800. p->pi_blocked_on = NULL;
  801. #endif
  802. }
  803. /*
  804. * This creates a new process as a copy of the old one,
  805. * but does not actually start it yet.
  806. *
  807. * It copies the registers, and all the appropriate
  808. * parts of the process environment (as per the clone
  809. * flags). The actual kick-off is left to the caller.
  810. */
  811. static struct task_struct *copy_process(unsigned long clone_flags,
  812. unsigned long stack_start,
  813. struct pt_regs *regs,
  814. unsigned long stack_size,
  815. int __user *parent_tidptr,
  816. int __user *child_tidptr,
  817. int pid)
  818. {
  819. int retval;
  820. struct task_struct *p = NULL;
  821. if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
  822. return ERR_PTR(-EINVAL);
  823. /*
  824. * Thread groups must share signals as well, and detached threads
  825. * can only be started up within the thread group.
  826. */
  827. if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
  828. return ERR_PTR(-EINVAL);
  829. /*
  830. * Shared signal handlers imply shared VM. By way of the above,
  831. * thread groups also imply shared VM. Blocking this case allows
  832. * for various simplifications in other code.
  833. */
  834. if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
  835. return ERR_PTR(-EINVAL);
  836. retval = security_task_create(clone_flags);
  837. if (retval)
  838. goto fork_out;
  839. retval = -ENOMEM;
  840. p = dup_task_struct(current);
  841. if (!p)
  842. goto fork_out;
  843. rt_mutex_init_task(p);
  844. #ifdef CONFIG_TRACE_IRQFLAGS
  845. DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
  846. DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
  847. #endif
  848. retval = -EAGAIN;
  849. if (atomic_read(&p->user->processes) >=
  850. p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
  851. if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
  852. p->user != &root_user)
  853. goto bad_fork_free;
  854. }
  855. atomic_inc(&p->user->__count);
  856. atomic_inc(&p->user->processes);
  857. get_group_info(p->group_info);
  858. /*
  859. * If multiple threads are within copy_process(), then this check
  860. * triggers too late. This doesn't hurt, the check is only there
  861. * to stop root fork bombs.
  862. */
  863. if (nr_threads >= max_threads)
  864. goto bad_fork_cleanup_count;
  865. if (!try_module_get(task_thread_info(p)->exec_domain->module))
  866. goto bad_fork_cleanup_count;
  867. if (p->binfmt && !try_module_get(p->binfmt->module))
  868. goto bad_fork_cleanup_put_domain;
  869. p->did_exec = 0;
  870. delayacct_tsk_init(p); /* Must remain after dup_task_struct() */
  871. copy_flags(clone_flags, p);
  872. p->pid = pid;
  873. retval = -EFAULT;
  874. if (clone_flags & CLONE_PARENT_SETTID)
  875. if (put_user(p->pid, parent_tidptr))
  876. goto bad_fork_cleanup_delays_binfmt;
  877. INIT_LIST_HEAD(&p->children);
  878. INIT_LIST_HEAD(&p->sibling);
  879. p->vfork_done = NULL;
  880. spin_lock_init(&p->alloc_lock);
  881. clear_tsk_thread_flag(p, TIF_SIGPENDING);
  882. init_sigpending(&p->pending);
  883. p->utime = cputime_zero;
  884. p->stime = cputime_zero;
  885. #ifdef CONFIG_TASK_XACCT
  886. p->rchar = 0; /* I/O counter: bytes read */
  887. p->wchar = 0; /* I/O counter: bytes written */
  888. p->syscr = 0; /* I/O counter: read syscalls */
  889. p->syscw = 0; /* I/O counter: write syscalls */
  890. #endif
  891. task_io_accounting_init(p);
  892. acct_clear_integrals(p);
  893. p->it_virt_expires = cputime_zero;
  894. p->it_prof_expires = cputime_zero;
  895. p->it_sched_expires = 0;
  896. INIT_LIST_HEAD(&p->cpu_timers[0]);
  897. INIT_LIST_HEAD(&p->cpu_timers[1]);
  898. INIT_LIST_HEAD(&p->cpu_timers[2]);
  899. p->lock_depth = -1; /* -1 = no lock */
  900. do_posix_clock_monotonic_gettime(&p->start_time);
  901. p->security = NULL;
  902. p->io_context = NULL;
  903. p->io_wait = NULL;
  904. p->audit_context = NULL;
  905. cpuset_fork(p);
  906. #ifdef CONFIG_NUMA
  907. p->mempolicy = mpol_copy(p->mempolicy);
  908. if (IS_ERR(p->mempolicy)) {
  909. retval = PTR_ERR(p->mempolicy);
  910. p->mempolicy = NULL;
  911. goto bad_fork_cleanup_cpuset;
  912. }
  913. mpol_fix_fork_child_flag(p);
  914. #endif
  915. #ifdef CONFIG_TRACE_IRQFLAGS
  916. p->irq_events = 0;
  917. #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
  918. p->hardirqs_enabled = 1;
  919. #else
  920. p->hardirqs_enabled = 0;
  921. #endif
  922. p->hardirq_enable_ip = 0;
  923. p->hardirq_enable_event = 0;
  924. p->hardirq_disable_ip = _THIS_IP_;
  925. p->hardirq_disable_event = 0;
  926. p->softirqs_enabled = 1;
  927. p->softirq_enable_ip = _THIS_IP_;
  928. p->softirq_enable_event = 0;
  929. p->softirq_disable_ip = 0;
  930. p->softirq_disable_event = 0;
  931. p->hardirq_context = 0;
  932. p->softirq_context = 0;
  933. #endif
  934. #ifdef CONFIG_LOCKDEP
  935. p->lockdep_depth = 0; /* no locks held yet */
  936. p->curr_chain_key = 0;
  937. p->lockdep_recursion = 0;
  938. #endif
  939. #ifdef CONFIG_DEBUG_MUTEXES
  940. p->blocked_on = NULL; /* not blocked yet */
  941. #endif
  942. p->tgid = p->pid;
  943. if (clone_flags & CLONE_THREAD)
  944. p->tgid = current->tgid;
  945. if ((retval = security_task_alloc(p)))
  946. goto bad_fork_cleanup_policy;
  947. if ((retval = audit_alloc(p)))
  948. goto bad_fork_cleanup_security;
  949. /* copy all the process information */
  950. if ((retval = copy_semundo(clone_flags, p)))
  951. goto bad_fork_cleanup_audit;
  952. if ((retval = copy_files(clone_flags, p)))
  953. goto bad_fork_cleanup_semundo;
  954. if ((retval = copy_fs(clone_flags, p)))
  955. goto bad_fork_cleanup_files;
  956. if ((retval = copy_sighand(clone_flags, p)))
  957. goto bad_fork_cleanup_fs;
  958. if ((retval = copy_signal(clone_flags, p)))
  959. goto bad_fork_cleanup_sighand;
  960. if ((retval = copy_mm(clone_flags, p)))
  961. goto bad_fork_cleanup_signal;
  962. if ((retval = copy_keys(clone_flags, p)))
  963. goto bad_fork_cleanup_mm;
  964. if ((retval = copy_namespaces(clone_flags, p)))
  965. goto bad_fork_cleanup_keys;
  966. retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
  967. if (retval)
  968. goto bad_fork_cleanup_namespaces;
  969. p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
  970. /*
  971. * Clear TID on mm_release()?
  972. */
  973. p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
  974. p->robust_list = NULL;
  975. #ifdef CONFIG_COMPAT
  976. p->compat_robust_list = NULL;
  977. #endif
  978. INIT_LIST_HEAD(&p->pi_state_list);
  979. p->pi_state_cache = NULL;
  980. /*
  981. * sigaltstack should be cleared when sharing the same VM
  982. */
  983. if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
  984. p->sas_ss_sp = p->sas_ss_size = 0;
  985. /*
  986. * Syscall tracing should be turned off in the child regardless
  987. * of CLONE_PTRACE.
  988. */
  989. clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
  990. #ifdef TIF_SYSCALL_EMU
  991. clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
  992. #endif
  993. /* Our parent execution domain becomes current domain
  994. These must match for thread signalling to apply */
  995. p->parent_exec_id = p->self_exec_id;
  996. /* ok, now we should be set up.. */
  997. p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
  998. p->pdeath_signal = 0;
  999. p->exit_state = 0;
  1000. /*
  1001. * Ok, make it visible to the rest of the system.
  1002. * We dont wake it up yet.
  1003. */
  1004. p->group_leader = p;
  1005. INIT_LIST_HEAD(&p->thread_group);
  1006. INIT_LIST_HEAD(&p->ptrace_children);
  1007. INIT_LIST_HEAD(&p->ptrace_list);
  1008. /* Perform scheduler related setup. Assign this task to a CPU. */
  1009. sched_fork(p, clone_flags);
  1010. /* Need tasklist lock for parent etc handling! */
  1011. write_lock_irq(&tasklist_lock);
  1012. /* for sys_ioprio_set(IOPRIO_WHO_PGRP) */
  1013. p->ioprio = current->ioprio;
  1014. /*
  1015. * The task hasn't been attached yet, so its cpus_allowed mask will
  1016. * not be changed, nor will its assigned CPU.
  1017. *
  1018. * The cpus_allowed mask of the parent may have changed after it was
  1019. * copied first time - so re-copy it here, then check the child's CPU
  1020. * to ensure it is on a valid CPU (and if not, just force it back to
  1021. * parent's CPU). This avoids alot of nasty races.
  1022. */
  1023. p->cpus_allowed = current->cpus_allowed;
  1024. if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
  1025. !cpu_online(task_cpu(p))))
  1026. set_task_cpu(p, smp_processor_id());
  1027. /* CLONE_PARENT re-uses the old parent */
  1028. if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
  1029. p->real_parent = current->real_parent;
  1030. else
  1031. p->real_parent = current;
  1032. p->parent = p->real_parent;
  1033. spin_lock(&current->sighand->siglock);
  1034. /*
  1035. * Process group and session signals need to be delivered to just the
  1036. * parent before the fork or both the parent and the child after the
  1037. * fork. Restart if a signal comes in before we add the new process to
  1038. * it's process group.
  1039. * A fatal signal pending means that current will exit, so the new
  1040. * thread can't slip out of an OOM kill (or normal SIGKILL).
  1041. */
  1042. recalc_sigpending();
  1043. if (signal_pending(current)) {
  1044. spin_unlock(&current->sighand->siglock);
  1045. write_unlock_irq(&tasklist_lock);
  1046. retval = -ERESTARTNOINTR;
  1047. goto bad_fork_cleanup_namespaces;
  1048. }
  1049. if (clone_flags & CLONE_THREAD) {
  1050. p->group_leader = current->group_leader;
  1051. list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
  1052. if (!cputime_eq(current->signal->it_virt_expires,
  1053. cputime_zero) ||
  1054. !cputime_eq(current->signal->it_prof_expires,
  1055. cputime_zero) ||
  1056. current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
  1057. !list_empty(&current->signal->cpu_timers[0]) ||
  1058. !list_empty(&current->signal->cpu_timers[1]) ||
  1059. !list_empty(&current->signal->cpu_timers[2])) {
  1060. /*
  1061. * Have child wake up on its first tick to check
  1062. * for process CPU timers.
  1063. */
  1064. p->it_prof_expires = jiffies_to_cputime(1);
  1065. }
  1066. }
  1067. if (likely(p->pid)) {
  1068. add_parent(p);
  1069. if (unlikely(p->ptrace & PT_PTRACED))
  1070. __ptrace_link(p, current->parent);
  1071. if (thread_group_leader(p)) {
  1072. p->signal->tty = current->signal->tty;
  1073. p->signal->pgrp = process_group(current);
  1074. set_signal_session(p->signal, process_session(current));
  1075. attach_pid(p, PIDTYPE_PGID, process_group(p));
  1076. attach_pid(p, PIDTYPE_SID, process_session(p));
  1077. list_add_tail_rcu(&p->tasks, &init_task.tasks);
  1078. __get_cpu_var(process_counts)++;
  1079. }
  1080. attach_pid(p, PIDTYPE_PID, p->pid);
  1081. nr_threads++;
  1082. }
  1083. total_forks++;
  1084. spin_unlock(&current->sighand->siglock);
  1085. write_unlock_irq(&tasklist_lock);
  1086. proc_fork_connector(p);
  1087. return p;
  1088. bad_fork_cleanup_namespaces:
  1089. exit_task_namespaces(p);
  1090. bad_fork_cleanup_keys:
  1091. exit_keys(p);
  1092. bad_fork_cleanup_mm:
  1093. if (p->mm)
  1094. mmput(p->mm);
  1095. bad_fork_cleanup_signal:
  1096. cleanup_signal(p);
  1097. bad_fork_cleanup_sighand:
  1098. __cleanup_sighand(p->sighand);
  1099. bad_fork_cleanup_fs:
  1100. exit_fs(p); /* blocking */
  1101. bad_fork_cleanup_files:
  1102. exit_files(p); /* blocking */
  1103. bad_fork_cleanup_semundo:
  1104. exit_sem(p);
  1105. bad_fork_cleanup_audit:
  1106. audit_free(p);
  1107. bad_fork_cleanup_security:
  1108. security_task_free(p);
  1109. bad_fork_cleanup_policy:
  1110. #ifdef CONFIG_NUMA
  1111. mpol_free(p->mempolicy);
  1112. bad_fork_cleanup_cpuset:
  1113. #endif
  1114. cpuset_exit(p);
  1115. bad_fork_cleanup_delays_binfmt:
  1116. delayacct_tsk_free(p);
  1117. if (p->binfmt)
  1118. module_put(p->binfmt->module);
  1119. bad_fork_cleanup_put_domain:
  1120. module_put(task_thread_info(p)->exec_domain->module);
  1121. bad_fork_cleanup_count:
  1122. put_group_info(p->group_info);
  1123. atomic_dec(&p->user->processes);
  1124. free_uid(p->user);
  1125. bad_fork_free:
  1126. free_task(p);
  1127. fork_out:
  1128. return ERR_PTR(retval);
  1129. }
  1130. noinline struct pt_regs * __devinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
  1131. {
  1132. memset(regs, 0, sizeof(struct pt_regs));
  1133. return regs;
  1134. }
  1135. struct task_struct * __cpuinit fork_idle(int cpu)
  1136. {
  1137. struct task_struct *task;
  1138. struct pt_regs regs;
  1139. task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL, NULL, 0);
  1140. if (!IS_ERR(task))
  1141. init_idle(task, cpu);
  1142. return task;
  1143. }
  1144. static inline int fork_traceflag (unsigned clone_flags)
  1145. {
  1146. if (clone_flags & CLONE_UNTRACED)
  1147. return 0;
  1148. else if (clone_flags & CLONE_VFORK) {
  1149. if (current->ptrace & PT_TRACE_VFORK)
  1150. return PTRACE_EVENT_VFORK;
  1151. } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
  1152. if (current->ptrace & PT_TRACE_CLONE)
  1153. return PTRACE_EVENT_CLONE;
  1154. } else if (current->ptrace & PT_TRACE_FORK)
  1155. return PTRACE_EVENT_FORK;
  1156. return 0;
  1157. }
  1158. /*
  1159. * Ok, this is the main fork-routine.
  1160. *
  1161. * It copies the process, and if successful kick-starts
  1162. * it and waits for it to finish using the VM if required.
  1163. */
  1164. long do_fork(unsigned long clone_flags,
  1165. unsigned long stack_start,
  1166. struct pt_regs *regs,
  1167. unsigned long stack_size,
  1168. int __user *parent_tidptr,
  1169. int __user *child_tidptr)
  1170. {
  1171. struct task_struct *p;
  1172. int trace = 0;
  1173. struct pid *pid = alloc_pid();
  1174. long nr;
  1175. if (!pid)
  1176. return -EAGAIN;
  1177. nr = pid->nr;
  1178. if (unlikely(current->ptrace)) {
  1179. trace = fork_traceflag (clone_flags);
  1180. if (trace)
  1181. clone_flags |= CLONE_PTRACE;
  1182. }
  1183. p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, nr);
  1184. /*
  1185. * Do this prior waking up the new thread - the thread pointer
  1186. * might get invalid after that point, if the thread exits quickly.
  1187. */
  1188. if (!IS_ERR(p)) {
  1189. struct completion vfork;
  1190. if (clone_flags & CLONE_VFORK) {
  1191. p->vfork_done = &vfork;
  1192. init_completion(&vfork);
  1193. }
  1194. if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
  1195. /*
  1196. * We'll start up with an immediate SIGSTOP.
  1197. */
  1198. sigaddset(&p->pending.signal, SIGSTOP);
  1199. set_tsk_thread_flag(p, TIF_SIGPENDING);
  1200. }
  1201. if (!(clone_flags & CLONE_STOPPED))
  1202. wake_up_new_task(p, clone_flags);
  1203. else
  1204. p->state = TASK_STOPPED;
  1205. if (unlikely (trace)) {
  1206. current->ptrace_message = nr;
  1207. ptrace_notify ((trace << 8) | SIGTRAP);
  1208. }
  1209. if (clone_flags & CLONE_VFORK) {
  1210. wait_for_completion(&vfork);
  1211. if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
  1212. current->ptrace_message = nr;
  1213. ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
  1214. }
  1215. }
  1216. } else {
  1217. free_pid(pid);
  1218. nr = PTR_ERR(p);
  1219. }
  1220. return nr;
  1221. }
  1222. #ifndef ARCH_MIN_MMSTRUCT_ALIGN
  1223. #define ARCH_MIN_MMSTRUCT_ALIGN 0
  1224. #endif
  1225. static void sighand_ctor(void *data, struct kmem_cache *cachep, unsigned long flags)
  1226. {
  1227. struct sighand_struct *sighand = data;
  1228. if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
  1229. SLAB_CTOR_CONSTRUCTOR)
  1230. spin_lock_init(&sighand->siglock);
  1231. }
  1232. void __init proc_caches_init(void)
  1233. {
  1234. sighand_cachep = kmem_cache_create("sighand_cache",
  1235. sizeof(struct sighand_struct), 0,
  1236. SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,
  1237. sighand_ctor, NULL);
  1238. signal_cachep = kmem_cache_create("signal_cache",
  1239. sizeof(struct signal_struct), 0,
  1240. SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
  1241. files_cachep = kmem_cache_create("files_cache",
  1242. sizeof(struct files_struct), 0,
  1243. SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
  1244. fs_cachep = kmem_cache_create("fs_cache",
  1245. sizeof(struct fs_struct), 0,
  1246. SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
  1247. vm_area_cachep = kmem_cache_create("vm_area_struct",
  1248. sizeof(struct vm_area_struct), 0,
  1249. SLAB_PANIC, NULL, NULL);
  1250. mm_cachep = kmem_cache_create("mm_struct",
  1251. sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
  1252. SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
  1253. }
  1254. /*
  1255. * Check constraints on flags passed to the unshare system call and
  1256. * force unsharing of additional process context as appropriate.
  1257. */
  1258. static inline void check_unshare_flags(unsigned long *flags_ptr)
  1259. {
  1260. /*
  1261. * If unsharing a thread from a thread group, must also
  1262. * unshare vm.
  1263. */
  1264. if (*flags_ptr & CLONE_THREAD)
  1265. *flags_ptr |= CLONE_VM;
  1266. /*
  1267. * If unsharing vm, must also unshare signal handlers.
  1268. */
  1269. if (*flags_ptr & CLONE_VM)
  1270. *flags_ptr |= CLONE_SIGHAND;
  1271. /*
  1272. * If unsharing signal handlers and the task was created
  1273. * using CLONE_THREAD, then must unshare the thread
  1274. */
  1275. if ((*flags_ptr & CLONE_SIGHAND) &&
  1276. (atomic_read(&current->signal->count) > 1))
  1277. *flags_ptr |= CLONE_THREAD;
  1278. /*
  1279. * If unsharing namespace, must also unshare filesystem information.
  1280. */
  1281. if (*flags_ptr & CLONE_NEWNS)
  1282. *flags_ptr |= CLONE_FS;
  1283. }
  1284. /*
  1285. * Unsharing of tasks created with CLONE_THREAD is not supported yet
  1286. */
  1287. static int unshare_thread(unsigned long unshare_flags)
  1288. {
  1289. if (unshare_flags & CLONE_THREAD)
  1290. return -EINVAL;
  1291. return 0;
  1292. }
  1293. /*
  1294. * Unshare the filesystem structure if it is being shared
  1295. */
  1296. static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)
  1297. {
  1298. struct fs_struct *fs = current->fs;
  1299. if ((unshare_flags & CLONE_FS) &&
  1300. (fs && atomic_read(&fs->count) > 1)) {
  1301. *new_fsp = __copy_fs_struct(current->fs);
  1302. if (!*new_fsp)
  1303. return -ENOMEM;
  1304. }
  1305. return 0;
  1306. }
  1307. /*
  1308. * Unshare the mnt_namespace structure if it is being shared
  1309. */
  1310. static int unshare_mnt_namespace(unsigned long unshare_flags,
  1311. struct mnt_namespace **new_nsp, struct fs_struct *new_fs)
  1312. {
  1313. struct mnt_namespace *ns = current->nsproxy->mnt_ns;
  1314. if ((unshare_flags & CLONE_NEWNS) && ns) {
  1315. if (!capable(CAP_SYS_ADMIN))
  1316. return -EPERM;
  1317. *new_nsp = dup_mnt_ns(current, new_fs ? new_fs : current->fs);
  1318. if (!*new_nsp)
  1319. return -ENOMEM;
  1320. }
  1321. return 0;
  1322. }
  1323. /*
  1324. * Unsharing of sighand is not supported yet
  1325. */
  1326. static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)
  1327. {
  1328. struct sighand_struct *sigh = current->sighand;
  1329. if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)
  1330. return -EINVAL;
  1331. else
  1332. return 0;
  1333. }
  1334. /*
  1335. * Unshare vm if it is being shared
  1336. */
  1337. static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)
  1338. {
  1339. struct mm_struct *mm = current->mm;
  1340. if ((unshare_flags & CLONE_VM) &&
  1341. (mm && atomic_read(&mm->mm_users) > 1)) {
  1342. return -EINVAL;
  1343. }
  1344. return 0;
  1345. }
  1346. /*
  1347. * Unshare file descriptor table if it is being shared
  1348. */
  1349. static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)
  1350. {
  1351. struct files_struct *fd = current->files;
  1352. int error = 0;
  1353. if ((unshare_flags & CLONE_FILES) &&
  1354. (fd && atomic_read(&fd->count) > 1)) {
  1355. *new_fdp = dup_fd(fd, &error);
  1356. if (!*new_fdp)
  1357. return error;
  1358. }
  1359. return 0;
  1360. }
  1361. /*
  1362. * Unsharing of semundo for tasks created with CLONE_SYSVSEM is not
  1363. * supported yet
  1364. */
  1365. static int unshare_semundo(unsigned long unshare_flags, struct sem_undo_list **new_ulistp)
  1366. {
  1367. if (unshare_flags & CLONE_SYSVSEM)
  1368. return -EINVAL;
  1369. return 0;
  1370. }
  1371. #ifndef CONFIG_IPC_NS
  1372. static inline int unshare_ipcs(unsigned long flags, struct ipc_namespace **ns)
  1373. {
  1374. if (flags & CLONE_NEWIPC)
  1375. return -EINVAL;
  1376. return 0;
  1377. }
  1378. #endif
  1379. /*
  1380. * unshare allows a process to 'unshare' part of the process
  1381. * context which was originally shared using clone. copy_*
  1382. * functions used by do_fork() cannot be used here directly
  1383. * because they modify an inactive task_struct that is being
  1384. * constructed. Here we are modifying the current, active,
  1385. * task_struct.
  1386. */
  1387. asmlinkage long sys_unshare(unsigned long unshare_flags)
  1388. {
  1389. int err = 0;
  1390. struct fs_struct *fs, *new_fs = NULL;
  1391. struct mnt_namespace *ns, *new_ns = NULL;
  1392. struct sighand_struct *new_sigh = NULL;
  1393. struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;
  1394. struct files_struct *fd, *new_fd = NULL;
  1395. struct sem_undo_list *new_ulist = NULL;
  1396. struct nsproxy *new_nsproxy = NULL, *old_nsproxy = NULL;
  1397. struct uts_namespace *uts, *new_uts = NULL;
  1398. struct ipc_namespace *ipc, *new_ipc = NULL;
  1399. check_unshare_flags(&unshare_flags);
  1400. /* Return -EINVAL for all unsupported flags */
  1401. err = -EINVAL;
  1402. if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|
  1403. CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|
  1404. CLONE_NEWUTS|CLONE_NEWIPC))
  1405. goto bad_unshare_out;
  1406. if ((err = unshare_thread(unshare_flags)))
  1407. goto bad_unshare_out;
  1408. if ((err = unshare_fs(unshare_flags, &new_fs)))
  1409. goto bad_unshare_cleanup_thread;
  1410. if ((err = unshare_mnt_namespace(unshare_flags, &new_ns, new_fs)))
  1411. goto bad_unshare_cleanup_fs;
  1412. if ((err = unshare_sighand(unshare_flags, &new_sigh)))
  1413. goto bad_unshare_cleanup_ns;
  1414. if ((err = unshare_vm(unshare_flags, &new_mm)))
  1415. goto bad_unshare_cleanup_sigh;
  1416. if ((err = unshare_fd(unshare_flags, &new_fd)))
  1417. goto bad_unshare_cleanup_vm;
  1418. if ((err = unshare_semundo(unshare_flags, &new_ulist)))
  1419. goto bad_unshare_cleanup_fd;
  1420. if ((err = unshare_utsname(unshare_flags, &new_uts)))
  1421. goto bad_unshare_cleanup_semundo;
  1422. if ((err = unshare_ipcs(unshare_flags, &new_ipc)))
  1423. goto bad_unshare_cleanup_uts;
  1424. if (new_ns || new_uts || new_ipc) {
  1425. old_nsproxy = current->nsproxy;
  1426. new_nsproxy = dup_namespaces(old_nsproxy);
  1427. if (!new_nsproxy) {
  1428. err = -ENOMEM;
  1429. goto bad_unshare_cleanup_ipc;
  1430. }
  1431. }
  1432. if (new_fs || new_ns || new_mm || new_fd || new_ulist ||
  1433. new_uts || new_ipc) {
  1434. task_lock(current);
  1435. if (new_nsproxy) {
  1436. current->nsproxy = new_nsproxy;
  1437. new_nsproxy = old_nsproxy;
  1438. }
  1439. if (new_fs) {
  1440. fs = current->fs;
  1441. current->fs = new_fs;
  1442. new_fs = fs;
  1443. }
  1444. if (new_ns) {
  1445. ns = current->nsproxy->mnt_ns;
  1446. current->nsproxy->mnt_ns = new_ns;
  1447. new_ns = ns;
  1448. }
  1449. if (new_mm) {
  1450. mm = current->mm;
  1451. active_mm = current->active_mm;
  1452. current->mm = new_mm;
  1453. current->active_mm = new_mm;
  1454. activate_mm(active_mm, new_mm);
  1455. new_mm = mm;
  1456. }
  1457. if (new_fd) {
  1458. fd = current->files;
  1459. current->files = new_fd;
  1460. new_fd = fd;
  1461. }
  1462. if (new_uts) {
  1463. uts = current->nsproxy->uts_ns;
  1464. current->nsproxy->uts_ns = new_uts;
  1465. new_uts = uts;
  1466. }
  1467. if (new_ipc) {
  1468. ipc = current->nsproxy->ipc_ns;
  1469. current->nsproxy->ipc_ns = new_ipc;
  1470. new_ipc = ipc;
  1471. }
  1472. task_unlock(current);
  1473. }
  1474. if (new_nsproxy)
  1475. put_nsproxy(new_nsproxy);
  1476. bad_unshare_cleanup_ipc:
  1477. if (new_ipc)
  1478. put_ipc_ns(new_ipc);
  1479. bad_unshare_cleanup_uts:
  1480. if (new_uts)
  1481. put_uts_ns(new_uts);
  1482. bad_unshare_cleanup_semundo:
  1483. bad_unshare_cleanup_fd:
  1484. if (new_fd)
  1485. put_files_struct(new_fd);
  1486. bad_unshare_cleanup_vm:
  1487. if (new_mm)
  1488. mmput(new_mm);
  1489. bad_unshare_cleanup_sigh:
  1490. if (new_sigh)
  1491. if (atomic_dec_and_test(&new_sigh->count))
  1492. kmem_cache_free(sighand_cachep, new_sigh);
  1493. bad_unshare_cleanup_ns:
  1494. if (new_ns)
  1495. put_mnt_ns(new_ns);
  1496. bad_unshare_cleanup_fs:
  1497. if (new_fs)
  1498. put_fs_struct(new_fs);
  1499. bad_unshare_cleanup_thread:
  1500. bad_unshare_out:
  1501. return err;
  1502. }