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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
signal.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：15k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

signal.c：源码内容
  1. /*
  2.  *  arch/s390/kernel/signal.c
  3.  *
  4.  *  S390 version
  5.  *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6.  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  7.  *
  8.  *    Based on Intel version
  9.  * 
  10.  *  Copyright (C) 1991, 1992  Linus Torvalds
  11.  *
  12.  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  13.  */
  15. #include <linux/config.h>
  16. #include <linux/sched.h>
  17. #include <linux/mm.h>
  18. #include <linux/smp.h>
  19. #include <linux/smp_lock.h>
  20. #include <linux/kernel.h>
  21. #include <linux/signal.h>
  22. #include <linux/errno.h>
  23. #include <linux/wait.h>
  24. #include <linux/ptrace.h>
  25. #include <linux/unistd.h>
  26. #include <linux/stddef.h>
  27. #include <linux/personality.h>
  28. #include <asm/ucontext.h>
  29. #include <asm/uaccess.h>
  31. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  34. typedef struct 
  35. {
  36. __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  37. struct sigcontext sc;
  38. _sigregs sregs;
  39. __u8 retcode[S390_SYSCALL_SIZE];
  40. } sigframe;
  42. typedef struct 
  43. {
  44. __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  45. __u8 retcode[S390_SYSCALL_SIZE];
  46. struct siginfo info;
  47. struct ucontext uc;
  48. } rt_sigframe;
  50. asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
  52. int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  53. {
  54. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  55. return -EFAULT;
  56. if (from->si_code < 0)
  57. return __copy_to_user(to, from, sizeof(siginfo_t));
  58. else {
  59. int err;
  61. /* If you change siginfo_t structure, please be sure
  62.    this code is fixed accordingly.
  63.    It should never copy any pad contained in the structure
  64.    to avoid security leaks, but must copy the generic
  65.    3 ints plus the relevant union member.  */
  66. err = __put_user(from->si_signo, &to->si_signo);
  67. err |= __put_user(from->si_errno, &to->si_errno);
  68. err |= __put_user((short)from->si_code, &to->si_code);
  69. /* First 32bits of unions are always present.  */
  70. err |= __put_user(from->si_pid, &to->si_pid);
  71. switch (from->si_code >> 16) {
  72. case __SI_FAULT >> 16:
  73. break;
  74. case __SI_CHLD >> 16:
  75. err |= __put_user(from->si_utime, &to->si_utime);
  76. err |= __put_user(from->si_stime, &to->si_stime);
  77. err |= __put_user(from->si_status, &to->si_status);
  78. default:
  79. err |= __put_user(from->si_uid, &to->si_uid);
  80. break;
  81. /* case __SI_RT: This is not generated by the kernel as of now.  */
  82. }
  83. return err;
  84. }
  85. }
  87. /*
  88.  * Atomically swap in the new signal mask, and wait for a signal.
  89.  */
  90. asmlinkage int
  91. sys_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
  92. {
  93. sigset_t saveset;
  95. mask &= _BLOCKABLE;
  96. spin_lock_irq(&current->sigmask_lock);
  97. saveset = current->blocked;
  98. siginitset(&current->blocked, mask);
  99. recalc_sigpending(current);
  100. spin_unlock_irq(&current->sigmask_lock);
  101. regs->gprs[2] = -EINTR;
  103. while (1) {
  104. set_current_state(TASK_INTERRUPTIBLE);
  105. schedule();
  106. if (do_signal(regs, &saveset))
  107. return -EINTR;
  108. }
  109. }
  111. asmlinkage int
  112. sys_rt_sigsuspend(struct pt_regs * regs,sigset_t *unewset, size_t sigsetsize)
  113. {
  114. sigset_t saveset, newset;
  116. /* XXX: Don't preclude handling different sized sigset_t's.  */
  117. if (sigsetsize != sizeof(sigset_t))
  118. return -EINVAL;
  120. if (copy_from_user(&newset, unewset, sizeof(newset)))
  121. return -EFAULT;
  122. sigdelsetmask(&newset, ~_BLOCKABLE);
  124. spin_lock_irq(&current->sigmask_lock);
  125. saveset = current->blocked;
  126. current->blocked = newset;
  127. recalc_sigpending(current);
  128. spin_unlock_irq(&current->sigmask_lock);
  129. regs->gprs[2] = -EINTR;
  131. while (1) {
  132. set_current_state(TASK_INTERRUPTIBLE);
  133. schedule();
  134. if (do_signal(regs, &saveset))
  135. return -EINTR;
  136. }
  137. }
  139. asmlinkage int 
  140. sys_sigaction(int sig, const struct old_sigaction *act,
  141.       struct old_sigaction *oact)
  142. {
  143. struct k_sigaction new_ka, old_ka;
  144. int ret;
  146. if (act) {
  147. old_sigset_t mask;
  148. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  149.     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  150.     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
  151. return -EFAULT;
  152. __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  153. __get_user(mask, &act->sa_mask);
  154. siginitset(&new_ka.sa.sa_mask, mask);
  155. }
  157. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  159. if (!ret && oact) {
  160. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  161.     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  162.     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
  163. return -EFAULT;
  164. __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  165. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  166. }
  168. return ret;
  169. }
  171. asmlinkage int
  172. sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs *regs)
  173. {
  174. return do_sigaltstack(uss, uoss, regs->gprs[15]);
  175. }
  180. static int save_sigregs(struct pt_regs *regs,_sigregs *sregs)
  181. {
  182. int err;
  183. s390_fp_regs fpregs;
  184.   
  185. err = __copy_to_user(&sregs->regs,regs,sizeof(_s390_regs_common));
  186. if(!err)
  187. {
  188. save_fp_regs(&fpregs);
  189. err=__copy_to_user(&sregs->fpregs,&fpregs,sizeof(fpregs));
  190. }
  191. return(err);
  193. }
  195. static int restore_sigregs(struct pt_regs *regs,_sigregs *sregs)
  196. {
  197. int err;
  198. s390_fp_regs fpregs;
  199. psw_t saved_psw=regs->psw;
  200. err=__copy_from_user(regs,&sregs->regs,sizeof(_s390_regs_common));
  201. if(!err)
  202. {
  203. regs->trap = -1; /* disable syscall checks */
  204. regs->psw.mask=(saved_psw.mask&~PSW_MASK_DEBUGCHANGE)|
  205. (regs->psw.mask&PSW_MASK_DEBUGCHANGE);
  206. regs->psw.addr=(saved_psw.addr&~PSW_ADDR_DEBUGCHANGE)|
  207. (regs->psw.addr&PSW_ADDR_DEBUGCHANGE);
  208. err=__copy_from_user(&fpregs,&sregs->fpregs,sizeof(fpregs));
  209. if(!err)
  210. restore_fp_regs(&fpregs);
  211. }
  212. return(err);
  213. }
  215. asmlinkage long sys_sigreturn(struct pt_regs *regs)
  216. {
  217. sigframe *frame = (sigframe *)regs->gprs[15];
  218. sigset_t set;
  220. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  221. goto badframe;
  222. if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
  223. goto badframe;
  225. sigdelsetmask(&set, ~_BLOCKABLE);
  226. spin_lock_irq(&current->sigmask_lock);
  227. current->blocked = set;
  228. recalc_sigpending(current);
  229. spin_unlock_irq(&current->sigmask_lock);
  231. if (restore_sigregs(regs, &frame->sregs))
  232. goto badframe;
  234. return regs->gprs[2];
  236. badframe:
  237. force_sig(SIGSEGV, current);
  238. return 0;
  239. }
  241. asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
  242. {
  243. rt_sigframe *frame = (rt_sigframe *)regs->gprs[15];
  244. sigset_t set;
  246. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  247. goto badframe;
  248. if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
  249. goto badframe;
  251. sigdelsetmask(&set, ~_BLOCKABLE);
  252. spin_lock_irq(&current->sigmask_lock);
  253. current->blocked = set;
  254. recalc_sigpending(current);
  255. spin_unlock_irq(&current->sigmask_lock);
  257. if (restore_sigregs(regs, &frame->uc.uc_mcontext))
  258. goto badframe;
  260. /* It is more difficult to avoid calling this function than to
  261.    call it and ignore errors.  */
  262. do_sigaltstack(&frame->uc.uc_stack, NULL, regs->gprs[15]);
  263. return regs->gprs[2];
  265. badframe:
  266. force_sig(SIGSEGV, current);
  267. return 0;
  268. }
  270. /*
  271.  * Set up a signal frame.
  272.  */
  275. /*
  276.  * Determine which stack to use..
  277.  */
  278. static inline void *
  279. get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
  280. {
  281. unsigned long sp;
  283. /* Default to using normal stack */
  284. sp = regs->gprs[15];
  286. /* This is the X/Open sanctioned signal stack switching.  */
  287. if (ka->sa.sa_flags & SA_ONSTACK) {
  288. if (! on_sig_stack(sp))
  289. sp = current->sas_ss_sp + current->sas_ss_size;
  290. }
  292. /* This is the legacy signal stack switching. */
  293. else if (!user_mode(regs) &&
  294.  !(ka->sa.sa_flags & SA_RESTORER) &&
  295.  ka->sa.sa_restorer) {
  296. sp = (unsigned long) ka->sa.sa_restorer;
  297. }
  299. return (void *)((sp - frame_size) & -8ul);
  300. }
  302. static inline int map_signal(int sig)
  303. {
  304. if (current->exec_domain
  305.     && current->exec_domain->signal_invmap
  306.     && sig < 32)
  307. return current->exec_domain->signal_invmap[sig];
  308. else
  309. return sig;
  310. }
  312. static void setup_frame(int sig, struct k_sigaction *ka,
  313. sigset_t *set, struct pt_regs * regs)
  314. {
  315. sigframe *frame = get_sigframe(ka, regs, sizeof(sigframe));
  316. if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
  317. goto give_sigsegv;
  319. if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
  320. goto give_sigsegv;
  322. if (save_sigregs(regs, &frame->sregs))
  323. goto give_sigsegv;
  324. if (__put_user(&frame->sregs, &frame->sc.sregs))
  325. goto give_sigsegv;
  327. /* Set up to return from userspace.  If provided, use a stub
  328.    already in userspace.  */
  329. if (ka->sa.sa_flags & SA_RESTORER) {
  330.                 regs->gprs[14] = FIX_PSW(ka->sa.sa_restorer);
  331. } else {
  332.                 regs->gprs[14] = FIX_PSW(frame->retcode);
  333. if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, 
  334.                        (u16 *)(frame->retcode)))
  335. goto give_sigsegv;
  336. }
  338. /* Set up registers for signal handler */
  339. regs->gprs[15] = (addr_t)frame;
  340. regs->psw.addr = FIX_PSW(ka->sa.sa_handler);
  341. regs->psw.mask = _USER_PSW_MASK;
  343. regs->gprs[2] = map_signal(sig);
  344. regs->gprs[3] = (addr_t)&frame->sc;
  346. /* We forgot to include these in the sigcontext.
  347.    To avoid breaking binary compatibility, they are passed as args. */
  348. regs->gprs[4] = current->thread.trap_no;
  349. regs->gprs[5] = current->thread.prot_addr;
  350. return;
  352. give_sigsegv:
  353. if (sig == SIGSEGV)
  354. ka->sa.sa_handler = SIG_DFL;
  355. force_sig(SIGSEGV, current);
  356. }
  358. static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
  359.    sigset_t *set, struct pt_regs * regs)
  360. {
  361. int err = 0;
  362. rt_sigframe *frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
  363. if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
  364. goto give_sigsegv;
  366. if (copy_siginfo_to_user(&frame->info, info))
  367. goto give_sigsegv;
  369. /* Create the ucontext.  */
  370. err |= __put_user(0, &frame->uc.uc_flags);
  371. err |= __put_user(0, &frame->uc.uc_link);
  372. err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
  373. err |= __put_user(sas_ss_flags(regs->gprs[15]),
  374.   &frame->uc.uc_stack.ss_flags);
  375. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  376. err |= save_sigregs(regs, &frame->uc.uc_mcontext);
  377. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  378. if (err)
  379. goto give_sigsegv;
  381. /* Set up to return from userspace.  If provided, use a stub
  382.    already in userspace.  */
  383. if (ka->sa.sa_flags & SA_RESTORER) {
  384.                 regs->gprs[14] = FIX_PSW(ka->sa.sa_restorer);
  385. } else {
  386.                 regs->gprs[14] = FIX_PSW(frame->retcode);
  387. err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, 
  388.                           (u16 *)(frame->retcode));
  389. }
  391. /* Set up registers for signal handler */
  392. regs->gprs[15] = (addr_t)frame;
  393. regs->psw.addr = FIX_PSW(ka->sa.sa_handler);
  394. regs->psw.mask = _USER_PSW_MASK;
  396. regs->gprs[2] = map_signal(sig);
  397. regs->gprs[3] = (addr_t)&frame->info;
  398. regs->gprs[4] = (addr_t)&frame->uc;
  399. return;
  401. give_sigsegv:
  402. if (sig == SIGSEGV)
  403. ka->sa.sa_handler = SIG_DFL;
  404. force_sig(SIGSEGV, current);
  405. }
  407. /*
  408.  * OK, we're invoking a handler
  409.  */
  411. static void
  412. handle_signal(unsigned long sig, struct k_sigaction *ka,
  413.       siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  414. {
  415. /* Are we from a system call? */
  416. if (regs->trap == __LC_SVC_OLD_PSW) {
  417. /* If so, check system call restarting.. */
  418. switch (regs->gprs[2]) {
  419. case -ERESTARTNOHAND:
  420. regs->gprs[2] = -EINTR;
  421. break;
  423. case -ERESTARTSYS:
  424. if (!(ka->sa.sa_flags & SA_RESTART)) {
  425. regs->gprs[2] = -EINTR;
  426. break;
  427. }
  428. /* fallthrough */
  429. case -ERESTARTNOINTR:
  430. regs->gprs[2] = regs->orig_gpr2;
  431. regs->psw.addr -= 2;
  432. }
  433. }
  435. /* Set up the stack frame */
  436. if (ka->sa.sa_flags & SA_SIGINFO)
  437. setup_rt_frame(sig, ka, info, oldset, regs);
  438. else
  439. setup_frame(sig, ka, oldset, regs);
  441. if (ka->sa.sa_flags & SA_ONESHOT)
  442. ka->sa.sa_handler = SIG_DFL;
  444. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  445. spin_lock_irq(&current->sigmask_lock);
  446. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  447. sigaddset(&current->blocked,sig);
  448. recalc_sigpending(current);
  449. spin_unlock_irq(&current->sigmask_lock);
  450. }
  451. }
  453. /*
  454.  * Note that 'init' is a special process: it doesn't get signals it doesn't
  455.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  456.  * mistake.
  457.  *
  458.  * Note that we go through the signals twice: once to check the signals that
  459.  * the kernel can handle, and then we build all the user-level signal handling
  460.  * stack-frames in one go after that.
  461.  */
  462. int do_signal(struct pt_regs *regs, sigset_t *oldset)
  463. {
  464. siginfo_t info;
  465. struct k_sigaction *ka;
  467. /*
  468.  * We want the common case to go fast, which
  469.  * is why we may in certain cases get here from
  470.  * kernel mode. Just return without doing anything
  471.  * if so.
  472.  */
  473. if (!user_mode(regs))
  474. return 1;
  476. if (!oldset)
  477. oldset = &current->blocked;
  479. for (;;) {
  480. unsigned long signr;
  482. spin_lock_irq(&current->sigmask_lock);
  483. signr = dequeue_signal(&current->blocked, &info);
  484. spin_unlock_irq(&current->sigmask_lock);
  486. if (!signr)
  487. break;
  489. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  490. /* Let the debugger run.  */
  491. current->exit_code = signr;
  492. set_current_state(TASK_STOPPED);
  493. notify_parent(current, SIGCHLD);
  494. schedule();
  496. /* We're back.  Did the debugger cancel the sig?  */
  497. if (!(signr = current->exit_code))
  498. continue;
  499. current->exit_code = 0;
  501. /* The debugger continued.  Ignore SIGSTOP.  */
  502. if (signr == SIGSTOP)
  503. continue;
  505. /* Update the siginfo structure.  Is this good?  */
  506. if (signr != info.si_signo) {
  507. info.si_signo = signr;
  508. info.si_errno = 0;
  509. info.si_code = SI_USER;
  510. info.si_pid = current->p_pptr->pid;
  511. info.si_uid = current->p_pptr->uid;
  512. }
  514. /* If the (new) signal is now blocked, requeue it.  */
  515. if (sigismember(&current->blocked, signr)) {
  516. send_sig_info(signr, &info, current);
  517. continue;
  518. }
  519. }
  521. ka = &current->sig->action[signr-1];
  522. if (ka->sa.sa_handler == SIG_IGN) {
  523. if (signr != SIGCHLD)
  524. continue;
  525. /* Check for SIGCHLD: it's special.  */
  526. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  527. /* nothing */;
  528. continue;
  529. }
  531. if (ka->sa.sa_handler == SIG_DFL) {
  532. int exit_code = signr;
  534. /* Init gets no signals it doesn't want.  */
  535. if (current->pid == 1)
  536. continue;
  538. switch (signr) {
  539. case SIGCONT: case SIGCHLD: case SIGWINCH:
  540. continue;
  542. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  543. if (is_orphaned_pgrp(current->pgrp))
  544. continue;
  545. /* FALLTHRU */
  547. case SIGSTOP: {
  548. struct signal_struct *sig;
  549. set_current_state(TASK_STOPPED);
  550. current->exit_code = signr;
  551. sig = current->p_pptr->sig;
  552. if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  553. notify_parent(current, SIGCHLD);
  554. schedule();
  555. continue;
  556. }
  558. case SIGQUIT: case SIGILL: case SIGTRAP:
  559. case SIGABRT: case SIGFPE: case SIGSEGV:
  560. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  561.                                 if (do_coredump(signr, regs))
  562.                                         exit_code |= 0x80;
  563.                                 /* FALLTHRU */
  565. default:
  566. sigaddset(&current->pending.signal, signr);
  567. recalc_sigpending(current);
  568. current->flags |= PF_SIGNALED;
  569. do_exit(exit_code);
  570. /* NOTREACHED */
  571. }
  572. }
  574. /* Whee!  Actually deliver the signal.  */
  575. handle_signal(signr, ka, &info, oldset, regs);
  576. return 1;
  577. }
  579. /* Did we come from a system call? */
  580. if ( regs->trap == __LC_SVC_OLD_PSW /* System Call! */ ) {
  581. /* Restart the system call - no handlers present */
  582. if (regs->gprs[2] == -ERESTARTNOHAND ||
  583.     regs->gprs[2] == -ERESTARTSYS ||
  584.     regs->gprs[2] == -ERESTARTNOINTR) {
  585. regs->gprs[2] = regs->orig_gpr2;
  586. regs->psw.addr -= 2;
  587. }
  588. }
  589. return 0;
  590. }