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

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

Linux/Unix编程

开发平台：

Unix_Linux

signal.c：源码内容
  1. /*
  2.  *  linux/arch/x86_64/kernel/signal.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  *  Copyright (C) 2000, 2001  SuSE Labs
  6.  *
  7.  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  8.  *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
  9.  *  2000-2001   x86-64 support by Andi Kleen
  10.  * 
  11.  *  $Id: signal.c,v 1.35 2002/07/29 10:34:03 ak Exp $
  12.  */
  14. #include <linux/sched.h>
  15. #include <linux/mm.h>
  16. #include <linux/smp.h>
  17. #include <linux/smp_lock.h>
  18. #include <linux/kernel.h>
  19. #include <linux/signal.h>
  20. #include <linux/errno.h>
  21. #include <linux/wait.h>
  22. #include <linux/ptrace.h>
  23. #include <linux/unistd.h>
  24. #include <linux/stddef.h>
  25. #include <linux/tty.h>
  26. #include <linux/personality.h>
  27. #include <linux/compiler.h>
  28. #include <linux/binfmts.h>
  29. #include <asm/ucontext.h>
  30. #include <asm/uaccess.h>
  31. #include <asm/i387.h>
  33. #define DEBUG_SIG 0
  35. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  37. asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  39. void ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
  40.                sigset_t *set, struct pt_regs * regs); 
  41. void ia32_setup_frame(int sig, struct k_sigaction *ka,
  42.             sigset_t *set, struct pt_regs * regs); 
  43. void signal_fault(struct pt_regs *regs, void *frame, char *where);
  44. extern int exception_trace;
  46. int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  47. {
  48. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  49. return -EFAULT;
  50. if (from->si_code < 0)
  51. return __copy_to_user(to, from, sizeof(siginfo_t));
  52. else {
  53. int err;
  55. /* If you change siginfo_t structure, please be sure
  56.    this code is fixed accordingly.
  57.    It should never copy any pad contained in the structure
  58.    to avoid security leaks, but must copy the generic
  59.    3 ints plus the relevant union member.  */
  60. err = __put_user(from->si_signo, &to->si_signo);
  61. err |= __put_user(from->si_errno, &to->si_errno);
  62. err |= __put_user((short)from->si_code, &to->si_code);
  63. /* First 32bits of unions are always present.  */
  64. err |= __put_user(from->si_pid, &to->si_pid);
  65. switch (from->si_code >> 16) {
  66. case __SI_FAULT >> 16:
  67. break;
  68. case __SI_CHLD >> 16:
  69. err |= __put_user(from->si_utime, &to->si_utime);
  70. err |= __put_user(from->si_stime, &to->si_stime);
  71. err |= __put_user(from->si_status, &to->si_status);
  72. default:
  73. err |= __put_user(from->si_uid, &to->si_uid);
  74. break;
  75. /* case __SI_RT: This is not generated by the kernel as of now.  */
  76. }
  77. return err;
  78. }
  79. }
  81. asmlinkage long
  82. sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs regs)
  83. {
  84. sigset_t saveset, newset;
  86. /* XXX: Don't preclude handling different sized sigset_t's.  */
  87. if (sigsetsize != sizeof(sigset_t))
  88. return -EINVAL;
  90. if (copy_from_user(&newset, unewset, sizeof(newset)))
  91. return -EFAULT;
  92. sigdelsetmask(&newset, ~_BLOCKABLE);
  94. spin_lock_irq(&current->sigmask_lock);
  95. saveset = current->blocked;
  96. current->blocked = newset;
  97. recalc_sigpending(current);
  98. spin_unlock_irq(&current->sigmask_lock);
  99. #if DEBUG_SIG
  100. printk("rt_sigsuspend savset(%lx) newset(%lx) regs(%p) rip(%lx)n",
  101. saveset, newset, &regs, regs.rip);
  102. #endif 
  103. regs.rax = -EINTR;
  104. while (1) {
  105. current->state = TASK_INTERRUPTIBLE;
  106. schedule();
  107. if (do_signal(&regs, &saveset))
  108. return -EINTR;
  109. }
  110. }
  112. asmlinkage long
  113. sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs regs)
  114. {
  115. return do_sigaltstack(uss, uoss, regs.rsp);
  116. }
  119. /*
  120.  * Do a signal return; undo the signal stack.
  121.  */
  123. struct rt_sigframe
  124. {
  125. char *pretcode;
  126. struct ucontext uc;
  127. struct siginfo info;
  128. };
  130. static int
  131. restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc, unsigned long *prax)
  132. {
  133. unsigned int err = 0;
  136. #define COPY(x) err |= __get_user(regs->x, &sc->x)
  137. #define COPY_CANON(x)   
  138. COPY(x); 
  139. if ((regs->x >> 48)  != 0 && (regs->x >> 48) != 0xffff) 
  140. regs->x = 0; 
  142. { 
  143. unsigned int seg; 
  144. err |= __get_user(seg, &sc->gs); 
  145. load_gs_index(seg); 
  146. err |= __get_user(seg, &sc->fs);
  147. loadsegment(fs,seg);
  148. }
  150. COPY(rdi); COPY(rsi); COPY(rbp); COPY_CANON(rsp); COPY(rbx);
  151. COPY(rdx); COPY(rcx); COPY_CANON(rip);
  152. COPY(r8);
  153. COPY(r9);
  154. COPY(r10);
  155. COPY(r11);
  156. COPY(r12);
  157. COPY(r13);
  158. COPY(r14);
  159. COPY(r15);
  161. /* do not copy CS/SS because 64bit should not need it. 
  162.    also need IRET exception handling anyways. */
  164. {
  165. unsigned int tmpflags;
  166. err |= __get_user(tmpflags, &sc->eflags);
  167. regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
  168. regs->orig_rax = -1; /* disable syscall checks */
  169. }
  171. {
  172. struct _fpstate * buf;
  173. err |= __get_user(buf, &sc->fpstate);
  174. if (buf) {
  175. if (unlikely(verify_area(VERIFY_READ, buf, sizeof(*buf))))
  176. return 1;
  177. err |= restore_i387(buf);
  178. }
  179. }
  181. err |= __get_user(*prax, &sc->rax);
  182. return err;
  183. }
  184. #undef COPY
  186. asmlinkage long sys_rt_sigreturn(struct pt_regs regs)
  187. {
  188. struct rt_sigframe *frame = (struct rt_sigframe *)(regs.rsp - 8);
  189. sigset_t set;
  190. stack_t st;
  191. long eax;
  193. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  194. goto badframe;
  195. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  196. goto badframe;
  198. sigdelsetmask(&set, ~_BLOCKABLE);
  199. spin_lock_irq(&current->sigmask_lock);
  200. current->blocked = set;
  201. recalc_sigpending(current);
  202. spin_unlock_irq(&current->sigmask_lock);
  204. if (restore_sigcontext(&regs, &frame->uc.uc_mcontext, &eax))
  205. goto badframe;
  207. #if DEBUG_SIG
  208. printk("%d sigreturn rip:%lx rsp:%lx frame:%p rax:%lxn",current->pid,regs.rip,regs.rsp,frame,eax);
  209. #endif
  211. if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
  212. goto badframe;
  213. /* It is more difficult to avoid calling this function than to
  214.    call it and ignore errors.  */
  215. do_sigaltstack(&st, NULL, regs.rsp);
  217. return eax;
  219. badframe:
  220. signal_fault(&regs, frame, "rt_sigreturn"); 
  221. return 0;
  222. }
  224. /*
  225.  * Set up a signal frame.
  226.  */
  228. static int
  229. setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, unsigned long mask)
  230. {
  231. int tmp, err = 0;
  232. struct task_struct *me = current;
  234. tmp = 0;
  235. __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
  236. err |= __put_user(tmp, (unsigned int *)&sc->gs);
  237. __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
  238. err |= __put_user(tmp, (unsigned int *)&sc->fs);
  240. err |= __put_user(regs->rdi, &sc->rdi);
  241. err |= __put_user(regs->rsi, &sc->rsi);
  242. err |= __put_user(regs->rbp, &sc->rbp);
  243. err |= __put_user(regs->rsp, &sc->rsp);
  244. err |= __put_user(regs->rbx, &sc->rbx);
  245. err |= __put_user(regs->rdx, &sc->rdx);
  246. err |= __put_user(regs->rcx, &sc->rcx);
  247. err |= __put_user(regs->rax, &sc->rax);
  248. err |= __put_user(regs->r8, &sc->r8);
  249. err |= __put_user(regs->r9, &sc->r9);
  250. err |= __put_user(regs->r10, &sc->r10);
  251. err |= __put_user(regs->r11, &sc->r11);
  252. err |= __put_user(regs->r12, &sc->r12);
  253. err |= __put_user(regs->r13, &sc->r13);
  254. err |= __put_user(regs->r14, &sc->r14);
  255. err |= __put_user(regs->r15, &sc->r15);
  256. err |= __put_user(me->thread.trap_no, &sc->trapno);
  257. err |= __put_user(me->thread.error_code, &sc->err);
  258. err |= __put_user(regs->rip, &sc->rip);
  259. err |= __put_user(regs->cs, &sc->cs);
  260. err |= __put_user(regs->eflags, &sc->eflags);
  261. err |= __put_user(mask, &sc->oldmask);
  262. err |= __put_user(me->thread.cr2, &sc->cr2);
  264. return err;
  265. }
  267. /*
  268.  * Determine which stack to use..
  269.  */
  270. #define round_down(p, r) ((void *)  ((unsigned long)((p) - (r) + 1) & ~((r)-1)))
  273. static void * 
  274. get_stack(struct k_sigaction *ka, struct pt_regs *regs, unsigned long size)
  275. {
  276. unsigned long rsp;
  278. /* Default to using normal stack - redzone*/
  279. rsp = regs->rsp - 128;
  281. /* This is the X/Open sanctioned signal stack switching.  */
  282. if (ka->sa.sa_flags & SA_ONSTACK) {
  283. if (! sas_ss_flags(rsp) == 0)
  284. rsp = current->sas_ss_sp + current->sas_ss_size;
  285. }
  287. return round_down(rsp - size, 16); 
  288. }
  290. static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
  291.    sigset_t *set, struct pt_regs * regs)
  292. {
  293. struct rt_sigframe *frame = NULL;
  294. struct _fpstate *fp = NULL; 
  295. int err = 0;
  297. if (current->used_math) {
  298. fp = get_stack(ka, regs, sizeof(struct _fpstate)); 
  299. frame = round_down((char *)fp - sizeof(struct rt_sigframe), 16) - 8;
  301. if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate))) { 
  302. goto give_sigsegv;
  303. }
  304. if (save_i387(fp) < 0) 
  305. err |= -1; 
  306. }
  308. if (!frame)
  309. frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8;
  311. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
  312. goto give_sigsegv;
  313. }
  316. if (ka->sa.sa_flags & SA_SIGINFO) { 
  317. err |= copy_siginfo_to_user(&frame->info, info);
  318. if (err)
  319. goto give_sigsegv;
  320. }
  322. /* Create the ucontext.  */
  323. err |= __put_user(0, &frame->uc.uc_flags);
  324. err |= __put_user(0, &frame->uc.uc_link);
  325. err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
  326. err |= __put_user(sas_ss_flags(regs->rsp),
  327.   &frame->uc.uc_stack.ss_flags);
  328. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  329. err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
  330. err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate);
  331. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  333. /* Set up to return from userspace.  If provided, use a stub
  334.    already in userspace.  */
  335. /* x86-64 should always use SA_RESTORER. */
  336. if (ka->sa.sa_flags & SA_RESTORER) {
  337. err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
  338. } else {
  339. printk("%s forgot to set SA_RESTORER for signal %d.n", current->comm, sig); 
  340. goto give_sigsegv; 
  341. }
  343. if (err)
  344. goto give_sigsegv;
  346. #if DEBUG_SIG
  347. printk("%d old rip %lx old rsp %lx old rax %lxn", current->pid,regs->rip,regs->rsp,regs->rax);
  348. #endif
  350. /* Set up registers for signal handler */
  351. { 
  352. struct exec_domain *ed = current->exec_domain;
  353. if (unlikely(ed && ed->signal_invmap && sig < 32))
  354. sig = ed->signal_invmap[sig];
  355. } 
  356. regs->rdi = sig;
  358. /* could reload DS/ES to __USER_DS here, but assume for now
  359.    that 64bit does not care */
  361. /* In case the signal handler was declared without prototypes */ 
  362. regs->rax = 0;
  364. /* This also works for non SA_SIGINFO handlers because they expect the
  365.    next argument after the signal number on the stack. */
  366. regs->rsi = (unsigned long)&frame->info; 
  367. regs->rdx = (unsigned long)&frame->uc; 
  368. regs->rsp = (unsigned long) frame;
  369. regs->rip = (unsigned long) ka->sa.sa_handler;
  370. regs->cs = __USER_CS;
  371. regs->ss = __USER_DS; 
  373. set_fs(USER_DS);
  374. regs->eflags &= ~TF_MASK;
  376. #if DEBUG_SIG
  377. printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%pn",
  378. current->comm, current->pid, frame, regs->rip, frame->pretcode);
  379. #endif
  381. return;
  383. give_sigsegv:
  384. if (sig == SIGSEGV)
  385. ka->sa.sa_handler = SIG_DFL;
  386. signal_fault(regs, frame, "signal deliver"); 
  387. }
  389. /*
  390.  * OK, we're invoking a handler
  391.  */
  393. static void
  394. handle_signal(unsigned long sig, struct k_sigaction *ka,
  395.       siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  396. {
  397. #if DEBUG_SIG
  398. printk("handle_signal pid:%d sig:%lu rip:%lx rsp:%lx regs=%pn", current->pid, sig, 
  399. regs->rip, regs->rsp, regs);
  400. #endif
  402. /* Are we from a system call? */
  403. if (regs->orig_rax >= 0) {
  404. /* If so, check system call restarting.. */
  405. switch (regs->rax) {
  406. case -ERESTARTNOHAND:
  407. regs->rax = -EINTR;
  408. break;
  410. case -ERESTARTSYS:
  411. if (!(ka->sa.sa_flags & SA_RESTART)) {
  412. regs->rax = -EINTR;
  413. break;
  414. }
  415. /* fallthrough */
  416. case -ERESTARTNOINTR:
  417. regs->rax = regs->orig_rax;
  418. regs->rip -= 2;
  419. break; 
  420. }
  421. }
  423. #ifdef CONFIG_IA32_EMULATION
  424. if (current->thread.flags & THREAD_IA32) { 
  425. if (ka->sa.sa_flags & SA_SIGINFO)
  426. ia32_setup_rt_frame(sig, ka, info, oldset, regs);
  427. else
  428. ia32_setup_frame(sig, ka, oldset, regs);
  429. } else 
  430. #endif
  431. setup_rt_frame(sig, ka, info, oldset, regs);
  433. if (ka->sa.sa_flags & SA_ONESHOT)
  434. ka->sa.sa_handler = SIG_DFL;
  436. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  437. spin_lock_irq(&current->sigmask_lock);
  438. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  439. sigaddset(&current->blocked,sig);
  440. recalc_sigpending(current);
  441. spin_unlock_irq(&current->sigmask_lock);
  442. }
  443. }
  445. /*
  446.  * Note that 'init' is a special process: it doesn't get signals it doesn't
  447.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  448.  * mistake.
  449.  */
  450. int do_signal(struct pt_regs *regs, sigset_t *oldset)
  451. {
  452. siginfo_t info;
  453. struct k_sigaction *ka;
  455. /*
  456.  * We want the common case to go fast, which
  457.  * is why we may in certain cases get here from
  458.  * kernel mode. Just return without doing anything
  459.  * if so.
  460.  */
  461. if ((regs->cs & 3) != 3) {
  462. return 1;
  463. } 
  465. if (!oldset)
  466. oldset = &current->blocked;
  468. for (;;) {
  469. unsigned long signr;
  471. spin_lock_irq(&current->sigmask_lock);
  472. signr = dequeue_signal(&current->blocked, &info);
  473. spin_unlock_irq(&current->sigmask_lock);
  475. if (!signr) { 
  476. break;
  477. }
  479. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  480. /* Let the debugger run.  */
  481. current->exit_code = signr;
  482. current->state = TASK_STOPPED;
  483. notify_parent(current, SIGCHLD);
  484. schedule();
  486. /* We're back.  Did the debugger cancel the sig?  */
  487. if (!(signr = current->exit_code))
  488. continue;
  489. current->exit_code = 0;
  491. /* The debugger continued.  Ignore SIGSTOP.  */
  492. if (signr == SIGSTOP)
  493. continue;
  495. /* Update the siginfo structure.  Is this good?  */
  496. if (signr != info.si_signo) {
  497. info.si_signo = signr;
  498. info.si_errno = 0;
  499. info.si_code = SI_USER;
  500. info.si_pid = current->p_pptr->pid;
  501. info.si_uid = current->p_pptr->uid;
  502. }
  504. /* If the (new) signal is now blocked, requeue it.  */
  505. if (sigismember(&current->blocked, signr)) {
  506. send_sig_info(signr, &info, current);
  507. continue;
  508. }
  509. }
  511. ka = &current->sig->action[signr-1];
  512. if (ka->sa.sa_handler == SIG_IGN) {
  513. if (signr != SIGCHLD)
  514. continue;
  515. /* Check for SIGCHLD: it's special.  */
  516. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  517. /* nothing */;
  518. continue;
  519. }
  521. if (ka->sa.sa_handler == SIG_DFL) {
  522. int exit_code = signr;
  524. /* Init gets no signals it doesn't want.  */
  525. if (current->pid == 1)       
  526. continue;
  528. switch (signr) {
  529. case SIGCONT: case SIGCHLD: case SIGWINCH: case SIGURG:
  530. continue;
  532. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  533. if (is_orphaned_pgrp(current->pgrp))
  534. continue;
  535. /* FALLTHRU */
  537. case SIGSTOP: {
  538. struct signal_struct *sig;
  539. current->state = TASK_STOPPED;
  540. current->exit_code = signr;
  541. sig = current->p_pptr->sig;
  542. if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  543. notify_parent(current, SIGCHLD);
  544. schedule();
  545. continue;
  546. }
  548. case SIGQUIT: case SIGILL: case SIGTRAP:
  549. case SIGABRT: case SIGFPE: case SIGSEGV:
  550. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  551. if (do_coredump(signr, regs))
  552. exit_code |= 0x80;
  553. /* FALLTHRU */
  555. default:
  556. sig_exit(signr, exit_code, &info);
  557. /* NOTREACHED */
  558. }
  559. }
  561. /* Reenable any watchpoints before delivering the
  562.  * signal to user space. The processor register will
  563.  * have been cleared if the watchpoint triggered
  564.  * inside the kernel.
  565.  */
  566. __asm__("movq %0,%%db7" : : "r" (current->thread.debugreg[7]));
  568. /* Whee!  Actually deliver the signal.  */
  569. handle_signal(signr, ka, &info, oldset, regs);
  570. return 1;
  571. }
  573. /* Did we come from a system call? */
  574. if (regs->orig_rax >= 0) {
  575. /* Restart the system call - no handlers present */
  576. if (regs->rax == -ERESTARTNOHAND ||
  577.     regs->rax == -ERESTARTSYS ||
  578.     regs->rax == -ERESTARTNOINTR) {
  579. regs->rax = regs->orig_rax;
  580. regs->rip -= 2;
  581. }
  582. }
  583. return 0;
  584. }
  587. void signal_fault(struct pt_regs *regs, void *frame, char *where)
  588. { 
  589. struct task_struct *me = current; 
  590. if (exception_trace)
  591. printk("%s[%d] bad frame in %s frame:%p rip:%lx rsp:%lx orax:%lxn",
  592.        me->comm,me->pid,where,frame,regs->rip,regs->rsp,regs->orig_rax); 
  594. force_sig(SIGSEGV, me); 
  595. }