开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
signal.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：28k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

signal.c：源码内容
  1. /*
  2.  *  linux/kernel/signal.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  *
  6.  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
  7.  */
  9. #include <linux/config.h>
  10. #include <linux/slab.h>
  11. #include <linux/module.h>
  12. #include <linux/unistd.h>
  13. #include <linux/smp_lock.h>
  14. #include <linux/init.h>
  15. #include <linux/sched.h>
  17. #include <asm/uaccess.h>
  19. /*
  20.  * SLAB caches for signal bits.
  21.  */
  23. static kmem_cache_t *sigqueue_cachep;
  25. atomic_t nr_queued_signals;
  26. int max_queued_signals = 1024;
  28. void __init signals_init(void)
  29. {
  30. sigqueue_cachep =
  31. kmem_cache_create("sigqueue",
  32.   sizeof(struct sigqueue),
  33.   __alignof__(struct sigqueue),
  34.   0, NULL, NULL);
  35. if (!sigqueue_cachep)
  36. panic("signals_init(): cannot create sigqueue SLAB cache");
  37. }
  40. /* Given the mask, find the first available signal that should be serviced. */
  42. static int
  43. next_signal(struct task_struct *tsk, sigset_t *mask)
  44. {
  45. unsigned long i, *s, *m, x;
  46. int sig = 0;
  48. s = tsk->pending.signal.sig;
  49. m = mask->sig;
  50. switch (_NSIG_WORDS) {
  51. default:
  52. for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
  53. if ((x = *s &~ *m) != 0) {
  54. sig = ffz(~x) + i*_NSIG_BPW + 1;
  55. break;
  56. }
  57. break;
  59. case 2: if ((x = s[0] &~ m[0]) != 0)
  60. sig = 1;
  61. else if ((x = s[1] &~ m[1]) != 0)
  62. sig = _NSIG_BPW + 1;
  63. else
  64. break;
  65. sig += ffz(~x);
  66. break;
  68. case 1: if ((x = *s &~ *m) != 0)
  69. sig = ffz(~x) + 1;
  70. break;
  71. }
  73. return sig;
  74. }
  76. static void flush_sigqueue(struct sigpending *queue)
  77. {
  78. struct sigqueue *q, *n;
  80. sigemptyset(&queue->signal);
  81. q = queue->head;
  82. queue->head = NULL;
  83. queue->tail = &queue->head;
  85. while (q) {
  86. n = q->next;
  87. kmem_cache_free(sigqueue_cachep, q);
  88. atomic_dec(&nr_queued_signals);
  89. q = n;
  90. }
  91. }
  93. /*
  94.  * Flush all pending signals for a task.
  95.  */
  97. void
  98. flush_signals(struct task_struct *t)
  99. {
  100. t->sigpending = 0;
  101. flush_sigqueue(&t->pending);
  102. }
  104. void exit_sighand(struct task_struct *tsk)
  105. {
  106. struct signal_struct * sig = tsk->sig;
  108. spin_lock_irq(&tsk->sigmask_lock);
  109. if (sig) {
  110. tsk->sig = NULL;
  111. if (atomic_dec_and_test(&sig->count))
  112. kmem_cache_free(sigact_cachep, sig);
  113. }
  114. tsk->sigpending = 0;
  115. flush_sigqueue(&tsk->pending);
  116. spin_unlock_irq(&tsk->sigmask_lock);
  117. }
  119. /*
  120.  * Flush all handlers for a task.
  121.  */
  123. void
  124. flush_signal_handlers(struct task_struct *t)
  125. {
  126. int i;
  127. struct k_sigaction *ka = &t->sig->action[0];
  128. for (i = _NSIG ; i != 0 ; i--) {
  129. if (ka->sa.sa_handler != SIG_IGN)
  130. ka->sa.sa_handler = SIG_DFL;
  131. ka->sa.sa_flags = 0;
  132. sigemptyset(&ka->sa.sa_mask);
  133. ka++;
  134. }
  135. }
  137. /*
  138.  * sig_exit - cause the current task to exit due to a signal.
  139.  */
  141. void
  142. sig_exit(int sig, int exit_code, struct siginfo *info)
  143. {
  144. struct task_struct *t;
  146. sigaddset(&current->pending.signal, sig);
  147. recalc_sigpending(current);
  148. current->flags |= PF_SIGNALED;
  150. /* Propagate the signal to all the tasks in
  151.  *  our thread group
  152.  */
  153. if (info && (unsigned long)info != 1
  154.     && info->si_code != SI_TKILL) {
  155. read_lock(&tasklist_lock);
  156. for_each_thread(t) {
  157. force_sig_info(sig, info, t);
  158. }
  159. read_unlock(&tasklist_lock);
  160. }
  162. do_exit(exit_code);
  163. /* NOTREACHED */
  164. }
  166. /* Notify the system that a driver wants to block all signals for this
  167.  * process, and wants to be notified if any signals at all were to be
  168.  * sent/acted upon.  If the notifier routine returns non-zero, then the
  169.  * signal will be acted upon after all.  If the notifier routine returns 0,
  170.  * then then signal will be blocked.  Only one block per process is
  171.  * allowed.  priv is a pointer to private data that the notifier routine
  172.  * can use to determine if the signal should be blocked or not.  */
  174. void
  175. block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
  176. {
  177. unsigned long flags;
  179. spin_lock_irqsave(&current->sigmask_lock, flags);
  180. current->notifier_mask = mask;
  181. current->notifier_data = priv;
  182. current->notifier = notifier;
  183. spin_unlock_irqrestore(&current->sigmask_lock, flags);
  184. }
  186. /* Notify the system that blocking has ended. */
  188. void
  189. unblock_all_signals(void)
  190. {
  191. unsigned long flags;
  193. spin_lock_irqsave(&current->sigmask_lock, flags);
  194. current->notifier = NULL;
  195. current->notifier_data = NULL;
  196. recalc_sigpending(current);
  197. spin_unlock_irqrestore(&current->sigmask_lock, flags);
  198. }
  200. static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
  201. {
  202. if (sigismember(&list->signal, sig)) {
  203. /* Collect the siginfo appropriate to this signal.  */
  204. struct sigqueue *q, **pp;
  205. pp = &list->head;
  206. while ((q = *pp) != NULL) {
  207. if (q->info.si_signo == sig)
  208. goto found_it;
  209. pp = &q->next;
  210. }
  212. /* Ok, it wasn't in the queue.  We must have
  213.    been out of queue space.  So zero out the
  214.    info.  */
  215. sigdelset(&list->signal, sig);
  216. info->si_signo = sig;
  217. info->si_errno = 0;
  218. info->si_code = 0;
  219. info->si_pid = 0;
  220. info->si_uid = 0;
  221. return 1;
  223. found_it:
  224. if ((*pp = q->next) == NULL)
  225. list->tail = pp;
  227. /* Copy the sigqueue information and free the queue entry */
  228. copy_siginfo(info, &q->info);
  229. kmem_cache_free(sigqueue_cachep,q);
  230. atomic_dec(&nr_queued_signals);
  232. /* Non-RT signals can exist multiple times.. */
  233. if (sig >= SIGRTMIN) {
  234. while ((q = *pp) != NULL) {
  235. if (q->info.si_signo == sig)
  236. goto found_another;
  237. pp = &q->next;
  238. }
  239. }
  241. sigdelset(&list->signal, sig);
  242. found_another:
  243. return 1;
  244. }
  245. return 0;
  246. }
  248. /*
  249.  * Dequeue a signal and return the element to the caller, which is 
  250.  * expected to free it.
  251.  *
  252.  * All callers must be holding current->sigmask_lock.
  253.  */
  255. int
  256. dequeue_signal(sigset_t *mask, siginfo_t *info)
  257. {
  258. int sig = 0;
  260. sig = next_signal(current, mask);
  261. if (sig) {
  262. if (current->notifier) {
  263. if (sigismember(current->notifier_mask, sig)) {
  264. if (!(current->notifier)(current->notifier_data)) {
  265. current->sigpending = 0;
  266. return 0;
  267. }
  268. }
  269. }
  271. if (!collect_signal(sig, &current->pending, info))
  272. sig = 0;
  274. /* XXX: Once POSIX.1b timers are in, if si_code == SI_TIMER,
  275.    we need to xchg out the timer overrun values.  */
  276. }
  277. recalc_sigpending(current);
  279. return sig;
  280. }
  282. static int rm_from_queue(int sig, struct sigpending *s)
  283. {
  284. struct sigqueue *q, **pp;
  286. if (!sigismember(&s->signal, sig))
  287. return 0;
  289. sigdelset(&s->signal, sig);
  291. pp = &s->head;
  293. while ((q = *pp) != NULL) {
  294. if (q->info.si_signo == sig) {
  295. if ((*pp = q->next) == NULL)
  296. s->tail = pp;
  297. kmem_cache_free(sigqueue_cachep,q);
  298. atomic_dec(&nr_queued_signals);
  299. continue;
  300. }
  301. pp = &q->next;
  302. }
  303. return 1;
  304. }
  306. /*
  307.  * Remove signal sig from t->pending.
  308.  * Returns 1 if sig was found.
  309.  *
  310.  * All callers must be holding t->sigmask_lock.
  311.  */
  312. static int rm_sig_from_queue(int sig, struct task_struct *t)
  313. {
  314. return rm_from_queue(sig, &t->pending);
  315. }
  317. /*
  318.  * Bad permissions for sending the signal
  319.  */
  320. int bad_signal(int sig, struct siginfo *info, struct task_struct *t)
  321. {
  322. return (!info || ((unsigned long)info != 1 && SI_FROMUSER(info)))
  323.     && ((sig != SIGCONT) || (current->session != t->session))
  324.     && (current->euid ^ t->suid) && (current->euid ^ t->uid)
  325.     && (current->uid ^ t->suid) && (current->uid ^ t->uid)
  326.     && !capable(CAP_KILL);
  327. }
  329. /*
  330.  * Signal type:
  331.  *    < 0 : global action (kill - spread to all non-blocked threads)
  332.  *    = 0 : ignored
  333.  *    > 0 : wake up.
  334.  */
  335. static int signal_type(int sig, struct signal_struct *signals)
  336. {
  337. unsigned long handler;
  339. if (!signals)
  340. return 0;
  342. handler = (unsigned long) signals->action[sig-1].sa.sa_handler;
  343. if (handler > 1)
  344. return 1;
  346. /* "Ignore" handler.. Illogical, but that has an implicit handler for SIGCHLD */
  347. if (handler == 1)
  348. return sig == SIGCHLD;
  350. /* Default handler. Normally lethal, but.. */
  351. switch (sig) {
  353. /* Ignored */
  354. case SIGCONT: case SIGWINCH:
  355. case SIGCHLD: case SIGURG:
  356. return 0;
  358. /* Implicit behaviour */
  359. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  360. return 1;
  362. /* Implicit actions (kill or do special stuff) */
  363. default:
  364. return -1;
  365. }
  366. }
  369. /*
  370.  * Determine whether a signal should be posted or not.
  371.  *
  372.  * Signals with SIG_IGN can be ignored, except for the
  373.  * special case of a SIGCHLD. 
  374.  *
  375.  * Some signals with SIG_DFL default to a non-action.
  376.  */
  377. static int ignored_signal(int sig, struct task_struct *t)
  378. {
  379. /* Don't ignore traced or blocked signals */
  380. if ((t->ptrace & PT_PTRACED) || sigismember(&t->blocked, sig))
  381. return 0;
  383. return signal_type(sig, t->sig) == 0;
  384. }
  386. /*
  387.  * Handle TASK_STOPPED cases etc implicit behaviour
  388.  * of certain magical signals.
  389.  *
  390.  * SIGKILL gets spread out to every thread. 
  391.  */
  392. static void handle_stop_signal(int sig, struct task_struct *t)
  393. {
  394. switch (sig) {
  395. case SIGKILL: case SIGCONT:
  396. /* Wake up the process if stopped.  */
  397. if (t->state == TASK_STOPPED)
  398. wake_up_process(t);
  399. t->exit_code = 0;
  400. rm_sig_from_queue(SIGSTOP, t);
  401. rm_sig_from_queue(SIGTSTP, t);
  402. rm_sig_from_queue(SIGTTOU, t);
  403. rm_sig_from_queue(SIGTTIN, t);
  404. break;
  406. case SIGSTOP: case SIGTSTP:
  407. case SIGTTIN: case SIGTTOU:
  408. /* If we're stopping again, cancel SIGCONT */
  409. rm_sig_from_queue(SIGCONT, t);
  410. break;
  411. }
  412. }
  414. static int send_signal(int sig, struct siginfo *info, struct sigpending *signals)
  415. {
  416. struct sigqueue * q = NULL;
  418. /* Real-time signals must be queued if sent by sigqueue, or
  419.    some other real-time mechanism.  It is implementation
  420.    defined whether kill() does so.  We attempt to do so, on
  421.    the principle of least surprise, but since kill is not
  422.    allowed to fail with EAGAIN when low on memory we just
  423.    make sure at least one signal gets delivered and don't
  424.    pass on the info struct.  */
  426. if (atomic_read(&nr_queued_signals) < max_queued_signals) {
  427. q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);
  428. }
  430. if (q) {
  431. atomic_inc(&nr_queued_signals);
  432. q->next = NULL;
  433. *signals->tail = q;
  434. signals->tail = &q->next;
  435. switch ((unsigned long) info) {
  436. case 0:
  437. q->info.si_signo = sig;
  438. q->info.si_errno = 0;
  439. q->info.si_code = SI_USER;
  440. q->info.si_pid = current->pid;
  441. q->info.si_uid = current->uid;
  442. break;
  443. case 1:
  444. q->info.si_signo = sig;
  445. q->info.si_errno = 0;
  446. q->info.si_code = SI_KERNEL;
  447. q->info.si_pid = 0;
  448. q->info.si_uid = 0;
  449. break;
  450. default:
  451. copy_siginfo(&q->info, info);
  452. break;
  453. }
  454. } else if (sig >= SIGRTMIN && info && (unsigned long)info != 1
  455.    && info->si_code != SI_USER) {
  456. /*
  457.  * Queue overflow, abort.  We may abort if the signal was rt
  458.  * and sent by user using something other than kill().
  459.  */
  460. return -EAGAIN;
  461. }
  463. sigaddset(&signals->signal, sig);
  464. return 0;
  465. }
  467. /*
  468.  * Tell a process that it has a new active signal..
  469.  *
  470.  * NOTE! we rely on the previous spin_lock to
  471.  * lock interrupts for us! We can only be called with
  472.  * "sigmask_lock" held, and the local interrupt must
  473.  * have been disabled when that got acquired!
  474.  *
  475.  * No need to set need_resched since signal event passing
  476.  * goes through ->blocked
  477.  */
  478. static inline void signal_wake_up(struct task_struct *t)
  479. {
  480. t->sigpending = 1;
  482. #ifdef CONFIG_SMP
  483. /*
  484.  * If the task is running on a different CPU 
  485.  * force a reschedule on the other CPU to make
  486.  * it notice the new signal quickly.
  487.  *
  488.  * The code below is a tad loose and might occasionally
  489.  * kick the wrong CPU if we catch the process in the
  490.  * process of changing - but no harm is done by that
  491.  * other than doing an extra (lightweight) IPI interrupt.
  492.  */
  493. spin_lock(&runqueue_lock);
  494. if (task_has_cpu(t) && t->processor != smp_processor_id())
  495. smp_send_reschedule(t->processor);
  496. spin_unlock(&runqueue_lock);
  497. #endif /* CONFIG_SMP */
  499. if (t->state & TASK_INTERRUPTIBLE) {
  500. wake_up_process(t);
  501. return;
  502. }
  503. }
  505. static int deliver_signal(int sig, struct siginfo *info, struct task_struct *t)
  506. {
  507. int retval = send_signal(sig, info, &t->pending);
  509. if (!retval && !sigismember(&t->blocked, sig))
  510. signal_wake_up(t);
  512. return retval;
  513. }
  515. int
  516. send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
  517. {
  518. unsigned long flags;
  519. int ret;
  521. ret = -EINVAL;
  522. if (sig < 0 || sig > _NSIG)
  523. goto out_nolock;
  524. /* The somewhat baroque permissions check... */
  525. ret = -EPERM;
  526. if (bad_signal(sig, info, t))
  527. goto out_nolock;
  529. /* The null signal is a permissions and process existence probe.
  530.    No signal is actually delivered.  Same goes for zombies. */
  531. ret = 0;
  532. if (!sig || !t->sig)
  533. goto out_nolock;
  535. spin_lock_irqsave(&t->sigmask_lock, flags);
  536. handle_stop_signal(sig, t);
  538. /* Optimize away the signal, if it's a signal that can be
  539.    handled immediately (ie non-blocked and untraced) and
  540.    that is ignored (either explicitly or by default).  */
  542. if (ignored_signal(sig, t))
  543. goto out;
  545. /* Support queueing exactly one non-rt signal, so that we
  546.    can get more detailed information about the cause of
  547.    the signal. */
  548. if (sig < SIGRTMIN && sigismember(&t->pending.signal, sig))
  549. goto out;
  551. ret = deliver_signal(sig, info, t);
  552. out:
  553. spin_unlock_irqrestore(&t->sigmask_lock, flags);
  554. out_nolock:
  556. return ret;
  557. }
  559. /*
  560.  * Force a signal that the process can't ignore: if necessary
  561.  * we unblock the signal and change any SIG_IGN to SIG_DFL.
  562.  */
  564. int
  565. force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
  566. {
  567. unsigned long int flags;
  569. spin_lock_irqsave(&t->sigmask_lock, flags);
  570. if (t->sig == NULL) {
  571. spin_unlock_irqrestore(&t->sigmask_lock, flags);
  572. return -ESRCH;
  573. }
  575. if (t->sig->action[sig-1].sa.sa_handler == SIG_IGN)
  576. t->sig->action[sig-1].sa.sa_handler = SIG_DFL;
  577. sigdelset(&t->blocked, sig);
  578. recalc_sigpending(t);
  579. spin_unlock_irqrestore(&t->sigmask_lock, flags);
  581. return send_sig_info(sig, info, t);
  582. }
  584. /*
  585.  * kill_pg_info() sends a signal to a process group: this is what the tty
  586.  * control characters do (^C, ^Z etc)
  587.  */
  589. int
  590. kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
  591. {
  592. int retval = -EINVAL;
  593. if (pgrp > 0) {
  594. struct task_struct *p;
  596. retval = -ESRCH;
  597. read_lock(&tasklist_lock);
  598. for_each_task(p) {
  599. if (p->pgrp == pgrp && thread_group_leader(p)) {
  600. int err = send_sig_info(sig, info, p);
  601. if (retval)
  602. retval = err;
  603. }
  604. }
  605. read_unlock(&tasklist_lock);
  606. }
  607. return retval;
  608. }
  610. /*
  611.  * kill_sl_info() sends a signal to the session leader: this is used
  612.  * to send SIGHUP to the controlling process of a terminal when
  613.  * the connection is lost.
  614.  */
  616. int
  617. kill_sl_info(int sig, struct siginfo *info, pid_t sess)
  618. {
  619. int retval = -EINVAL;
  620. if (sess > 0) {
  621. struct task_struct *p;
  623. retval = -ESRCH;
  624. read_lock(&tasklist_lock);
  625. for_each_task(p) {
  626. if (p->leader && p->session == sess) {
  627. int err = send_sig_info(sig, info, p);
  628. if (retval)
  629. retval = err;
  630. }
  631. }
  632. read_unlock(&tasklist_lock);
  633. }
  634. return retval;
  635. }
  637. inline int
  638. kill_proc_info(int sig, struct siginfo *info, pid_t pid)
  639. {
  640. int error;
  641. struct task_struct *p;
  643. read_lock(&tasklist_lock);
  644. p = find_task_by_pid(pid);
  645. error = -ESRCH;
  646. if (p) {
  647. if (!thread_group_leader(p)) {
  648.                        struct task_struct *tg;
  649.                        tg = find_task_by_pid(p->tgid);
  650.                        if (tg)
  651.                                p = tg;
  652.                 }
  653. error = send_sig_info(sig, info, p);
  654. }
  655. read_unlock(&tasklist_lock);
  656. return error;
  657. }
  660. /*
  661.  * kill_something_info() interprets pid in interesting ways just like kill(2).
  662.  *
  663.  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
  664.  * is probably wrong.  Should make it like BSD or SYSV.
  665.  */
  667. static int kill_something_info(int sig, struct siginfo *info, int pid)
  668. {
  669. if (!pid) {
  670. return kill_pg_info(sig, info, current->pgrp);
  671. } else if (pid == -1) {
  672. int retval = 0, count = 0;
  673. struct task_struct * p;
  675. read_lock(&tasklist_lock);
  676. for_each_task(p) {
  677. if (p->pid > 1 && p != current && thread_group_leader(p)) {
  678. int err = send_sig_info(sig, info, p);
  679. ++count;
  680. if (err != -EPERM)
  681. retval = err;
  682. }
  683. }
  684. read_unlock(&tasklist_lock);
  685. return count ? retval : -ESRCH;
  686. } else if (pid < 0) {
  687. return kill_pg_info(sig, info, -pid);
  688. } else {
  689. return kill_proc_info(sig, info, pid);
  690. }
  691. }
  693. /*
  694.  * These are for backward compatibility with the rest of the kernel source.
  695.  */
  697. int
  698. send_sig(int sig, struct task_struct *p, int priv)
  699. {
  700. return send_sig_info(sig, (void*)(long)(priv != 0), p);
  701. }
  703. void
  704. force_sig(int sig, struct task_struct *p)
  705. {
  706. force_sig_info(sig, (void*)1L, p);
  707. }
  709. int
  710. kill_pg(pid_t pgrp, int sig, int priv)
  711. {
  712. return kill_pg_info(sig, (void *)(long)(priv != 0), pgrp);
  713. }
  715. int
  716. kill_sl(pid_t sess, int sig, int priv)
  717. {
  718. return kill_sl_info(sig, (void *)(long)(priv != 0), sess);
  719. }
  721. int
  722. kill_proc(pid_t pid, int sig, int priv)
  723. {
  724. return kill_proc_info(sig, (void *)(long)(priv != 0), pid);
  725. }
  727. /*
  728.  * Joy. Or not. Pthread wants us to wake up every thread
  729.  * in our parent group.
  730.  */
  731. static void wake_up_parent(struct task_struct *parent)
  732. {
  733. struct task_struct *tsk = parent;
  735. do {
  736. wake_up_interruptible(&tsk->wait_chldexit);
  737. tsk = next_thread(tsk);
  738. } while (tsk != parent);
  739. }
  741. /*
  742.  * Let a parent know about a status change of a child.
  743.  */
  745. void do_notify_parent(struct task_struct *tsk, int sig)
  746. {
  747. struct siginfo info;
  748. int why, status;
  750. info.si_signo = sig;
  751. info.si_errno = 0;
  752. info.si_pid = tsk->pid;
  753. info.si_uid = tsk->uid;
  755. /* FIXME: find out whether or not this is supposed to be c*time. */
  756. info.si_utime = tsk->times.tms_utime;
  757. info.si_stime = tsk->times.tms_stime;
  759. status = tsk->exit_code & 0x7f;
  760. why = SI_KERNEL; /* shouldn't happen */
  761. switch (tsk->state) {
  762. case TASK_STOPPED:
  763. /* FIXME -- can we deduce CLD_TRAPPED or CLD_CONTINUED? */
  764. if (tsk->ptrace & PT_PTRACED)
  765. why = CLD_TRAPPED;
  766. else
  767. why = CLD_STOPPED;
  768. break;
  770. default:
  771. if (tsk->exit_code & 0x80)
  772. why = CLD_DUMPED;
  773. else if (tsk->exit_code & 0x7f)
  774. why = CLD_KILLED;
  775. else {
  776. why = CLD_EXITED;
  777. status = tsk->exit_code >> 8;
  778. }
  779. break;
  780. }
  781. info.si_code = why;
  782. info.si_status = status;
  784. send_sig_info(sig, &info, tsk->p_pptr);
  785. wake_up_parent(tsk->p_pptr);
  786. }
  789. /*
  790.  * We need the tasklist lock because it's the only
  791.  * thing that protects out "parent" pointer.
  792.  *
  793.  * exit.c calls "do_notify_parent()" directly, because
  794.  * it already has the tasklist lock.
  795.  */
  796. void
  797. notify_parent(struct task_struct *tsk, int sig)
  798. {
  799. read_lock(&tasklist_lock);
  800. do_notify_parent(tsk, sig);
  801. read_unlock(&tasklist_lock);
  802. }
  804. EXPORT_SYMBOL(dequeue_signal);
  805. EXPORT_SYMBOL(flush_signals);
  806. EXPORT_SYMBOL(force_sig);
  807. EXPORT_SYMBOL(force_sig_info);
  808. EXPORT_SYMBOL(kill_pg);
  809. EXPORT_SYMBOL(kill_pg_info);
  810. EXPORT_SYMBOL(kill_proc);
  811. EXPORT_SYMBOL(kill_proc_info);
  812. EXPORT_SYMBOL(kill_sl);
  813. EXPORT_SYMBOL(kill_sl_info);
  814. EXPORT_SYMBOL(notify_parent);
  815. EXPORT_SYMBOL(recalc_sigpending);
  816. EXPORT_SYMBOL(send_sig);
  817. EXPORT_SYMBOL(send_sig_info);
  818. EXPORT_SYMBOL(block_all_signals);
  819. EXPORT_SYMBOL(unblock_all_signals);
  822. /*
  823.  * System call entry points.
  824.  */
  826. /*
  827.  * We don't need to get the kernel lock - this is all local to this
  828.  * particular thread.. (and that's good, because this is _heavily_
  829.  * used by various programs)
  830.  */
  832. asmlinkage long
  833. sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset, size_t sigsetsize)
  834. {
  835. int error = -EINVAL;
  836. sigset_t old_set, new_set;
  838. /* XXX: Don't preclude handling different sized sigset_t's.  */
  839. if (sigsetsize != sizeof(sigset_t))
  840. goto out;
  842. if (set) {
  843. error = -EFAULT;
  844. if (copy_from_user(&new_set, set, sizeof(*set)))
  845. goto out;
  846. sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
  848. spin_lock_irq(&current->sigmask_lock);
  849. old_set = current->blocked;
  851. error = 0;
  852. switch (how) {
  853. default:
  854. error = -EINVAL;
  855. break;
  856. case SIG_BLOCK:
  857. sigorsets(&new_set, &old_set, &new_set);
  858. break;
  859. case SIG_UNBLOCK:
  860. signandsets(&new_set, &old_set, &new_set);
  861. break;
  862. case SIG_SETMASK:
  863. break;
  864. }
  866. current->blocked = new_set;
  867. recalc_sigpending(current);
  868. spin_unlock_irq(&current->sigmask_lock);
  869. if (error)
  870. goto out;
  871. if (oset)
  872. goto set_old;
  873. } else if (oset) {
  874. spin_lock_irq(&current->sigmask_lock);
  875. old_set = current->blocked;
  876. spin_unlock_irq(&current->sigmask_lock);
  878. set_old:
  879. error = -EFAULT;
  880. if (copy_to_user(oset, &old_set, sizeof(*oset)))
  881. goto out;
  882. }
  883. error = 0;
  884. out:
  885. return error;
  886. }
  888. long do_sigpending(void *set, unsigned long sigsetsize)
  889. {
  890. long error = -EINVAL;
  891. sigset_t pending;
  893. if (sigsetsize > sizeof(sigset_t))
  894. goto out;
  896. spin_lock_irq(&current->sigmask_lock);
  897. sigandsets(&pending, &current->blocked, &current->pending.signal);
  898. spin_unlock_irq(&current->sigmask_lock);
  900. error = -EFAULT;
  901. if (!copy_to_user(set, &pending, sigsetsize))
  902. error = 0;
  903. out:
  904. return error;
  905. }
  907. asmlinkage long
  908. sys_rt_sigpending(sigset_t *set, size_t sigsetsize)
  909. {
  910. return do_sigpending(set, sigsetsize);
  911. }
  913. asmlinkage long
  914. sys_rt_sigtimedwait(const sigset_t *uthese, siginfo_t *uinfo,
  915.     const struct timespec *uts, size_t sigsetsize)
  916. {
  917. int ret, sig;
  918. sigset_t these;
  919. struct timespec ts;
  920. siginfo_t info;
  921. long timeout = 0;
  923. /* XXX: Don't preclude handling different sized sigset_t's.  */
  924. if (sigsetsize != sizeof(sigset_t))
  925. return -EINVAL;
  927. if (copy_from_user(&these, uthese, sizeof(these)))
  928. return -EFAULT;
  930. /*
  931.  * Invert the set of allowed signals to get those we
  932.  * want to block.
  933.  */
  934. sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
  935. signotset(&these);
  937. if (uts) {
  938. if (copy_from_user(&ts, uts, sizeof(ts)))
  939. return -EFAULT;
  940. if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
  941.     || ts.tv_sec < 0)
  942. return -EINVAL;
  943. }
  945. spin_lock_irq(&current->sigmask_lock);
  946. sig = dequeue_signal(&these, &info);
  947. if (!sig) {
  948. timeout = MAX_SCHEDULE_TIMEOUT;
  949. if (uts)
  950. timeout = (timespec_to_jiffies(&ts)
  951.    + (ts.tv_sec || ts.tv_nsec));
  953. if (timeout) {
  954. /* None ready -- temporarily unblock those we're
  955.  * interested while we are sleeping in so that we'll
  956.  * be awakened when they arrive.  */
  957. sigset_t oldblocked = current->blocked;
  958. sigandsets(&current->blocked, &current->blocked, &these);
  959. recalc_sigpending(current);
  960. spin_unlock_irq(&current->sigmask_lock);
  962. current->state = TASK_INTERRUPTIBLE;
  963. timeout = schedule_timeout(timeout);
  965. spin_lock_irq(&current->sigmask_lock);
  966. sig = dequeue_signal(&these, &info);
  967. current->blocked = oldblocked;
  968. recalc_sigpending(current);
  969. }
  970. }
  971. spin_unlock_irq(&current->sigmask_lock);
  973. if (sig) {
  974. ret = sig;
  975. if (uinfo) {
  976. if (copy_siginfo_to_user(uinfo, &info))
  977. ret = -EFAULT;
  978. }
  979. } else {
  980. ret = -EAGAIN;
  981. if (timeout)
  982. ret = -EINTR;
  983. }
  985. return ret;
  986. }
  988. asmlinkage long
  989. sys_kill(int pid, int sig)
  990. {
  991. struct siginfo info;
  993. info.si_signo = sig;
  994. info.si_errno = 0;
  995. info.si_code = SI_USER;
  996. info.si_pid = current->pid;
  997. info.si_uid = current->uid;
  999. return kill_something_info(sig, &info, pid);
  1000. }
  1002. /*
  1003.  *  Kill only one task, even if it's a CLONE_THREAD task.
  1004.  */
  1005. asmlinkage long
  1006. sys_tkill(int pid, int sig)
  1007. {
  1008.        struct siginfo info;
  1009.        int error;
  1010.        struct task_struct *p;
  1012.        /* This is only valid for single tasks */
  1013.        if (pid <= 0)
  1014.            return -EINVAL;
  1016.        info.si_signo = sig;
  1017.        info.si_errno = 0;
  1018.        info.si_code = SI_TKILL;
  1019.        info.si_pid = current->pid;
  1020.        info.si_uid = current->uid;
  1022.        read_lock(&tasklist_lock);
  1023.        p = find_task_by_pid(pid);
  1024.        error = -ESRCH;
  1025.        if (p) {
  1026.                error = send_sig_info(sig, &info, p);
  1027.        }
  1028.        read_unlock(&tasklist_lock);
  1029.        return error;
  1030. }
  1032. asmlinkage long
  1033. sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo)
  1034. {
  1035. siginfo_t info;
  1037. if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
  1038. return -EFAULT;
  1040. /* Not even root can pretend to send signals from the kernel.
  1041.    Nor can they impersonate a kill(), which adds source info.  */
  1042. if (info.si_code >= 0)
  1043. return -EPERM;
  1044. info.si_signo = sig;
  1046. /* POSIX.1b doesn't mention process groups.  */
  1047. return kill_proc_info(sig, &info, pid);
  1048. }
  1050. int
  1051. do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
  1052. {
  1053. struct k_sigaction *k;
  1055. if (sig < 1 || sig > _NSIG ||
  1056.     (act && (sig == SIGKILL || sig == SIGSTOP)))
  1057. return -EINVAL;
  1059. k = &current->sig->action[sig-1];
  1061. spin_lock(&current->sig->siglock);
  1063. if (oact)
  1064. *oact = *k;
  1066. if (act) {
  1067. *k = *act;
  1068. sigdelsetmask(&k->sa.sa_mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
  1070. /*
  1071.  * POSIX 3.3.1.3:
  1072.  *  "Setting a signal action to SIG_IGN for a signal that is
  1073.  *   pending shall cause the pending signal to be discarded,
  1074.  *   whether or not it is blocked."
  1075.  *
  1076.  *  "Setting a signal action to SIG_DFL for a signal that is
  1077.  *   pending and whose default action is to ignore the signal
  1078.  *   (for example, SIGCHLD), shall cause the pending signal to
  1079.  *   be discarded, whether or not it is blocked"
  1080.  *
  1081.  * Note the silly behaviour of SIGCHLD: SIG_IGN means that the
  1082.  * signal isn't actually ignored, but does automatic child
  1083.  * reaping, while SIG_DFL is explicitly said by POSIX to force
  1084.  * the signal to be ignored.
  1085.  */
  1087. if (k->sa.sa_handler == SIG_IGN
  1088.     || (k->sa.sa_handler == SIG_DFL
  1089. && (sig == SIGCONT ||
  1090.     sig == SIGCHLD ||
  1091.     sig == SIGURG ||
  1092.     sig == SIGWINCH))) {
  1093. spin_lock_irq(&current->sigmask_lock);
  1094. if (rm_sig_from_queue(sig, current))
  1095. recalc_sigpending(current);
  1096. spin_unlock_irq(&current->sigmask_lock);
  1097. }
  1098. }
  1100. spin_unlock(&current->sig->siglock);
  1101. return 0;
  1102. }
  1104. int 
  1105. do_sigaltstack (const stack_t *uss, stack_t *uoss, unsigned long sp)
  1106. {
  1107. stack_t oss;
  1108. int error;
  1110. if (uoss) {
  1111. oss.ss_sp = (void *) current->sas_ss_sp;
  1112. oss.ss_size = current->sas_ss_size;
  1113. oss.ss_flags = sas_ss_flags(sp);
  1114. }
  1116. if (uss) {
  1117. void *ss_sp;
  1118. size_t ss_size;
  1119. int ss_flags;
  1121. error = -EFAULT;
  1122. if (verify_area(VERIFY_READ, uss, sizeof(*uss))
  1123.     || __get_user(ss_sp, &uss->ss_sp)
  1124.     || __get_user(ss_flags, &uss->ss_flags)
  1125.     || __get_user(ss_size, &uss->ss_size))
  1126. goto out;
  1128. error = -EPERM;
  1129. if (on_sig_stack (sp))
  1130. goto out;
  1132. error = -EINVAL;
  1133. /*
  1134.  *
  1135.  * Note - this code used to test ss_flags incorrectly
  1136.  *     old code may have been written using ss_flags==0
  1137.  *   to mean ss_flags==SS_ONSTACK (as this was the only
  1138.  *   way that worked) - this fix preserves that older
  1139.  *   mechanism
  1140.  */
  1141. if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
  1142. goto out;
  1144. if (ss_flags == SS_DISABLE) {
  1145. ss_size = 0;
  1146. ss_sp = NULL;
  1147. } else {
  1148. error = -ENOMEM;
  1149. if (ss_size < MINSIGSTKSZ)
  1150. goto out;
  1151. }
  1153. current->sas_ss_sp = (unsigned long) ss_sp;
  1154. current->sas_ss_size = ss_size;
  1155. }
  1157. if (uoss) {
  1158. error = -EFAULT;
  1159. if (copy_to_user(uoss, &oss, sizeof(oss)))
  1160. goto out;
  1161. }
  1163. error = 0;
  1164. out:
  1165. return error;
  1166. }
  1168. asmlinkage long
  1169. sys_sigpending(old_sigset_t *set)
  1170. {
  1171. return do_sigpending(set, sizeof(*set));
  1172. }
  1174. #if !defined(__alpha__)
  1175. /* Alpha has its own versions with special arguments.  */
  1177. asmlinkage long
  1178. sys_sigprocmask(int how, old_sigset_t *set, old_sigset_t *oset)
  1179. {
  1180. int error;
  1181. old_sigset_t old_set, new_set;
  1183. if (set) {
  1184. error = -EFAULT;
  1185. if (copy_from_user(&new_set, set, sizeof(*set)))
  1186. goto out;
  1187. new_set &= ~(sigmask(SIGKILL)|sigmask(SIGSTOP));
  1189. spin_lock_irq(&current->sigmask_lock);
  1190. old_set = current->blocked.sig[0];
  1192. error = 0;
  1193. switch (how) {
  1194. default:
  1195. error = -EINVAL;
  1196. break;
  1197. case SIG_BLOCK:
  1198. sigaddsetmask(&current->blocked, new_set);
  1199. break;
  1200. case SIG_UNBLOCK:
  1201. sigdelsetmask(&current->blocked, new_set);
  1202. break;
  1203. case SIG_SETMASK:
  1204. current->blocked.sig[0] = new_set;
  1205. break;
  1206. }
  1208. recalc_sigpending(current);
  1209. spin_unlock_irq(&current->sigmask_lock);
  1210. if (error)
  1211. goto out;
  1212. if (oset)
  1213. goto set_old;
  1214. } else if (oset) {
  1215. old_set = current->blocked.sig[0];
  1216. set_old:
  1217. error = -EFAULT;
  1218. if (copy_to_user(oset, &old_set, sizeof(*oset)))
  1219. goto out;
  1220. }
  1221. error = 0;
  1222. out:
  1223. return error;
  1224. }
  1226. #ifndef __sparc__
  1227. asmlinkage long
  1228. sys_rt_sigaction(int sig, const struct sigaction *act, struct sigaction *oact,
  1229.  size_t sigsetsize)
  1230. {
  1231. struct k_sigaction new_sa, old_sa;
  1232. int ret = -EINVAL;
  1234. /* XXX: Don't preclude handling different sized sigset_t's.  */
  1235. if (sigsetsize != sizeof(sigset_t))
  1236. goto out;
  1238. if (act) {
  1239. if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
  1240. return -EFAULT;
  1241. }
  1243. ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
  1245. if (!ret && oact) {
  1246. if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
  1247. return -EFAULT;
  1248. }
  1249. out:
  1250. return ret;
  1251. }
  1252. #endif /* __sparc__ */
  1253. #endif
  1255. #if !defined(__alpha__) && !defined(__ia64__)
  1256. /*
  1257.  * For backwards compatibility.  Functionality superseded by sigprocmask.
  1258.  */
  1259. asmlinkage long
  1260. sys_sgetmask(void)
  1261. {
  1262. /* SMP safe */
  1263. return current->blocked.sig[0];
  1264. }
  1266. asmlinkage long
  1267. sys_ssetmask(int newmask)
  1268. {
  1269. int old;
  1271. spin_lock_irq(&current->sigmask_lock);
  1272. old = current->blocked.sig[0];
  1274. siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
  1275.   sigmask(SIGSTOP)));
  1276. recalc_sigpending(current);
  1277. spin_unlock_irq(&current->sigmask_lock);
  1279. return old;
  1280. }
  1281. #endif /* !defined(__alpha__) */
  1283. #if !defined(__alpha__) && !defined(__ia64__) && !defined(__mips__)
  1284. /*
  1285.  * For backwards compatibility.  Functionality superseded by sigaction.
  1286.  */
  1287. asmlinkage unsigned long
  1288. sys_signal(int sig, __sighandler_t handler)
  1289. {
  1290. struct k_sigaction new_sa, old_sa;
  1291. int ret;
  1293. new_sa.sa.sa_handler = handler;
  1294. new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
  1296. ret = do_sigaction(sig, &new_sa, &old_sa);
  1298. return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
  1299. }
  1300. #endif /* !alpha && !__ia64__ && !defined(__mips__) */