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

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

嵌入式Linux

开发平台：

Unix_Linux

ia32_signal.c：源码内容
  1. /*
  2.  * IA32 Architecture-specific signal handling support.
  3.  *
  4.  * Copyright (C) 1999, 2001 Hewlett-Packard Co
  5.  * David Mosberger-Tang <davidm@hpl.hp.com>
  6.  * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
  7.  * Copyright (C) 2000 VA Linux Co
  8.  * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
  9.  *
  10.  * Derived from i386 and Alpha versions.
  11.  */
  13. #include <linux/errno.h>
  14. #include <linux/kernel.h>
  15. #include <linux/mm.h>
  16. #include <linux/personality.h>
  17. #include <linux/ptrace.h>
  18. #include <linux/sched.h>
  19. #include <linux/signal.h>
  20. #include <linux/smp.h>
  21. #include <linux/smp_lock.h>
  22. #include <linux/stddef.h>
  23. #include <linux/unistd.h>
  24. #include <linux/wait.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/rse.h>
  28. #include <asm/sigcontext.h>
  29. #include <asm/segment.h>
  30. #include <asm/ia32.h>
  32. #include "../kernel/sigframe.h"
  34. #define A(__x) ((unsigned long)(__x))
  36. #define DEBUG_SIG 0
  37. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  39. #define __IA32_NR_sigreturn            119
  40. #define __IA32_NR_rt_sigreturn         173
  42. struct sigframe_ia32
  43. {
  44.        int pretcode;
  45.        int sig;
  46.        struct sigcontext_ia32 sc;
  47.        struct _fpstate_ia32 fpstate;
  48.        unsigned int extramask[_IA32_NSIG_WORDS-1];
  49.        char retcode[8];
  50. };
  52. struct rt_sigframe_ia32
  53. {
  54.        int pretcode;
  55.        int sig;
  56.        int pinfo;
  57.        int puc;
  58.        siginfo_t32 info;
  59.        struct ucontext_ia32 uc;
  60.        struct _fpstate_ia32 fpstate;
  61.        char retcode[8];
  62. };
  64. int
  65. copy_siginfo_from_user32 (siginfo_t *to, siginfo_t32 *from)
  66. {
  67. unsigned long tmp;
  68. int err;
  70. if (!access_ok(VERIFY_READ, from, sizeof(siginfo_t32)))
  71. return -EFAULT;
  73. err = __get_user(to->si_signo, &from->si_signo);
  74. err |= __get_user(to->si_errno, &from->si_errno);
  75. err |= __get_user(to->si_code, &from->si_code);
  77. if (from->si_code < 0)
  78. err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  79. else {
  80. switch (from->si_code >> 16) {
  81.       case __SI_CHLD >> 16:
  82. err |= __get_user(to->si_utime, &from->si_utime);
  83. err |= __get_user(to->si_stime, &from->si_stime);
  84. err |= __get_user(to->si_status, &from->si_status);
  85.       default:
  86. err |= __get_user(to->si_pid, &from->si_pid);
  87. err |= __get_user(to->si_uid, &from->si_uid);
  88. break;
  89.       case __SI_FAULT >> 16:
  90. err |= __get_user(tmp, &from->si_addr);
  91. to->si_addr = (void *) tmp;
  92. break;
  93.       case __SI_POLL >> 16:
  94. err |= __get_user(to->si_band, &from->si_band);
  95. err |= __get_user(to->si_fd, &from->si_fd);
  96. break;
  97. /* case __SI_RT: This is not generated by the kernel as of now.  */
  98. }
  99. }
  100. return err;
  101. }
  103. int
  104. copy_siginfo_to_user32 (siginfo_t32 *to, siginfo_t *from)
  105. {
  106. int err;
  108. if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t32)))
  109. return -EFAULT;
  111. /* If you change siginfo_t structure, please be sure
  112.    this code is fixed accordingly.
  113.    It should never copy any pad contained in the structure
  114.    to avoid security leaks, but must copy the generic
  115.    3 ints plus the relevant union member.
  116.    This routine must convert siginfo from 64bit to 32bit as well
  117.    at the same time.  */
  118. err = __put_user(from->si_signo, &to->si_signo);
  119. err |= __put_user(from->si_errno, &to->si_errno);
  120. err |= __put_user((short)from->si_code, &to->si_code);
  121. if (from->si_code < 0)
  122. err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  123. else {
  124. switch (from->si_code >> 16) {
  125. case __SI_CHLD >> 16:
  126. err |= __put_user(from->si_utime, &to->si_utime);
  127. err |= __put_user(from->si_stime, &to->si_stime);
  128. err |= __put_user(from->si_status, &to->si_status);
  129. default:
  130. err |= __put_user(from->si_pid, &to->si_pid);
  131. err |= __put_user(from->si_uid, &to->si_uid);
  132. break;
  133. case __SI_FAULT >> 16:
  134. err |= __put_user((long)from->si_addr, &to->si_addr);
  135. break;
  136. case __SI_POLL >> 16:
  137. err |= __put_user(from->si_band, &to->si_band);
  138. err |= __put_user(from->si_fd, &to->si_fd);
  139. break;
  140. /* case __SI_RT: This is not generated by the kernel as of now.  */
  141. }
  142. }
  143. return err;
  144. }
  146. static inline void
  147. sigact_set_handler (struct k_sigaction *sa, unsigned int handler, unsigned int restorer)
  148. {
  149. if (handler + 1 <= 2)
  150. /* SIG_DFL, SIG_IGN, or SIG_ERR: must sign-extend to 64-bits */
  151. sa->sa.sa_handler = (__sighandler_t) A((int) handler);
  152. else
  153. sa->sa.sa_handler = (__sighandler_t) (((unsigned long) restorer << 32) | handler);
  154. }
  156. asmlinkage long
  157. ia32_rt_sigsuspend (sigset32_t *uset, unsigned int sigsetsize, struct sigscratch *scr)
  158. {
  159. extern long ia64_do_signal (sigset_t *oldset, struct sigscratch *scr, long in_syscall);
  160. sigset_t oldset, set;
  162. scr->scratch_unat = 0; /* avoid leaking kernel bits to user level */
  163. memset(&set, 0, sizeof(&set));
  165. if (sigsetsize > sizeof(sigset_t))
  166. return -EINVAL;
  168. if (copy_from_user(&set.sig, &uset->sig, sigsetsize))
  169. return -EFAULT;
  171. sigdelsetmask(&set, ~_BLOCKABLE);
  173. spin_lock_irq(&current->sigmask_lock);
  174. {
  175. oldset = current->blocked;
  176. current->blocked = set;
  177. recalc_sigpending(current);
  178. }
  179. spin_unlock_irq(&current->sigmask_lock);
  181. /*
  182.  * The return below usually returns to the signal handler.  We need to pre-set the
  183.  * correct error code here to ensure that the right values get saved in sigcontext
  184.  * by ia64_do_signal.
  185.  */
  186. scr->pt.r8 = -EINTR;
  187. while (1) {
  188. current->state = TASK_INTERRUPTIBLE;
  189. schedule();
  190. if (ia64_do_signal(&oldset, scr, 1))
  191. return -EINTR;
  192. }
  193. }
  195. asmlinkage long
  196. ia32_sigsuspend (unsigned int mask, struct sigscratch *scr)
  197. {
  198. return ia32_rt_sigsuspend((sigset32_t *)&mask, sizeof(mask), scr);
  199. }
  201. asmlinkage long
  202. sys32_signal (int sig, unsigned int handler)
  203. {
  204. struct k_sigaction new_sa, old_sa;
  205. int ret;
  207. sigact_set_handler(&new_sa, handler, 0);
  208. new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
  210. ret = do_sigaction(sig, &new_sa, &old_sa);
  212. return ret ? ret : IA32_SA_HANDLER(&old_sa);
  213. }
  215. asmlinkage long
  216. sys32_rt_sigaction (int sig, struct sigaction32 *act,
  217.     struct sigaction32 *oact, unsigned int sigsetsize)
  218. {
  219. struct k_sigaction new_ka, old_ka;
  220. unsigned int handler, restorer;
  221. int ret;
  223. /* XXX: Don't preclude handling different sized sigset_t's.  */
  224. if (sigsetsize != sizeof(sigset32_t))
  225. return -EINVAL;
  227. if (act) {
  228. ret = get_user(handler, &act->sa_handler);
  229. ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
  230. ret |= get_user(restorer, &act->sa_restorer);
  231. ret |= copy_from_user(&new_ka.sa.sa_mask, &act->sa_mask, sizeof(sigset32_t));
  232. if (ret)
  233. return -EFAULT;
  235. sigact_set_handler(&new_ka, handler, restorer);
  236. }
  238. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  240. if (!ret && oact) {
  241. ret = put_user(IA32_SA_HANDLER(&old_ka), &oact->sa_handler);
  242. ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  243. ret |= put_user(IA32_SA_RESTORER(&old_ka), &oact->sa_restorer);
  244. ret |= copy_to_user(&oact->sa_mask, &old_ka.sa.sa_mask, sizeof(sigset32_t));
  245. }
  246. return ret;
  247. }
  250. extern asmlinkage long sys_rt_sigprocmask (int how, sigset_t *set, sigset_t *oset,
  251.    size_t sigsetsize);
  253. asmlinkage long
  254. sys32_rt_sigprocmask (int how, sigset32_t *set, sigset32_t *oset, unsigned int sigsetsize)
  255. {
  256. mm_segment_t old_fs = get_fs();
  257. sigset_t s;
  258. long ret;
  260. if (sigsetsize > sizeof(s))
  261. return -EINVAL;
  263. if (set) {
  264. memset(&s, 0, sizeof(s));
  265. if (copy_from_user(&s.sig, set, sigsetsize))
  266. return -EFAULT;
  267. }
  268. set_fs(KERNEL_DS);
  269. ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL, sizeof(s));
  270. set_fs(old_fs);
  271. if (ret)
  272. return ret;
  273. if (oset) {
  274. if (copy_to_user(oset, &s.sig, sigsetsize))
  275. return -EFAULT;
  276. }
  277. return 0;
  278. }
  280. asmlinkage long
  281. sys32_sigprocmask (int how, unsigned int *set, unsigned int *oset)
  282. {
  283. return sys32_rt_sigprocmask(how, (sigset32_t *) set, (sigset32_t *) oset, sizeof(*set));
  284. }
  286. asmlinkage long
  287. sys32_rt_sigtimedwait (sigset32_t *uthese, siginfo_t32 *uinfo, struct timespec32 *uts,
  288.        unsigned int sigsetsize)
  289. {
  290. extern asmlinkage long sys_rt_sigtimedwait (const sigset_t *, siginfo_t *,
  291.     const struct timespec *, size_t);
  292. extern int copy_siginfo_to_user32 (siginfo_t32 *, siginfo_t *);
  293. mm_segment_t old_fs = get_fs();
  294. struct timespec t;
  295. siginfo_t info;
  296. sigset_t s;
  297. int ret;
  299. if (copy_from_user(&s.sig, uthese, sizeof(sigset32_t)))
  300. return -EFAULT;
  301. if (uts) {
  302. ret = get_user(t.tv_sec, &uts->tv_sec);
  303. ret |= get_user(t.tv_nsec, &uts->tv_nsec);
  304. if (ret)
  305. return -EFAULT;
  306. }
  307. set_fs(KERNEL_DS);
  308. ret = sys_rt_sigtimedwait(&s, &info, &t, sigsetsize);
  309. set_fs(old_fs);
  310. if (ret >= 0 && uinfo) {
  311. if (copy_siginfo_to_user32(uinfo, &info))
  312. return -EFAULT;
  313. }
  314. return ret;
  315. }
  317. asmlinkage long
  318. sys32_rt_sigqueueinfo (int pid, int sig, siginfo_t32 *uinfo)
  319. {
  320. extern asmlinkage long sys_rt_sigqueueinfo (int, int, siginfo_t *);
  321. extern int copy_siginfo_from_user32 (siginfo_t *to, siginfo_t32 *from);
  322. mm_segment_t old_fs = get_fs();
  323. siginfo_t info;
  324. int ret;
  326. if (copy_siginfo_from_user32(&info, uinfo))
  327. return -EFAULT;
  328. set_fs(KERNEL_DS);
  329. ret = sys_rt_sigqueueinfo(pid, sig, &info);
  330. set_fs(old_fs);
  331. return ret;
  332. }
  334. asmlinkage long
  335. sys32_sigaction (int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact)
  336. {
  337. struct k_sigaction new_ka, old_ka;
  338. unsigned int handler, restorer;
  339. int ret;
  341. if (act) {
  342. old_sigset32_t mask;
  344. ret = get_user(handler, &act->sa_handler);
  345. ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
  346. ret |= get_user(restorer, &act->sa_restorer);
  347. ret |= get_user(mask, &act->sa_mask);
  348. if (ret)
  349. return ret;
  351. sigact_set_handler(&new_ka, handler, restorer);
  352. siginitset(&new_ka.sa.sa_mask, mask);
  353. }
  355. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  357. if (!ret && oact) {
  358. ret = put_user(IA32_SA_HANDLER(&old_ka), &oact->sa_handler);
  359. ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  360. ret |= put_user(IA32_SA_RESTORER(&old_ka), &oact->sa_restorer);
  361. ret |= put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  362. }
  364. return ret;
  365. }
  367. static int
  368. setup_sigcontext_ia32 (struct sigcontext_ia32 *sc, struct _fpstate_ia32 *fpstate,
  369.        struct pt_regs *regs, unsigned long mask)
  370. {
  371. int  err = 0;
  372. unsigned long flag;
  374. err |= __put_user((regs->r16 >> 32) & 0xffff, (unsigned int *)&sc->fs);
  375. err |= __put_user((regs->r16 >> 48) & 0xffff, (unsigned int *)&sc->gs);
  376. err |= __put_user((regs->r16 >> 16) & 0xffff, (unsigned int *)&sc->es);
  377. err |= __put_user(regs->r16 & 0xffff, (unsigned int *)&sc->ds);
  378. err |= __put_user(regs->r15, &sc->edi);
  379. err |= __put_user(regs->r14, &sc->esi);
  380. err |= __put_user(regs->r13, &sc->ebp);
  381. err |= __put_user(regs->r12, &sc->esp);
  382. err |= __put_user(regs->r11, &sc->ebx);
  383. err |= __put_user(regs->r10, &sc->edx);
  384. err |= __put_user(regs->r9, &sc->ecx);
  385. err |= __put_user(regs->r8, &sc->eax);
  386. #if 0
  387. err |= __put_user(current->tss.trap_no, &sc->trapno);
  388. err |= __put_user(current->tss.error_code, &sc->err);
  389. #endif
  390. err |= __put_user(regs->cr_iip, &sc->eip);
  391. err |= __put_user(regs->r17 & 0xffff, (unsigned int *)&sc->cs);
  392. /*
  393.  *  `eflags' is in an ar register for this context
  394.  */
  395. asm volatile ("mov %0=ar.eflag ;;" : "=r"(flag));
  396. err |= __put_user((unsigned int)flag, &sc->eflags);
  397. err |= __put_user(regs->r12, &sc->esp_at_signal);
  398. err |= __put_user((regs->r17 >> 16) & 0xffff, (unsigned int *)&sc->ss);
  400. #if 0
  401. tmp = save_i387(fpstate);
  402. if (tmp < 0)
  403. err = 1;
  404. else
  405. err |= __put_user(tmp ? fpstate : NULL, &sc->fpstate);
  407. /* non-iBCS2 extensions.. */
  408. #endif
  409. err |= __put_user(mask, &sc->oldmask);
  410. #if 0
  411. err |= __put_user(current->tss.cr2, &sc->cr2);
  412. #endif
  413. return err;
  414. }
  416. static int
  417. restore_sigcontext_ia32 (struct pt_regs *regs, struct sigcontext_ia32 *sc, int *peax)
  418. {
  419. unsigned int err = 0;
  421. #define COPY(ia64x, ia32x) err |= __get_user(regs->ia64x, &sc->ia32x)
  423. #define copyseg_gs(tmp) (regs->r16 |= (unsigned long) tmp << 48)
  424. #define copyseg_fs(tmp) (regs->r16 |= (unsigned long) tmp << 32)
  425. #define copyseg_cs(tmp) (regs->r17 |= tmp)
  426. #define copyseg_ss(tmp) (regs->r17 |= (unsigned long) tmp << 16)
  427. #define copyseg_es(tmp) (regs->r16 |= (unsigned long) tmp << 16)
  428. #define copyseg_ds(tmp) (regs->r16 |= tmp)
  430. #define COPY_SEG(seg)
  431. {
  432. unsigned short tmp;
  433. err |= __get_user(tmp, &sc->seg);
  434. copyseg_##seg(tmp);
  435. }
  436. #define COPY_SEG_STRICT(seg)
  437. {
  438. unsigned short tmp;
  439. err |= __get_user(tmp, &sc->seg);
  440. copyseg_##seg(tmp|3);
  441. }
  443. /* To make COPY_SEGs easier, we zero r16, r17 */
  444. regs->r16 = 0;
  445. regs->r17 = 0;
  447. COPY_SEG(gs);
  448. COPY_SEG(fs);
  449. COPY_SEG(es);
  450. COPY_SEG(ds);
  451. COPY(r15, edi);
  452. COPY(r14, esi);
  453. COPY(r13, ebp);
  454. COPY(r12, esp);
  455. COPY(r11, ebx);
  456. COPY(r10, edx);
  457. COPY(r9, ecx);
  458. COPY(cr_iip, eip);
  459. COPY_SEG_STRICT(cs);
  460. COPY_SEG_STRICT(ss);
  461. ia32_load_segment_descriptors(current);
  462. {
  463. unsigned int tmpflags;
  464. unsigned long flag;
  466. /*
  467.  *  IA32 `eflags' is not part of `pt_regs', it's in an ar register which
  468.  *  is part of the thread context.  Fortunately, we are executing in the
  469.  *  IA32 process's context.
  470.  */
  471. err |= __get_user(tmpflags, &sc->eflags);
  472. asm volatile ("mov %0=ar.eflag ;;" : "=r"(flag));
  473. flag &= ~0x40DD5;
  474. flag |= (tmpflags & 0x40DD5);
  475. asm volatile ("mov ar.eflag=%0 ;;" :: "r"(flag));
  477. regs->r1 = -1; /* disable syscall checks, r1 is orig_eax */
  478. }
  480. #if 0
  481. {
  482. struct _fpstate * buf;
  483. err |= __get_user(buf, &sc->fpstate);
  484. if (buf) {
  485. if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
  486. goto badframe;
  487. err |= restore_i387(buf);
  488. }
  489. }
  490. #endif
  492. err |= __get_user(*peax, &sc->eax);
  493. return err;
  495. #if 0
  496.   badframe:
  497. return 1;
  498. #endif
  499. }
  501. /*
  502.  * Determine which stack to use..
  503.  */
  504. static inline void *
  505. get_sigframe (struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
  506. {
  507. unsigned long esp;
  509. /* Default to using normal stack (truncate off sign-extension of bit 31: */
  510. esp = (unsigned int) regs->r12;
  512. /* This is the X/Open sanctioned signal stack switching.  */
  513. if (ka->sa.sa_flags & SA_ONSTACK) {
  514. if (!on_sig_stack(esp))
  515. esp = current->sas_ss_sp + current->sas_ss_size;
  516. }
  517. /* Legacy stack switching not supported */
  519. return (void *)((esp - frame_size) & -8ul);
  520. }
  522. static int
  523. setup_frame_ia32 (int sig, struct k_sigaction *ka, sigset_t *set, struct pt_regs * regs)
  524. {
  525. struct sigframe_ia32 *frame;
  526. int err = 0;
  528. frame = get_sigframe(ka, regs, sizeof(*frame));
  530. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  531. goto give_sigsegv;
  533. err |= __put_user((current->exec_domain
  534.    && current->exec_domain->signal_invmap
  535.    && sig < 32
  536.    ? (int)(current->exec_domain->signal_invmap[sig])
  537.    : sig),
  538.   &frame->sig);
  540. err |= setup_sigcontext_ia32(&frame->sc, &frame->fpstate, regs, set->sig[0]);
  542. if (_IA32_NSIG_WORDS > 1)
  543. err |= __copy_to_user(frame->extramask, (char *) &set->sig + 4,
  544.       sizeof(frame->extramask));
  546. /* Set up to return from userspace.  If provided, use a stub
  547.    already in userspace.  */
  548. if (ka->sa.sa_flags & SA_RESTORER) {
  549. unsigned int restorer = IA32_SA_RESTORER(ka);
  550. err |= __put_user(restorer, &frame->pretcode);
  551. } else {
  552. err |= __put_user((long)frame->retcode, &frame->pretcode);
  553. /* This is popl %eax ; movl $,%eax ; int $0x80 */
  554. err |= __put_user(0xb858, (short *)(frame->retcode+0));
  555. err |= __put_user(__IA32_NR_sigreturn & 0xffff, (short *)(frame->retcode+2));
  556. err |= __put_user(__IA32_NR_sigreturn >> 16, (short *)(frame->retcode+4));
  557. err |= __put_user(0x80cd, (short *)(frame->retcode+6));
  558. }
  560. if (err)
  561. goto give_sigsegv;
  563. /* Set up registers for signal handler */
  564. regs->r12 = (unsigned long) frame;
  565. regs->cr_iip = IA32_SA_HANDLER(ka);
  567. set_fs(USER_DS);
  568. regs->r16 = (__USER_DS << 16) |  (__USER_DS); /* ES == DS, GS, FS are zero */
  569. regs->r17 = (__USER_DS << 16) | __USER_CS;
  571. #if 0
  572. regs->eflags &= ~TF_MASK;
  573. #endif
  575. #if 0
  576. printk("SIG deliver (%s:%d): sig=%d sp=%p pc=%lx ra=%xn",
  577.                current->comm, current->pid, sig, (void *) frame, regs->cr_iip, frame->pretcode);
  578. #endif
  580. return 1;
  582.   give_sigsegv:
  583. if (sig == SIGSEGV)
  584. ka->sa.sa_handler = SIG_DFL;
  585. force_sig(SIGSEGV, current);
  586. return 0;
  587. }
  589. static int
  590. setup_rt_frame_ia32 (int sig, struct k_sigaction *ka, siginfo_t *info,
  591.      sigset_t *set, struct pt_regs * regs)
  592. {
  593. struct rt_sigframe_ia32 *frame;
  594. int err = 0;
  596. frame = get_sigframe(ka, regs, sizeof(*frame));
  598. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  599. goto give_sigsegv;
  601. err |= __put_user((current->exec_domain
  602.    && current->exec_domain->signal_invmap
  603.    && sig < 32
  604.    ? current->exec_domain->signal_invmap[sig]
  605.    : sig),
  606.   &frame->sig);
  607. err |= __put_user((long)&frame->info, &frame->pinfo);
  608. err |= __put_user((long)&frame->uc, &frame->puc);
  609. err |= copy_siginfo_to_user32(&frame->info, info);
  611. /* Create the ucontext.  */
  612. err |= __put_user(0, &frame->uc.uc_flags);
  613. err |= __put_user(0, &frame->uc.uc_link);
  614. err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
  615. err |= __put_user(sas_ss_flags(regs->r12), &frame->uc.uc_stack.ss_flags);
  616. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  617. err |= setup_sigcontext_ia32(&frame->uc.uc_mcontext, &frame->fpstate, regs, set->sig[0]);
  618. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  619. if (err)
  620. goto give_sigsegv;
  622. /* Set up to return from userspace.  If provided, use a stub
  623.    already in userspace.  */
  624. if (ka->sa.sa_flags & SA_RESTORER) {
  625. unsigned int restorer = IA32_SA_RESTORER(ka);
  626. err |= __put_user(restorer, &frame->pretcode);
  627. } else {
  628. err |= __put_user((long)frame->retcode, &frame->pretcode);
  629. /* This is movl $,%eax ; int $0x80 */
  630. err |= __put_user(0xb8, (char *)(frame->retcode+0));
  631. err |= __put_user(__IA32_NR_rt_sigreturn, (int *)(frame->retcode+1));
  632. err |= __put_user(0x80cd, (short *)(frame->retcode+5));
  633. }
  635. if (err)
  636. goto give_sigsegv;
  638. /* Set up registers for signal handler */
  639. regs->r12 = (unsigned long) frame;
  640. regs->cr_iip = IA32_SA_HANDLER(ka);
  642. set_fs(USER_DS);
  644. regs->r16 = (__USER_DS << 16) |  (__USER_DS); /* ES == DS, GS, FS are zero */
  645. regs->r17 = (__USER_DS << 16) | __USER_CS;
  647. #if 0
  648. regs->eflags &= ~TF_MASK;
  649. #endif
  651. #if 0
  652. printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%xn",
  653.                current->comm, current->pid, (void *) frame, regs->cr_iip, frame->pretcode);
  654. #endif
  656. return 1;
  658. give_sigsegv:
  659. if (sig == SIGSEGV)
  660. ka->sa.sa_handler = SIG_DFL;
  661. force_sig(SIGSEGV, current);
  662. return 0;
  663. }
  665. int
  666. ia32_setup_frame1 (int sig, struct k_sigaction *ka, siginfo_t *info,
  667.    sigset_t *set, struct pt_regs *regs)
  668. {
  669.        /* Set up the stack frame */
  670.        if (ka->sa.sa_flags & SA_SIGINFO)
  671.                return setup_rt_frame_ia32(sig, ka, info, set, regs);
  672.        else
  673.                return setup_frame_ia32(sig, ka, set, regs);
  674. }
  676. asmlinkage long
  677. sys32_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
  678.  unsigned long stack)
  679. {
  680. struct pt_regs *regs = (struct pt_regs *) &stack;
  681. unsigned long esp = (unsigned int) regs->r12;
  682. struct sigframe_ia32 *frame = (struct sigframe_ia32 *)(esp - 8);
  683. sigset_t set;
  684. int eax;
  686. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  687. goto badframe;
  689. if (__get_user(set.sig[0], &frame->sc.oldmask)
  690.     || (_IA32_NSIG_WORDS > 1 && __copy_from_user((char *) &set.sig + 4, &frame->extramask,
  691.  sizeof(frame->extramask))))
  692. goto badframe;
  694. sigdelsetmask(&set, ~_BLOCKABLE);
  695. spin_lock_irq(&current->sigmask_lock);
  696. current->blocked = (sigset_t) set;
  697. recalc_sigpending(current);
  698. spin_unlock_irq(&current->sigmask_lock);
  700. if (restore_sigcontext_ia32(regs, &frame->sc, &eax))
  701. goto badframe;
  702. return eax;
  704.   badframe:
  705. force_sig(SIGSEGV, current);
  706. return 0;
  707. }
  709. asmlinkage long
  710. sys32_rt_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
  711.     unsigned long stack)
  712. {
  713. struct pt_regs *regs = (struct pt_regs *) &stack;
  714. unsigned long esp = (unsigned int) regs->r12;
  715. struct rt_sigframe_ia32 *frame = (struct rt_sigframe_ia32 *)(esp - 4);
  716. sigset_t set;
  717. stack_t st;
  718. int eax;
  720. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  721. goto badframe;
  722. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  723. goto badframe;
  725. sigdelsetmask(&set, ~_BLOCKABLE);
  726. spin_lock_irq(&current->sigmask_lock);
  727. current->blocked =  set;
  728. recalc_sigpending(current);
  729. spin_unlock_irq(&current->sigmask_lock);
  731. if (restore_sigcontext_ia32(regs, &frame->uc.uc_mcontext, &eax))
  732. goto badframe;
  734. if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
  735. goto badframe;
  736. /* It is more difficult to avoid calling this function than to
  737.    call it and ignore errors.  */
  738. do_sigaltstack(&st, NULL, esp);
  740. return eax;
  742.   badframe:
  743. force_sig(SIGSEGV, current);
  744. return 0;
  745. }