exit.c 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662
  1. /*
  2. * linux/kernel/exit.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. */
  6. #include <linux/mm.h>
  7. #include <linux/slab.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/smp_lock.h>
  10. #include <linux/module.h>
  11. #include <linux/capability.h>
  12. #include <linux/completion.h>
  13. #include <linux/personality.h>
  14. #include <linux/tty.h>
  15. #include <linux/mnt_namespace.h>
  16. #include <linux/key.h>
  17. #include <linux/security.h>
  18. #include <linux/cpu.h>
  19. #include <linux/acct.h>
  20. #include <linux/tsacct_kern.h>
  21. #include <linux/file.h>
  22. #include <linux/binfmts.h>
  23. #include <linux/nsproxy.h>
  24. #include <linux/pid_namespace.h>
  25. #include <linux/ptrace.h>
  26. #include <linux/profile.h>
  27. #include <linux/mount.h>
  28. #include <linux/proc_fs.h>
  29. #include <linux/mempolicy.h>
  30. #include <linux/taskstats_kern.h>
  31. #include <linux/delayacct.h>
  32. #include <linux/cpuset.h>
  33. #include <linux/syscalls.h>
  34. #include <linux/signal.h>
  35. #include <linux/posix-timers.h>
  36. #include <linux/cn_proc.h>
  37. #include <linux/mutex.h>
  38. #include <linux/futex.h>
  39. #include <linux/compat.h>
  40. #include <linux/pipe_fs_i.h>
  41. #include <linux/audit.h> /* for audit_free() */
  42. #include <linux/resource.h>
  43. #include <linux/blkdev.h>
  44. #include <asm/uaccess.h>
  45. #include <asm/unistd.h>
  46. #include <asm/pgtable.h>
  47. #include <asm/mmu_context.h>
  48. extern void sem_exit (void);
  49. static void exit_mm(struct task_struct * tsk);
  50. static void __unhash_process(struct task_struct *p)
  51. {
  52. nr_threads--;
  53. detach_pid(p, PIDTYPE_PID);
  54. if (thread_group_leader(p)) {
  55. detach_pid(p, PIDTYPE_PGID);
  56. detach_pid(p, PIDTYPE_SID);
  57. list_del_rcu(&p->tasks);
  58. __get_cpu_var(process_counts)--;
  59. }
  60. list_del_rcu(&p->thread_group);
  61. remove_parent(p);
  62. }
  63. /*
  64. * This function expects the tasklist_lock write-locked.
  65. */
  66. static void __exit_signal(struct task_struct *tsk)
  67. {
  68. struct signal_struct *sig = tsk->signal;
  69. struct sighand_struct *sighand;
  70. BUG_ON(!sig);
  71. BUG_ON(!atomic_read(&sig->count));
  72. rcu_read_lock();
  73. sighand = rcu_dereference(tsk->sighand);
  74. spin_lock(&sighand->siglock);
  75. posix_cpu_timers_exit(tsk);
  76. if (atomic_dec_and_test(&sig->count))
  77. posix_cpu_timers_exit_group(tsk);
  78. else {
  79. /*
  80. * If there is any task waiting for the group exit
  81. * then notify it:
  82. */
  83. if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
  84. wake_up_process(sig->group_exit_task);
  85. sig->group_exit_task = NULL;
  86. }
  87. if (tsk == sig->curr_target)
  88. sig->curr_target = next_thread(tsk);
  89. /*
  90. * Accumulate here the counters for all threads but the
  91. * group leader as they die, so they can be added into
  92. * the process-wide totals when those are taken.
  93. * The group leader stays around as a zombie as long
  94. * as there are other threads. When it gets reaped,
  95. * the exit.c code will add its counts into these totals.
  96. * We won't ever get here for the group leader, since it
  97. * will have been the last reference on the signal_struct.
  98. */
  99. sig->utime = cputime_add(sig->utime, tsk->utime);
  100. sig->stime = cputime_add(sig->stime, tsk->stime);
  101. sig->min_flt += tsk->min_flt;
  102. sig->maj_flt += tsk->maj_flt;
  103. sig->nvcsw += tsk->nvcsw;
  104. sig->nivcsw += tsk->nivcsw;
  105. sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
  106. sig = NULL; /* Marker for below. */
  107. }
  108. __unhash_process(tsk);
  109. tsk->signal = NULL;
  110. tsk->sighand = NULL;
  111. spin_unlock(&sighand->siglock);
  112. rcu_read_unlock();
  113. __cleanup_sighand(sighand);
  114. clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
  115. flush_sigqueue(&tsk->pending);
  116. if (sig) {
  117. flush_sigqueue(&sig->shared_pending);
  118. taskstats_tgid_free(sig);
  119. __cleanup_signal(sig);
  120. }
  121. }
  122. static void delayed_put_task_struct(struct rcu_head *rhp)
  123. {
  124. put_task_struct(container_of(rhp, struct task_struct, rcu));
  125. }
  126. void release_task(struct task_struct * p)
  127. {
  128. struct task_struct *leader;
  129. int zap_leader;
  130. repeat:
  131. atomic_dec(&p->user->processes);
  132. write_lock_irq(&tasklist_lock);
  133. ptrace_unlink(p);
  134. BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children));
  135. __exit_signal(p);
  136. /*
  137. * If we are the last non-leader member of the thread
  138. * group, and the leader is zombie, then notify the
  139. * group leader's parent process. (if it wants notification.)
  140. */
  141. zap_leader = 0;
  142. leader = p->group_leader;
  143. if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
  144. BUG_ON(leader->exit_signal == -1);
  145. do_notify_parent(leader, leader->exit_signal);
  146. /*
  147. * If we were the last child thread and the leader has
  148. * exited already, and the leader's parent ignores SIGCHLD,
  149. * then we are the one who should release the leader.
  150. *
  151. * do_notify_parent() will have marked it self-reaping in
  152. * that case.
  153. */
  154. zap_leader = (leader->exit_signal == -1);
  155. }
  156. write_unlock_irq(&tasklist_lock);
  157. proc_flush_task(p);
  158. release_thread(p);
  159. call_rcu(&p->rcu, delayed_put_task_struct);
  160. p = leader;
  161. if (unlikely(zap_leader))
  162. goto repeat;
  163. }
  164. /*
  165. * This checks not only the pgrp, but falls back on the pid if no
  166. * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
  167. * without this...
  168. *
  169. * The caller must hold rcu lock or the tasklist lock.
  170. */
  171. struct pid *session_of_pgrp(struct pid *pgrp)
  172. {
  173. struct task_struct *p;
  174. struct pid *sid = NULL;
  175. p = pid_task(pgrp, PIDTYPE_PGID);
  176. if (p == NULL)
  177. p = pid_task(pgrp, PIDTYPE_PID);
  178. if (p != NULL)
  179. sid = task_session(p);
  180. return sid;
  181. }
  182. /*
  183. * Determine if a process group is "orphaned", according to the POSIX
  184. * definition in 2.2.2.52. Orphaned process groups are not to be affected
  185. * by terminal-generated stop signals. Newly orphaned process groups are
  186. * to receive a SIGHUP and a SIGCONT.
  187. *
  188. * "I ask you, have you ever known what it is to be an orphan?"
  189. */
  190. static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
  191. {
  192. struct task_struct *p;
  193. int ret = 1;
  194. do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
  195. if (p == ignored_task
  196. || p->exit_state
  197. || is_init(p->real_parent))
  198. continue;
  199. if (task_pgrp(p->real_parent) != pgrp &&
  200. task_session(p->real_parent) == task_session(p)) {
  201. ret = 0;
  202. break;
  203. }
  204. } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
  205. return ret; /* (sighing) "Often!" */
  206. }
  207. int is_current_pgrp_orphaned(void)
  208. {
  209. int retval;
  210. read_lock(&tasklist_lock);
  211. retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
  212. read_unlock(&tasklist_lock);
  213. return retval;
  214. }
  215. static int has_stopped_jobs(struct pid *pgrp)
  216. {
  217. int retval = 0;
  218. struct task_struct *p;
  219. do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
  220. if (p->state != TASK_STOPPED)
  221. continue;
  222. retval = 1;
  223. break;
  224. } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
  225. return retval;
  226. }
  227. /**
  228. * reparent_to_init - Reparent the calling kernel thread to the init task of the pid space that the thread belongs to.
  229. *
  230. * If a kernel thread is launched as a result of a system call, or if
  231. * it ever exits, it should generally reparent itself to init so that
  232. * it is correctly cleaned up on exit.
  233. *
  234. * The various task state such as scheduling policy and priority may have
  235. * been inherited from a user process, so we reset them to sane values here.
  236. *
  237. * NOTE that reparent_to_init() gives the caller full capabilities.
  238. */
  239. static void reparent_to_init(void)
  240. {
  241. write_lock_irq(&tasklist_lock);
  242. ptrace_unlink(current);
  243. /* Reparent to init */
  244. remove_parent(current);
  245. current->parent = child_reaper(current);
  246. current->real_parent = child_reaper(current);
  247. add_parent(current);
  248. /* Set the exit signal to SIGCHLD so we signal init on exit */
  249. current->exit_signal = SIGCHLD;
  250. if (task_nice(current) < 0)
  251. set_user_nice(current, 0);
  252. /* cpus_allowed? */
  253. /* rt_priority? */
  254. /* signals? */
  255. security_task_reparent_to_init(current);
  256. memcpy(current->signal->rlim, init_task.signal->rlim,
  257. sizeof(current->signal->rlim));
  258. atomic_inc(&(INIT_USER->__count));
  259. write_unlock_irq(&tasklist_lock);
  260. switch_uid(INIT_USER);
  261. }
  262. void __set_special_pids(pid_t session, pid_t pgrp)
  263. {
  264. struct task_struct *curr = current->group_leader;
  265. if (process_session(curr) != session) {
  266. detach_pid(curr, PIDTYPE_SID);
  267. set_signal_session(curr->signal, session);
  268. attach_pid(curr, PIDTYPE_SID, session);
  269. }
  270. if (process_group(curr) != pgrp) {
  271. detach_pid(curr, PIDTYPE_PGID);
  272. curr->signal->pgrp = pgrp;
  273. attach_pid(curr, PIDTYPE_PGID, pgrp);
  274. }
  275. }
  276. static void set_special_pids(pid_t session, pid_t pgrp)
  277. {
  278. write_lock_irq(&tasklist_lock);
  279. __set_special_pids(session, pgrp);
  280. write_unlock_irq(&tasklist_lock);
  281. }
  282. /*
  283. * Let kernel threads use this to say that they
  284. * allow a certain signal (since daemonize() will
  285. * have disabled all of them by default).
  286. */
  287. int allow_signal(int sig)
  288. {
  289. if (!valid_signal(sig) || sig < 1)
  290. return -EINVAL;
  291. spin_lock_irq(&current->sighand->siglock);
  292. sigdelset(&current->blocked, sig);
  293. if (!current->mm) {
  294. /* Kernel threads handle their own signals.
  295. Let the signal code know it'll be handled, so
  296. that they don't get converted to SIGKILL or
  297. just silently dropped */
  298. current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
  299. }
  300. recalc_sigpending();
  301. spin_unlock_irq(&current->sighand->siglock);
  302. return 0;
  303. }
  304. EXPORT_SYMBOL(allow_signal);
  305. int disallow_signal(int sig)
  306. {
  307. if (!valid_signal(sig) || sig < 1)
  308. return -EINVAL;
  309. spin_lock_irq(&current->sighand->siglock);
  310. sigaddset(&current->blocked, sig);
  311. recalc_sigpending();
  312. spin_unlock_irq(&current->sighand->siglock);
  313. return 0;
  314. }
  315. EXPORT_SYMBOL(disallow_signal);
  316. /*
  317. * Put all the gunge required to become a kernel thread without
  318. * attached user resources in one place where it belongs.
  319. */
  320. void daemonize(const char *name, ...)
  321. {
  322. va_list args;
  323. struct fs_struct *fs;
  324. sigset_t blocked;
  325. va_start(args, name);
  326. vsnprintf(current->comm, sizeof(current->comm), name, args);
  327. va_end(args);
  328. /*
  329. * If we were started as result of loading a module, close all of the
  330. * user space pages. We don't need them, and if we didn't close them
  331. * they would be locked into memory.
  332. */
  333. exit_mm(current);
  334. set_special_pids(1, 1);
  335. proc_clear_tty(current);
  336. /* Block and flush all signals */
  337. sigfillset(&blocked);
  338. sigprocmask(SIG_BLOCK, &blocked, NULL);
  339. flush_signals(current);
  340. /* Become as one with the init task */
  341. exit_fs(current); /* current->fs->count--; */
  342. fs = init_task.fs;
  343. current->fs = fs;
  344. atomic_inc(&fs->count);
  345. exit_task_namespaces(current);
  346. current->nsproxy = init_task.nsproxy;
  347. get_task_namespaces(current);
  348. exit_files(current);
  349. current->files = init_task.files;
  350. atomic_inc(&current->files->count);
  351. reparent_to_init();
  352. }
  353. EXPORT_SYMBOL(daemonize);
  354. static void close_files(struct files_struct * files)
  355. {
  356. int i, j;
  357. struct fdtable *fdt;
  358. j = 0;
  359. /*
  360. * It is safe to dereference the fd table without RCU or
  361. * ->file_lock because this is the last reference to the
  362. * files structure.
  363. */
  364. fdt = files_fdtable(files);
  365. for (;;) {
  366. unsigned long set;
  367. i = j * __NFDBITS;
  368. if (i >= fdt->max_fds)
  369. break;
  370. set = fdt->open_fds->fds_bits[j++];
  371. while (set) {
  372. if (set & 1) {
  373. struct file * file = xchg(&fdt->fd[i], NULL);
  374. if (file) {
  375. filp_close(file, files);
  376. cond_resched();
  377. }
  378. }
  379. i++;
  380. set >>= 1;
  381. }
  382. }
  383. }
  384. struct files_struct *get_files_struct(struct task_struct *task)
  385. {
  386. struct files_struct *files;
  387. task_lock(task);
  388. files = task->files;
  389. if (files)
  390. atomic_inc(&files->count);
  391. task_unlock(task);
  392. return files;
  393. }
  394. void fastcall put_files_struct(struct files_struct *files)
  395. {
  396. struct fdtable *fdt;
  397. if (atomic_dec_and_test(&files->count)) {
  398. close_files(files);
  399. /*
  400. * Free the fd and fdset arrays if we expanded them.
  401. * If the fdtable was embedded, pass files for freeing
  402. * at the end of the RCU grace period. Otherwise,
  403. * you can free files immediately.
  404. */
  405. fdt = files_fdtable(files);
  406. if (fdt != &files->fdtab)
  407. kmem_cache_free(files_cachep, files);
  408. free_fdtable(fdt);
  409. }
  410. }
  411. EXPORT_SYMBOL(put_files_struct);
  412. void reset_files_struct(struct task_struct *tsk, struct files_struct *files)
  413. {
  414. struct files_struct *old;
  415. old = tsk->files;
  416. task_lock(tsk);
  417. tsk->files = files;
  418. task_unlock(tsk);
  419. put_files_struct(old);
  420. }
  421. EXPORT_SYMBOL(reset_files_struct);
  422. static inline void __exit_files(struct task_struct *tsk)
  423. {
  424. struct files_struct * files = tsk->files;
  425. if (files) {
  426. task_lock(tsk);
  427. tsk->files = NULL;
  428. task_unlock(tsk);
  429. put_files_struct(files);
  430. }
  431. }
  432. void exit_files(struct task_struct *tsk)
  433. {
  434. __exit_files(tsk);
  435. }
  436. static inline void __put_fs_struct(struct fs_struct *fs)
  437. {
  438. /* No need to hold fs->lock if we are killing it */
  439. if (atomic_dec_and_test(&fs->count)) {
  440. dput(fs->root);
  441. mntput(fs->rootmnt);
  442. dput(fs->pwd);
  443. mntput(fs->pwdmnt);
  444. if (fs->altroot) {
  445. dput(fs->altroot);
  446. mntput(fs->altrootmnt);
  447. }
  448. kmem_cache_free(fs_cachep, fs);
  449. }
  450. }
  451. void put_fs_struct(struct fs_struct *fs)
  452. {
  453. __put_fs_struct(fs);
  454. }
  455. static inline void __exit_fs(struct task_struct *tsk)
  456. {
  457. struct fs_struct * fs = tsk->fs;
  458. if (fs) {
  459. task_lock(tsk);
  460. tsk->fs = NULL;
  461. task_unlock(tsk);
  462. __put_fs_struct(fs);
  463. }
  464. }
  465. void exit_fs(struct task_struct *tsk)
  466. {
  467. __exit_fs(tsk);
  468. }
  469. EXPORT_SYMBOL_GPL(exit_fs);
  470. /*
  471. * Turn us into a lazy TLB process if we
  472. * aren't already..
  473. */
  474. static void exit_mm(struct task_struct * tsk)
  475. {
  476. struct mm_struct *mm = tsk->mm;
  477. mm_release(tsk, mm);
  478. if (!mm)
  479. return;
  480. /*
  481. * Serialize with any possible pending coredump.
  482. * We must hold mmap_sem around checking core_waiters
  483. * and clearing tsk->mm. The core-inducing thread
  484. * will increment core_waiters for each thread in the
  485. * group with ->mm != NULL.
  486. */
  487. down_read(&mm->mmap_sem);
  488. if (mm->core_waiters) {
  489. up_read(&mm->mmap_sem);
  490. down_write(&mm->mmap_sem);
  491. if (!--mm->core_waiters)
  492. complete(mm->core_startup_done);
  493. up_write(&mm->mmap_sem);
  494. wait_for_completion(&mm->core_done);
  495. down_read(&mm->mmap_sem);
  496. }
  497. atomic_inc(&mm->mm_count);
  498. BUG_ON(mm != tsk->active_mm);
  499. /* more a memory barrier than a real lock */
  500. task_lock(tsk);
  501. tsk->mm = NULL;
  502. up_read(&mm->mmap_sem);
  503. enter_lazy_tlb(mm, current);
  504. task_unlock(tsk);
  505. mmput(mm);
  506. }
  507. static inline void
  508. choose_new_parent(struct task_struct *p, struct task_struct *reaper)
  509. {
  510. /*
  511. * Make sure we're not reparenting to ourselves and that
  512. * the parent is not a zombie.
  513. */
  514. BUG_ON(p == reaper || reaper->exit_state);
  515. p->real_parent = reaper;
  516. }
  517. static void
  518. reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
  519. {
  520. if (p->pdeath_signal)
  521. /* We already hold the tasklist_lock here. */
  522. group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);
  523. /* Move the child from its dying parent to the new one. */
  524. if (unlikely(traced)) {
  525. /* Preserve ptrace links if someone else is tracing this child. */
  526. list_del_init(&p->ptrace_list);
  527. if (p->parent != p->real_parent)
  528. list_add(&p->ptrace_list, &p->real_parent->ptrace_children);
  529. } else {
  530. /* If this child is being traced, then we're the one tracing it
  531. * anyway, so let go of it.
  532. */
  533. p->ptrace = 0;
  534. remove_parent(p);
  535. p->parent = p->real_parent;
  536. add_parent(p);
  537. if (p->state == TASK_TRACED) {
  538. /*
  539. * If it was at a trace stop, turn it into
  540. * a normal stop since it's no longer being
  541. * traced.
  542. */
  543. ptrace_untrace(p);
  544. }
  545. }
  546. /* If this is a threaded reparent there is no need to
  547. * notify anyone anything has happened.
  548. */
  549. if (p->real_parent->group_leader == father->group_leader)
  550. return;
  551. /* We don't want people slaying init. */
  552. if (p->exit_signal != -1)
  553. p->exit_signal = SIGCHLD;
  554. /* If we'd notified the old parent about this child's death,
  555. * also notify the new parent.
  556. */
  557. if (!traced && p->exit_state == EXIT_ZOMBIE &&
  558. p->exit_signal != -1 && thread_group_empty(p))
  559. do_notify_parent(p, p->exit_signal);
  560. /*
  561. * process group orphan check
  562. * Case ii: Our child is in a different pgrp
  563. * than we are, and it was the only connection
  564. * outside, so the child pgrp is now orphaned.
  565. */
  566. if ((task_pgrp(p) != task_pgrp(father)) &&
  567. (task_session(p) == task_session(father))) {
  568. struct pid *pgrp = task_pgrp(p);
  569. if (will_become_orphaned_pgrp(pgrp, NULL) &&
  570. has_stopped_jobs(pgrp)) {
  571. __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
  572. __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
  573. }
  574. }
  575. }
  576. /*
  577. * When we die, we re-parent all our children.
  578. * Try to give them to another thread in our thread
  579. * group, and if no such member exists, give it to
  580. * the child reaper process (ie "init") in our pid
  581. * space.
  582. */
  583. static void
  584. forget_original_parent(struct task_struct *father, struct list_head *to_release)
  585. {
  586. struct task_struct *p, *reaper = father;
  587. struct list_head *_p, *_n;
  588. do {
  589. reaper = next_thread(reaper);
  590. if (reaper == father) {
  591. reaper = child_reaper(father);
  592. break;
  593. }
  594. } while (reaper->exit_state);
  595. /*
  596. * There are only two places where our children can be:
  597. *
  598. * - in our child list
  599. * - in our ptraced child list
  600. *
  601. * Search them and reparent children.
  602. */
  603. list_for_each_safe(_p, _n, &father->children) {
  604. int ptrace;
  605. p = list_entry(_p, struct task_struct, sibling);
  606. ptrace = p->ptrace;
  607. /* if father isn't the real parent, then ptrace must be enabled */
  608. BUG_ON(father != p->real_parent && !ptrace);
  609. if (father == p->real_parent) {
  610. /* reparent with a reaper, real father it's us */
  611. choose_new_parent(p, reaper);
  612. reparent_thread(p, father, 0);
  613. } else {
  614. /* reparent ptraced task to its real parent */
  615. __ptrace_unlink (p);
  616. if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 &&
  617. thread_group_empty(p))
  618. do_notify_parent(p, p->exit_signal);
  619. }
  620. /*
  621. * if the ptraced child is a zombie with exit_signal == -1
  622. * we must collect it before we exit, or it will remain
  623. * zombie forever since we prevented it from self-reap itself
  624. * while it was being traced by us, to be able to see it in wait4.
  625. */
  626. if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && p->exit_signal == -1))
  627. list_add(&p->ptrace_list, to_release);
  628. }
  629. list_for_each_safe(_p, _n, &father->ptrace_children) {
  630. p = list_entry(_p, struct task_struct, ptrace_list);
  631. choose_new_parent(p, reaper);
  632. reparent_thread(p, father, 1);
  633. }
  634. }
  635. /*
  636. * Send signals to all our closest relatives so that they know
  637. * to properly mourn us..
  638. */
  639. static void exit_notify(struct task_struct *tsk)
  640. {
  641. int state;
  642. struct task_struct *t;
  643. struct list_head ptrace_dead, *_p, *_n;
  644. struct pid *pgrp;
  645. if (signal_pending(tsk) && !(tsk->signal->flags & SIGNAL_GROUP_EXIT)
  646. && !thread_group_empty(tsk)) {
  647. /*
  648. * This occurs when there was a race between our exit
  649. * syscall and a group signal choosing us as the one to
  650. * wake up. It could be that we are the only thread
  651. * alerted to check for pending signals, but another thread
  652. * should be woken now to take the signal since we will not.
  653. * Now we'll wake all the threads in the group just to make
  654. * sure someone gets all the pending signals.
  655. */
  656. read_lock(&tasklist_lock);
  657. spin_lock_irq(&tsk->sighand->siglock);
  658. for (t = next_thread(tsk); t != tsk; t = next_thread(t))
  659. if (!signal_pending(t) && !(t->flags & PF_EXITING)) {
  660. recalc_sigpending_tsk(t);
  661. if (signal_pending(t))
  662. signal_wake_up(t, 0);
  663. }
  664. spin_unlock_irq(&tsk->sighand->siglock);
  665. read_unlock(&tasklist_lock);
  666. }
  667. write_lock_irq(&tasklist_lock);
  668. /*
  669. * This does two things:
  670. *
  671. * A. Make init inherit all the child processes
  672. * B. Check to see if any process groups have become orphaned
  673. * as a result of our exiting, and if they have any stopped
  674. * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
  675. */
  676. INIT_LIST_HEAD(&ptrace_dead);
  677. forget_original_parent(tsk, &ptrace_dead);
  678. BUG_ON(!list_empty(&tsk->children));
  679. BUG_ON(!list_empty(&tsk->ptrace_children));
  680. /*
  681. * Check to see if any process groups have become orphaned
  682. * as a result of our exiting, and if they have any stopped
  683. * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
  684. *
  685. * Case i: Our father is in a different pgrp than we are
  686. * and we were the only connection outside, so our pgrp
  687. * is about to become orphaned.
  688. */
  689. t = tsk->real_parent;
  690. pgrp = task_pgrp(tsk);
  691. if ((task_pgrp(t) != pgrp) &&
  692. (task_session(t) == task_session(tsk)) &&
  693. will_become_orphaned_pgrp(pgrp, tsk) &&
  694. has_stopped_jobs(pgrp)) {
  695. __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
  696. __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
  697. }
  698. /* Let father know we died
  699. *
  700. * Thread signals are configurable, but you aren't going to use
  701. * that to send signals to arbitary processes.
  702. * That stops right now.
  703. *
  704. * If the parent exec id doesn't match the exec id we saved
  705. * when we started then we know the parent has changed security
  706. * domain.
  707. *
  708. * If our self_exec id doesn't match our parent_exec_id then
  709. * we have changed execution domain as these two values started
  710. * the same after a fork.
  711. *
  712. */
  713. if (tsk->exit_signal != SIGCHLD && tsk->exit_signal != -1 &&
  714. ( tsk->parent_exec_id != t->self_exec_id ||
  715. tsk->self_exec_id != tsk->parent_exec_id)
  716. && !capable(CAP_KILL))
  717. tsk->exit_signal = SIGCHLD;
  718. /* If something other than our normal parent is ptracing us, then
  719. * send it a SIGCHLD instead of honoring exit_signal. exit_signal
  720. * only has special meaning to our real parent.
  721. */
  722. if (tsk->exit_signal != -1 && thread_group_empty(tsk)) {
  723. int signal = tsk->parent == tsk->real_parent ? tsk->exit_signal : SIGCHLD;
  724. do_notify_parent(tsk, signal);
  725. } else if (tsk->ptrace) {
  726. do_notify_parent(tsk, SIGCHLD);
  727. }
  728. state = EXIT_ZOMBIE;
  729. if (tsk->exit_signal == -1 &&
  730. (likely(tsk->ptrace == 0) ||
  731. unlikely(tsk->parent->signal->flags & SIGNAL_GROUP_EXIT)))
  732. state = EXIT_DEAD;
  733. tsk->exit_state = state;
  734. write_unlock_irq(&tasklist_lock);
  735. list_for_each_safe(_p, _n, &ptrace_dead) {
  736. list_del_init(_p);
  737. t = list_entry(_p, struct task_struct, ptrace_list);
  738. release_task(t);
  739. }
  740. /* If the process is dead, release it - nobody will wait for it */
  741. if (state == EXIT_DEAD)
  742. release_task(tsk);
  743. }
  744. fastcall NORET_TYPE void do_exit(long code)
  745. {
  746. struct task_struct *tsk = current;
  747. int group_dead;
  748. profile_task_exit(tsk);
  749. WARN_ON(atomic_read(&tsk->fs_excl));
  750. if (unlikely(in_interrupt()))
  751. panic("Aiee, killing interrupt handler!");
  752. if (unlikely(!tsk->pid))
  753. panic("Attempted to kill the idle task!");
  754. if (unlikely(tsk == child_reaper(tsk))) {
  755. if (tsk->nsproxy->pid_ns != &init_pid_ns)
  756. tsk->nsproxy->pid_ns->child_reaper = init_pid_ns.child_reaper;
  757. else
  758. panic("Attempted to kill init!");
  759. }
  760. if (unlikely(current->ptrace & PT_TRACE_EXIT)) {
  761. current->ptrace_message = code;
  762. ptrace_notify((PTRACE_EVENT_EXIT << 8) | SIGTRAP);
  763. }
  764. /*
  765. * We're taking recursive faults here in do_exit. Safest is to just
  766. * leave this task alone and wait for reboot.
  767. */
  768. if (unlikely(tsk->flags & PF_EXITING)) {
  769. printk(KERN_ALERT
  770. "Fixing recursive fault but reboot is needed!\n");
  771. if (tsk->io_context)
  772. exit_io_context();
  773. set_current_state(TASK_UNINTERRUPTIBLE);
  774. schedule();
  775. }
  776. tsk->flags |= PF_EXITING;
  777. if (unlikely(in_atomic()))
  778. printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
  779. current->comm, current->pid,
  780. preempt_count());
  781. acct_update_integrals(tsk);
  782. if (tsk->mm) {
  783. update_hiwater_rss(tsk->mm);
  784. update_hiwater_vm(tsk->mm);
  785. }
  786. group_dead = atomic_dec_and_test(&tsk->signal->live);
  787. if (group_dead) {
  788. hrtimer_cancel(&tsk->signal->real_timer);
  789. exit_itimers(tsk->signal);
  790. }
  791. acct_collect(code, group_dead);
  792. if (unlikely(tsk->robust_list))
  793. exit_robust_list(tsk);
  794. #if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT)
  795. if (unlikely(tsk->compat_robust_list))
  796. compat_exit_robust_list(tsk);
  797. #endif
  798. if (unlikely(tsk->audit_context))
  799. audit_free(tsk);
  800. taskstats_exit(tsk, group_dead);
  801. exit_mm(tsk);
  802. if (group_dead)
  803. acct_process();
  804. exit_sem(tsk);
  805. __exit_files(tsk);
  806. __exit_fs(tsk);
  807. exit_thread();
  808. cpuset_exit(tsk);
  809. exit_keys(tsk);
  810. if (group_dead && tsk->signal->leader)
  811. disassociate_ctty(1);
  812. module_put(task_thread_info(tsk)->exec_domain->module);
  813. if (tsk->binfmt)
  814. module_put(tsk->binfmt->module);
  815. tsk->exit_code = code;
  816. proc_exit_connector(tsk);
  817. exit_task_namespaces(tsk);
  818. exit_notify(tsk);
  819. #ifdef CONFIG_NUMA
  820. mpol_free(tsk->mempolicy);
  821. tsk->mempolicy = NULL;
  822. #endif
  823. /*
  824. * This must happen late, after the PID is not
  825. * hashed anymore:
  826. */
  827. if (unlikely(!list_empty(&tsk->pi_state_list)))
  828. exit_pi_state_list(tsk);
  829. if (unlikely(current->pi_state_cache))
  830. kfree(current->pi_state_cache);
  831. /*
  832. * Make sure we are holding no locks:
  833. */
  834. debug_check_no_locks_held(tsk);
  835. if (tsk->io_context)
  836. exit_io_context();
  837. if (tsk->splice_pipe)
  838. __free_pipe_info(tsk->splice_pipe);
  839. preempt_disable();
  840. /* causes final put_task_struct in finish_task_switch(). */
  841. tsk->state = TASK_DEAD;
  842. schedule();
  843. BUG();
  844. /* Avoid "noreturn function does return". */
  845. for (;;)
  846. cpu_relax(); /* For when BUG is null */
  847. }
  848. EXPORT_SYMBOL_GPL(do_exit);
  849. NORET_TYPE void complete_and_exit(struct completion *comp, long code)
  850. {
  851. if (comp)
  852. complete(comp);
  853. do_exit(code);
  854. }
  855. EXPORT_SYMBOL(complete_and_exit);
  856. asmlinkage long sys_exit(int error_code)
  857. {
  858. do_exit((error_code&0xff)<<8);
  859. }
  860. /*
  861. * Take down every thread in the group. This is called by fatal signals
  862. * as well as by sys_exit_group (below).
  863. */
  864. NORET_TYPE void
  865. do_group_exit(int exit_code)
  866. {
  867. BUG_ON(exit_code & 0x80); /* core dumps don't get here */
  868. if (current->signal->flags & SIGNAL_GROUP_EXIT)
  869. exit_code = current->signal->group_exit_code;
  870. else if (!thread_group_empty(current)) {
  871. struct signal_struct *const sig = current->signal;
  872. struct sighand_struct *const sighand = current->sighand;
  873. spin_lock_irq(&sighand->siglock);
  874. if (sig->flags & SIGNAL_GROUP_EXIT)
  875. /* Another thread got here before we took the lock. */
  876. exit_code = sig->group_exit_code;
  877. else {
  878. sig->group_exit_code = exit_code;
  879. zap_other_threads(current);
  880. }
  881. spin_unlock_irq(&sighand->siglock);
  882. }
  883. do_exit(exit_code);
  884. /* NOTREACHED */
  885. }
  886. /*
  887. * this kills every thread in the thread group. Note that any externally
  888. * wait4()-ing process will get the correct exit code - even if this
  889. * thread is not the thread group leader.
  890. */
  891. asmlinkage void sys_exit_group(int error_code)
  892. {
  893. do_group_exit((error_code & 0xff) << 8);
  894. }
  895. static int eligible_child(pid_t pid, int options, struct task_struct *p)
  896. {
  897. if (pid > 0) {
  898. if (p->pid != pid)
  899. return 0;
  900. } else if (!pid) {
  901. if (process_group(p) != process_group(current))
  902. return 0;
  903. } else if (pid != -1) {
  904. if (process_group(p) != -pid)
  905. return 0;
  906. }
  907. /*
  908. * Do not consider detached threads that are
  909. * not ptraced:
  910. */
  911. if (p->exit_signal == -1 && !p->ptrace)
  912. return 0;
  913. /* Wait for all children (clone and not) if __WALL is set;
  914. * otherwise, wait for clone children *only* if __WCLONE is
  915. * set; otherwise, wait for non-clone children *only*. (Note:
  916. * A "clone" child here is one that reports to its parent
  917. * using a signal other than SIGCHLD.) */
  918. if (((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
  919. && !(options & __WALL))
  920. return 0;
  921. /*
  922. * Do not consider thread group leaders that are
  923. * in a non-empty thread group:
  924. */
  925. if (delay_group_leader(p))
  926. return 2;
  927. if (security_task_wait(p))
  928. return 0;
  929. return 1;
  930. }
  931. static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
  932. int why, int status,
  933. struct siginfo __user *infop,
  934. struct rusage __user *rusagep)
  935. {
  936. int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
  937. put_task_struct(p);
  938. if (!retval)
  939. retval = put_user(SIGCHLD, &infop->si_signo);
  940. if (!retval)
  941. retval = put_user(0, &infop->si_errno);
  942. if (!retval)
  943. retval = put_user((short)why, &infop->si_code);
  944. if (!retval)
  945. retval = put_user(pid, &infop->si_pid);
  946. if (!retval)
  947. retval = put_user(uid, &infop->si_uid);
  948. if (!retval)
  949. retval = put_user(status, &infop->si_status);
  950. if (!retval)
  951. retval = pid;
  952. return retval;
  953. }
  954. /*
  955. * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold
  956. * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
  957. * the lock and this task is uninteresting. If we return nonzero, we have
  958. * released the lock and the system call should return.
  959. */
  960. static int wait_task_zombie(struct task_struct *p, int noreap,
  961. struct siginfo __user *infop,
  962. int __user *stat_addr, struct rusage __user *ru)
  963. {
  964. unsigned long state;
  965. int retval;
  966. int status;
  967. if (unlikely(noreap)) {
  968. pid_t pid = p->pid;
  969. uid_t uid = p->uid;
  970. int exit_code = p->exit_code;
  971. int why, status;
  972. if (unlikely(p->exit_state != EXIT_ZOMBIE))
  973. return 0;
  974. if (unlikely(p->exit_signal == -1 && p->ptrace == 0))
  975. return 0;
  976. get_task_struct(p);
  977. read_unlock(&tasklist_lock);
  978. if ((exit_code & 0x7f) == 0) {
  979. why = CLD_EXITED;
  980. status = exit_code >> 8;
  981. } else {
  982. why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
  983. status = exit_code & 0x7f;
  984. }
  985. return wait_noreap_copyout(p, pid, uid, why,
  986. status, infop, ru);
  987. }
  988. /*
  989. * Try to move the task's state to DEAD
  990. * only one thread is allowed to do this:
  991. */
  992. state = xchg(&p->exit_state, EXIT_DEAD);
  993. if (state != EXIT_ZOMBIE) {
  994. BUG_ON(state != EXIT_DEAD);
  995. return 0;
  996. }
  997. if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) {
  998. /*
  999. * This can only happen in a race with a ptraced thread
  1000. * dying on another processor.
  1001. */
  1002. return 0;
  1003. }
  1004. if (likely(p->real_parent == p->parent) && likely(p->signal)) {
  1005. struct signal_struct *psig;
  1006. struct signal_struct *sig;
  1007. /*
  1008. * The resource counters for the group leader are in its
  1009. * own task_struct. Those for dead threads in the group
  1010. * are in its signal_struct, as are those for the child
  1011. * processes it has previously reaped. All these
  1012. * accumulate in the parent's signal_struct c* fields.
  1013. *
  1014. * We don't bother to take a lock here to protect these
  1015. * p->signal fields, because they are only touched by
  1016. * __exit_signal, which runs with tasklist_lock
  1017. * write-locked anyway, and so is excluded here. We do
  1018. * need to protect the access to p->parent->signal fields,
  1019. * as other threads in the parent group can be right
  1020. * here reaping other children at the same time.
  1021. */
  1022. spin_lock_irq(&p->parent->sighand->siglock);
  1023. psig = p->parent->signal;
  1024. sig = p->signal;
  1025. psig->cutime =
  1026. cputime_add(psig->cutime,
  1027. cputime_add(p->utime,
  1028. cputime_add(sig->utime,
  1029. sig->cutime)));
  1030. psig->cstime =
  1031. cputime_add(psig->cstime,
  1032. cputime_add(p->stime,
  1033. cputime_add(sig->stime,
  1034. sig->cstime)));
  1035. psig->cmin_flt +=
  1036. p->min_flt + sig->min_flt + sig->cmin_flt;
  1037. psig->cmaj_flt +=
  1038. p->maj_flt + sig->maj_flt + sig->cmaj_flt;
  1039. psig->cnvcsw +=
  1040. p->nvcsw + sig->nvcsw + sig->cnvcsw;
  1041. psig->cnivcsw +=
  1042. p->nivcsw + sig->nivcsw + sig->cnivcsw;
  1043. spin_unlock_irq(&p->parent->sighand->siglock);
  1044. }
  1045. /*
  1046. * Now we are sure this task is interesting, and no other
  1047. * thread can reap it because we set its state to EXIT_DEAD.
  1048. */
  1049. read_unlock(&tasklist_lock);
  1050. retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
  1051. status = (p->signal->flags & SIGNAL_GROUP_EXIT)
  1052. ? p->signal->group_exit_code : p->exit_code;
  1053. if (!retval && stat_addr)
  1054. retval = put_user(status, stat_addr);
  1055. if (!retval && infop)
  1056. retval = put_user(SIGCHLD, &infop->si_signo);
  1057. if (!retval && infop)
  1058. retval = put_user(0, &infop->si_errno);
  1059. if (!retval && infop) {
  1060. int why;
  1061. if ((status & 0x7f) == 0) {
  1062. why = CLD_EXITED;
  1063. status >>= 8;
  1064. } else {
  1065. why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
  1066. status &= 0x7f;
  1067. }
  1068. retval = put_user((short)why, &infop->si_code);
  1069. if (!retval)
  1070. retval = put_user(status, &infop->si_status);
  1071. }
  1072. if (!retval && infop)
  1073. retval = put_user(p->pid, &infop->si_pid);
  1074. if (!retval && infop)
  1075. retval = put_user(p->uid, &infop->si_uid);
  1076. if (retval) {
  1077. // TODO: is this safe?
  1078. p->exit_state = EXIT_ZOMBIE;
  1079. return retval;
  1080. }
  1081. retval = p->pid;
  1082. if (p->real_parent != p->parent) {
  1083. write_lock_irq(&tasklist_lock);
  1084. /* Double-check with lock held. */
  1085. if (p->real_parent != p->parent) {
  1086. __ptrace_unlink(p);
  1087. // TODO: is this safe?
  1088. p->exit_state = EXIT_ZOMBIE;
  1089. /*
  1090. * If this is not a detached task, notify the parent.
  1091. * If it's still not detached after that, don't release
  1092. * it now.
  1093. */
  1094. if (p->exit_signal != -1) {
  1095. do_notify_parent(p, p->exit_signal);
  1096. if (p->exit_signal != -1)
  1097. p = NULL;
  1098. }
  1099. }
  1100. write_unlock_irq(&tasklist_lock);
  1101. }
  1102. if (p != NULL)
  1103. release_task(p);
  1104. BUG_ON(!retval);
  1105. return retval;
  1106. }
  1107. /*
  1108. * Handle sys_wait4 work for one task in state TASK_STOPPED. We hold
  1109. * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
  1110. * the lock and this task is uninteresting. If we return nonzero, we have
  1111. * released the lock and the system call should return.
  1112. */
  1113. static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
  1114. int noreap, struct siginfo __user *infop,
  1115. int __user *stat_addr, struct rusage __user *ru)
  1116. {
  1117. int retval, exit_code;
  1118. if (!p->exit_code)
  1119. return 0;
  1120. if (delayed_group_leader && !(p->ptrace & PT_PTRACED) &&
  1121. p->signal && p->signal->group_stop_count > 0)
  1122. /*
  1123. * A group stop is in progress and this is the group leader.
  1124. * We won't report until all threads have stopped.
  1125. */
  1126. return 0;
  1127. /*
  1128. * Now we are pretty sure this task is interesting.
  1129. * Make sure it doesn't get reaped out from under us while we
  1130. * give up the lock and then examine it below. We don't want to
  1131. * keep holding onto the tasklist_lock while we call getrusage and
  1132. * possibly take page faults for user memory.
  1133. */
  1134. get_task_struct(p);
  1135. read_unlock(&tasklist_lock);
  1136. if (unlikely(noreap)) {
  1137. pid_t pid = p->pid;
  1138. uid_t uid = p->uid;
  1139. int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;
  1140. exit_code = p->exit_code;
  1141. if (unlikely(!exit_code) ||
  1142. unlikely(p->state & TASK_TRACED))
  1143. goto bail_ref;
  1144. return wait_noreap_copyout(p, pid, uid,
  1145. why, (exit_code << 8) | 0x7f,
  1146. infop, ru);
  1147. }
  1148. write_lock_irq(&tasklist_lock);
  1149. /*
  1150. * This uses xchg to be atomic with the thread resuming and setting
  1151. * it. It must also be done with the write lock held to prevent a
  1152. * race with the EXIT_ZOMBIE case.
  1153. */
  1154. exit_code = xchg(&p->exit_code, 0);
  1155. if (unlikely(p->exit_state)) {
  1156. /*
  1157. * The task resumed and then died. Let the next iteration
  1158. * catch it in EXIT_ZOMBIE. Note that exit_code might
  1159. * already be zero here if it resumed and did _exit(0).
  1160. * The task itself is dead and won't touch exit_code again;
  1161. * other processors in this function are locked out.
  1162. */
  1163. p->exit_code = exit_code;
  1164. exit_code = 0;
  1165. }
  1166. if (unlikely(exit_code == 0)) {
  1167. /*
  1168. * Another thread in this function got to it first, or it
  1169. * resumed, or it resumed and then died.
  1170. */
  1171. write_unlock_irq(&tasklist_lock);
  1172. bail_ref:
  1173. put_task_struct(p);
  1174. /*
  1175. * We are returning to the wait loop without having successfully
  1176. * removed the process and having released the lock. We cannot
  1177. * continue, since the "p" task pointer is potentially stale.
  1178. *
  1179. * Return -EAGAIN, and do_wait() will restart the loop from the
  1180. * beginning. Do _not_ re-acquire the lock.
  1181. */
  1182. return -EAGAIN;
  1183. }
  1184. /* move to end of parent's list to avoid starvation */
  1185. remove_parent(p);
  1186. add_parent(p);
  1187. write_unlock_irq(&tasklist_lock);
  1188. retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
  1189. if (!retval && stat_addr)
  1190. retval = put_user((exit_code << 8) | 0x7f, stat_addr);
  1191. if (!retval && infop)
  1192. retval = put_user(SIGCHLD, &infop->si_signo);
  1193. if (!retval && infop)
  1194. retval = put_user(0, &infop->si_errno);
  1195. if (!retval && infop)
  1196. retval = put_user((short)((p->ptrace & PT_PTRACED)
  1197. ? CLD_TRAPPED : CLD_STOPPED),
  1198. &infop->si_code);
  1199. if (!retval && infop)
  1200. retval = put_user(exit_code, &infop->si_status);
  1201. if (!retval && infop)
  1202. retval = put_user(p->pid, &infop->si_pid);
  1203. if (!retval && infop)
  1204. retval = put_user(p->uid, &infop->si_uid);
  1205. if (!retval)
  1206. retval = p->pid;
  1207. put_task_struct(p);
  1208. BUG_ON(!retval);
  1209. return retval;
  1210. }
  1211. /*
  1212. * Handle do_wait work for one task in a live, non-stopped state.
  1213. * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
  1214. * the lock and this task is uninteresting. If we return nonzero, we have
  1215. * released the lock and the system call should return.
  1216. */
  1217. static int wait_task_continued(struct task_struct *p, int noreap,
  1218. struct siginfo __user *infop,
  1219. int __user *stat_addr, struct rusage __user *ru)
  1220. {
  1221. int retval;
  1222. pid_t pid;
  1223. uid_t uid;
  1224. if (unlikely(!p->signal))
  1225. return 0;
  1226. if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
  1227. return 0;
  1228. spin_lock_irq(&p->sighand->siglock);
  1229. /* Re-check with the lock held. */
  1230. if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
  1231. spin_unlock_irq(&p->sighand->siglock);
  1232. return 0;
  1233. }
  1234. if (!noreap)
  1235. p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
  1236. spin_unlock_irq(&p->sighand->siglock);
  1237. pid = p->pid;
  1238. uid = p->uid;
  1239. get_task_struct(p);
  1240. read_unlock(&tasklist_lock);
  1241. if (!infop) {
  1242. retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
  1243. put_task_struct(p);
  1244. if (!retval && stat_addr)
  1245. retval = put_user(0xffff, stat_addr);
  1246. if (!retval)
  1247. retval = p->pid;
  1248. } else {
  1249. retval = wait_noreap_copyout(p, pid, uid,
  1250. CLD_CONTINUED, SIGCONT,
  1251. infop, ru);
  1252. BUG_ON(retval == 0);
  1253. }
  1254. return retval;
  1255. }
  1256. static inline int my_ptrace_child(struct task_struct *p)
  1257. {
  1258. if (!(p->ptrace & PT_PTRACED))
  1259. return 0;
  1260. if (!(p->ptrace & PT_ATTACHED))
  1261. return 1;
  1262. /*
  1263. * This child was PTRACE_ATTACH'd. We should be seeing it only if
  1264. * we are the attacher. If we are the real parent, this is a race
  1265. * inside ptrace_attach. It is waiting for the tasklist_lock,
  1266. * which we have to switch the parent links, but has already set
  1267. * the flags in p->ptrace.
  1268. */
  1269. return (p->parent != p->real_parent);
  1270. }
  1271. static long do_wait(pid_t pid, int options, struct siginfo __user *infop,
  1272. int __user *stat_addr, struct rusage __user *ru)
  1273. {
  1274. DECLARE_WAITQUEUE(wait, current);
  1275. struct task_struct *tsk;
  1276. int flag, retval;
  1277. add_wait_queue(&current->signal->wait_chldexit,&wait);
  1278. repeat:
  1279. /*
  1280. * We will set this flag if we see any child that might later
  1281. * match our criteria, even if we are not able to reap it yet.
  1282. */
  1283. flag = 0;
  1284. current->state = TASK_INTERRUPTIBLE;
  1285. read_lock(&tasklist_lock);
  1286. tsk = current;
  1287. do {
  1288. struct task_struct *p;
  1289. struct list_head *_p;
  1290. int ret;
  1291. list_for_each(_p,&tsk->children) {
  1292. p = list_entry(_p, struct task_struct, sibling);
  1293. ret = eligible_child(pid, options, p);
  1294. if (!ret)
  1295. continue;
  1296. switch (p->state) {
  1297. case TASK_TRACED:
  1298. /*
  1299. * When we hit the race with PTRACE_ATTACH,
  1300. * we will not report this child. But the
  1301. * race means it has not yet been moved to
  1302. * our ptrace_children list, so we need to
  1303. * set the flag here to avoid a spurious ECHILD
  1304. * when the race happens with the only child.
  1305. */
  1306. flag = 1;
  1307. if (!my_ptrace_child(p))
  1308. continue;
  1309. /*FALLTHROUGH*/
  1310. case TASK_STOPPED:
  1311. /*
  1312. * It's stopped now, so it might later
  1313. * continue, exit, or stop again.
  1314. */
  1315. flag = 1;
  1316. if (!(options & WUNTRACED) &&
  1317. !my_ptrace_child(p))
  1318. continue;
  1319. retval = wait_task_stopped(p, ret == 2,
  1320. (options & WNOWAIT),
  1321. infop,
  1322. stat_addr, ru);
  1323. if (retval == -EAGAIN)
  1324. goto repeat;
  1325. if (retval != 0) /* He released the lock. */
  1326. goto end;
  1327. break;
  1328. default:
  1329. // case EXIT_DEAD:
  1330. if (p->exit_state == EXIT_DEAD)
  1331. continue;
  1332. // case EXIT_ZOMBIE:
  1333. if (p->exit_state == EXIT_ZOMBIE) {
  1334. /*
  1335. * Eligible but we cannot release
  1336. * it yet:
  1337. */
  1338. if (ret == 2)
  1339. goto check_continued;
  1340. if (!likely(options & WEXITED))
  1341. continue;
  1342. retval = wait_task_zombie(
  1343. p, (options & WNOWAIT),
  1344. infop, stat_addr, ru);
  1345. /* He released the lock. */
  1346. if (retval != 0)
  1347. goto end;
  1348. break;
  1349. }
  1350. check_continued:
  1351. /*
  1352. * It's running now, so it might later
  1353. * exit, stop, or stop and then continue.
  1354. */
  1355. flag = 1;
  1356. if (!unlikely(options & WCONTINUED))
  1357. continue;
  1358. retval = wait_task_continued(
  1359. p, (options & WNOWAIT),
  1360. infop, stat_addr, ru);
  1361. if (retval != 0) /* He released the lock. */
  1362. goto end;
  1363. break;
  1364. }
  1365. }
  1366. if (!flag) {
  1367. list_for_each(_p, &tsk->ptrace_children) {
  1368. p = list_entry(_p, struct task_struct,
  1369. ptrace_list);
  1370. if (!eligible_child(pid, options, p))
  1371. continue;
  1372. flag = 1;
  1373. break;
  1374. }
  1375. }
  1376. if (options & __WNOTHREAD)
  1377. break;
  1378. tsk = next_thread(tsk);
  1379. BUG_ON(tsk->signal != current->signal);
  1380. } while (tsk != current);
  1381. read_unlock(&tasklist_lock);
  1382. if (flag) {
  1383. retval = 0;
  1384. if (options & WNOHANG)
  1385. goto end;
  1386. retval = -ERESTARTSYS;
  1387. if (signal_pending(current))
  1388. goto end;
  1389. schedule();
  1390. goto repeat;
  1391. }
  1392. retval = -ECHILD;
  1393. end:
  1394. current->state = TASK_RUNNING;
  1395. remove_wait_queue(&current->signal->wait_chldexit,&wait);
  1396. if (infop) {
  1397. if (retval > 0)
  1398. retval = 0;
  1399. else {
  1400. /*
  1401. * For a WNOHANG return, clear out all the fields
  1402. * we would set so the user can easily tell the
  1403. * difference.
  1404. */
  1405. if (!retval)
  1406. retval = put_user(0, &infop->si_signo);
  1407. if (!retval)
  1408. retval = put_user(0, &infop->si_errno);
  1409. if (!retval)
  1410. retval = put_user(0, &infop->si_code);
  1411. if (!retval)
  1412. retval = put_user(0, &infop->si_pid);
  1413. if (!retval)
  1414. retval = put_user(0, &infop->si_uid);
  1415. if (!retval)
  1416. retval = put_user(0, &infop->si_status);
  1417. }
  1418. }
  1419. return retval;
  1420. }
  1421. asmlinkage long sys_waitid(int which, pid_t pid,
  1422. struct siginfo __user *infop, int options,
  1423. struct rusage __user *ru)
  1424. {
  1425. long ret;
  1426. if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED))
  1427. return -EINVAL;
  1428. if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
  1429. return -EINVAL;
  1430. switch (which) {
  1431. case P_ALL:
  1432. pid = -1;
  1433. break;
  1434. case P_PID:
  1435. if (pid <= 0)
  1436. return -EINVAL;
  1437. break;
  1438. case P_PGID:
  1439. if (pid <= 0)
  1440. return -EINVAL;
  1441. pid = -pid;
  1442. break;
  1443. default:
  1444. return -EINVAL;
  1445. }
  1446. ret = do_wait(pid, options, infop, NULL, ru);
  1447. /* avoid REGPARM breakage on x86: */
  1448. prevent_tail_call(ret);
  1449. return ret;
  1450. }
  1451. asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr,
  1452. int options, struct rusage __user *ru)
  1453. {
  1454. long ret;
  1455. if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
  1456. __WNOTHREAD|__WCLONE|__WALL))
  1457. return -EINVAL;
  1458. ret = do_wait(pid, options | WEXITED, NULL, stat_addr, ru);
  1459. /* avoid REGPARM breakage on x86: */
  1460. prevent_tail_call(ret);
  1461. return ret;
  1462. }
  1463. #ifdef __ARCH_WANT_SYS_WAITPID
  1464. /*
  1465. * sys_waitpid() remains for compatibility. waitpid() should be
  1466. * implemented by calling sys_wait4() from libc.a.
  1467. */
  1468. asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options)
  1469. {
  1470. return sys_wait4(pid, stat_addr, options, NULL);
  1471. }
  1472. #endif