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

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

嵌入式Linux

开发平台：

Unix_Linux

irixsig.c：源码内容
  1. /*
  2.  * irixsig.c: WHEEE, IRIX signals!  YOW, am I compatable or what?!?!
  3.  *
  4.  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
  5.  * Copyright (C) 1997 - 2000 Ralf Baechle (ralf@gnu.org)
  6.  * Copyright (C) 2000 Silicon Graphics, Inc.
  7.  */
  8. #include <linux/kernel.h>
  9. #include <linux/sched.h>
  10. #include <linux/mm.h>
  11. #include <linux/errno.h>
  12. #include <linux/smp.h>
  13. #include <linux/smp_lock.h>
  14. #include <linux/time.h>
  16. #include <asm/ptrace.h>
  17. #include <asm/uaccess.h>
  19. extern asmlinkage void syscall_trace(void);
  21. #undef DEBUG_SIG
  23. #define _S(nr) (1<<((nr)-1))
  25. #define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
  27. typedef struct {
  28. unsigned long sig[4];
  29. } irix_sigset_t;
  31. struct sigctx_irix5 {
  32. u32 rmask, cp0_status;
  33. u64 pc;
  34. u64 regs[32];
  35. u64 fpregs[32];
  36. u32 usedfp, fpcsr, fpeir, sstk_flags;
  37. u64 hi, lo;
  38. u64 cp0_cause, cp0_badvaddr, _unused0;
  39. irix_sigset_t sigset;
  40. u64 weird_fpu_thing;
  41. u64 _unused1[31];
  42. };
  44. #ifdef DEBUG_SIG
  45. /* Debugging */
  46. static inline void dump_irix5_sigctx(struct sigctx_irix5 *c)
  47. {
  48. int i;
  50. printk("misc: rmask[%08lx] status[%08lx] pc[%08lx]n",
  51.        (unsigned long) c->rmask,
  52.        (unsigned long) c->cp0_status,
  53.        (unsigned long) c->pc);
  54. printk("regs: ");
  55. for(i = 0; i < 16; i++)
  56. printk("[%d]<%08lx> ", i, (unsigned long) c->regs[i]);
  57. printk("nregs: ");
  58. for(i = 16; i < 32; i++)
  59. printk("[%d]<%08lx> ", i, (unsigned long) c->regs[i]);
  60. printk("nfpregs: ");
  61. for(i = 0; i < 16; i++)
  62. printk("[%d]<%08lx> ", i, (unsigned long) c->fpregs[i]);
  63. printk("nfpregs: ");
  64. for(i = 16; i < 32; i++)
  65. printk("[%d]<%08lx> ", i, (unsigned long) c->fpregs[i]);
  66. printk("misc: usedfp[%d] fpcsr[%08lx] fpeir[%08lx] stk_flgs[%08lx]n",
  67.        (int) c->usedfp, (unsigned long) c->fpcsr,
  68.        (unsigned long) c->fpeir, (unsigned long) c->sstk_flags);
  69. printk("misc: hi[%08lx] lo[%08lx] cause[%08lx] badvaddr[%08lx]n",
  70.        (unsigned long) c->hi, (unsigned long) c->lo,
  71.        (unsigned long) c->cp0_cause, (unsigned long) c->cp0_badvaddr);
  72. printk("misc: sigset<0>[%08lx] sigset<1>[%08lx] sigset<2>[%08lx] "
  73.        "sigset<3>[%08lx]n", (unsigned long) c->sigset.sig[0],
  74.        (unsigned long) c->sigset.sig[1],
  75.        (unsigned long) c->sigset.sig[2],
  76.        (unsigned long) c->sigset.sig[3]);
  77. }
  78. #endif
  80. static void setup_irix_frame(struct k_sigaction *ka, struct pt_regs *regs,
  81.      int signr, sigset_t *oldmask)
  82. {
  83. unsigned long sp;
  84. struct sigctx_irix5 *ctx;
  85. int i;
  87. sp = regs->regs[29];
  88. sp -= sizeof(struct sigctx_irix5);
  89. sp &= ~(0xf);
  90. ctx = (struct sigctx_irix5 *) sp;
  91. if (!access_ok(VERIFY_WRITE, ctx, sizeof(*ctx)))
  92. goto segv_and_exit;
  94. __put_user(0, &ctx->weird_fpu_thing);
  95. __put_user(~(0x00000001), &ctx->rmask);
  96. __put_user(0, &ctx->regs[0]);
  97. for(i = 1; i < 32; i++)
  98. __put_user((u64) regs->regs[i], &ctx->regs[i]);
  100. __put_user((u64) regs->hi, &ctx->hi);
  101. __put_user((u64) regs->lo, &ctx->lo);
  102. __put_user((u64) regs->cp0_epc, &ctx->pc);
  103. __put_user(current->used_math, &ctx->usedfp);
  104. __put_user((u64) regs->cp0_cause, &ctx->cp0_cause);
  105. __put_user((u64) regs->cp0_badvaddr, &ctx->cp0_badvaddr);
  107. __put_user(0, &ctx->sstk_flags); /* XXX sigstack unimp... todo... */
  109. __copy_to_user(&ctx->sigset, oldmask, sizeof(irix_sigset_t));
  111. #ifdef DEBUG_SIG
  112. dump_irix5_sigctx(ctx);
  113. #endif
  115. regs->regs[4] = (unsigned long) signr;
  116. regs->regs[5] = 0; /* XXX sigcode XXX */
  117. regs->regs[6] = regs->regs[29] = sp;
  118. regs->regs[7] = (unsigned long) ka->sa.sa_handler;
  119. regs->regs[25] = regs->cp0_epc = (unsigned long) ka->sa.sa_restorer;
  120. return;
  122. segv_and_exit:
  123. if (signr == SIGSEGV)
  124. ka->sa.sa_handler = SIG_DFL;
  125. force_sig(SIGSEGV, current);
  126. }
  128. static void inline
  129. setup_irix_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
  130.                int signr, sigset_t *oldmask, siginfo_t *info)
  131. {
  132. printk("Aiee: setup_tr_frame wants to be written");
  133. do_exit(SIGSEGV);
  134. }
  136. static inline void handle_signal(unsigned long sig, struct k_sigaction *ka,
  137.         siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  138. {
  139. if (ka->sa.sa_flags & SA_SIGINFO)
  140. setup_irix_rt_frame(ka, regs, sig, oldset, info);
  141. else
  142. setup_irix_frame(ka, regs, sig, oldset);
  144. if (ka->sa.sa_flags & SA_ONESHOT)
  145. ka->sa.sa_handler = SIG_DFL;
  146. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  147. spin_lock_irq(&current->sigmask_lock);
  148. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  149. sigaddset(&current->blocked,sig);
  150. recalc_sigpending(current);
  151. spin_unlock_irq(&current->sigmask_lock);
  152. }
  153. }
  155. static inline void syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
  156. {
  157. switch(regs->regs[0]) {
  158. case ERESTARTNOHAND:
  159. regs->regs[2] = EINTR;
  160. break;
  161. case ERESTARTSYS:
  162. if(!(ka->sa.sa_flags & SA_RESTART)) {
  163. regs->regs[2] = EINTR;
  164. break;
  165. }
  166. /* fallthrough */
  167. case ERESTARTNOINTR: /* Userland will reload $v0.  */
  168. regs->cp0_epc -= 8;
  169. }
  171. regs->regs[0] = 0; /* Don't deal with this again.  */
  172. }
  174. asmlinkage int do_irix_signal(sigset_t *oldset, struct pt_regs *regs)
  175. {
  176. struct k_sigaction *ka;
  177. siginfo_t info;
  179. if (!oldset)
  180. oldset = &current->blocked;
  182. for (;;) {
  183. unsigned long signr;
  185. spin_lock_irq(&current->sigmask_lock);
  186. signr = dequeue_signal(&current->blocked, &info);
  187. spin_unlock_irq(&current->sigmask_lock);
  189. if (!signr)
  190. break;
  192. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  193. /* Let the debugger run.  */
  194. current->exit_code = signr;
  195. current->state = TASK_STOPPED;
  196. notify_parent(current, SIGCHLD);
  197. schedule();
  199. /* We're back.  Did the debugger cancel the sig?  */
  200. if (!(signr = current->exit_code))
  201. continue;
  202. current->exit_code = 0;
  204. /* The debugger continued.  Ignore SIGSTOP.  */
  205. if (signr == SIGSTOP)
  206. continue;
  208. /* Update the siginfo structure.  Is this good?  */
  209. if (signr != info.si_signo) {
  210. info.si_signo = signr;
  211. info.si_errno = 0;
  212. info.si_code = SI_USER;
  213. info.si_pid = current->p_pptr->pid;
  214. info.si_uid = current->p_pptr->uid;
  215. }
  217. /* If the (new) signal is now blocked, requeue it.  */
  218. if (sigismember(&current->blocked, signr)) {
  219. send_sig_info(signr, &info, current);
  220. continue;
  221. }
  222. }
  224. ka = &current->sig->action[signr-1];
  225. if (ka->sa.sa_handler == SIG_IGN) {
  226. if (signr != SIGCHLD)
  227. continue;
  228. /* Check for SIGCHLD: it's special.  */
  229. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  230. /* nothing */;
  231. continue;
  232. }
  234. if (ka->sa.sa_handler == SIG_DFL) {
  235. int exit_code = signr;
  237. /* Init gets no signals it doesn't want.  */
  238. if (current->pid == 1)
  239. continue;
  241. switch (signr) {
  242. case SIGCONT: case SIGCHLD: case SIGWINCH:
  243. continue;
  245. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  246. if (is_orphaned_pgrp(current->pgrp))
  247. continue;
  248. /* FALLTHRU */
  250. case SIGSTOP:
  251. current->state = TASK_STOPPED;
  252. current->exit_code = signr;
  253. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  254. notify_parent(current, SIGCHLD);
  255. schedule();
  256. continue;
  258. case SIGQUIT: case SIGILL: case SIGTRAP:
  259. case SIGABRT: case SIGFPE: case SIGSEGV:
  260. if (do_coredump(signr, regs))
  261. exit_code |= 0x80;
  262. /* FALLTHRU */
  264. default:
  265. sigaddset(&current->pending.signal, signr);
  266. recalc_sigpending(current);
  267. current->flags |= PF_SIGNALED;
  268. do_exit(exit_code);
  269. /* NOTREACHED */
  270. }
  271. }
  273. if (regs->regs[0])
  274. syscall_restart(regs, ka);
  275. /* Whee!  Actually deliver the signal.  */
  276. handle_signal(signr, ka, &info, oldset, regs);
  277. return 1;
  278. }
  280. /*
  281.  * Who's code doesn't conform to the restartable syscall convention
  282.  * dies here!!!  The li instruction, a single machine instruction,
  283.  * must directly be followed by the syscall instruction.
  284.  */
  285. if (regs->regs[0]) {
  286. if (regs->regs[2] == ERESTARTNOHAND ||
  287.     regs->regs[2] == ERESTARTSYS ||
  288.     regs->regs[2] == ERESTARTNOINTR) {
  289. regs->cp0_epc -= 8;
  290. }
  291. }
  292. return 0;
  293. }
  295. asmlinkage void
  296. irix_sigreturn(struct pt_regs *regs)
  297. {
  298. struct sigctx_irix5 *context, *magic;
  299. unsigned long umask, mask;
  300. u64 *fregs;
  301. int sig, i, base = 0;
  302. sigset_t blocked;
  304. if(regs->regs[2] == 1000)
  305. base = 1;
  307. context = (struct sigctx_irix5 *) regs->regs[base + 4];
  308. magic = (struct sigctx_irix5 *) regs->regs[base + 5];
  309. sig = (int) regs->regs[base + 6];
  310. #ifdef DEBUG_SIG
  311. printk("[%s:%d] IRIX sigreturn(scp[%p],ucp[%p],sig[%d])n",
  312.        current->comm, current->pid, context, magic, sig);
  313. #endif
  314. if (!context)
  315. context = magic;
  316. if (!access_ok(VERIFY_READ, context, sizeof(struct sigctx_irix5)))
  317. goto badframe;
  319. #ifdef DEBUG_SIG
  320. dump_irix5_sigctx(context);
  321. #endif
  323. __get_user(regs->cp0_epc, &context->pc);
  324. umask = context->rmask; mask = 2;
  325. for (i = 1; i < 32; i++, mask <<= 1) {
  326. if(umask & mask)
  327. __get_user(regs->regs[i], &context->regs[i]);
  328. }
  329. __get_user(regs->hi, &context->hi);
  330. __get_user(regs->lo, &context->lo);
  332. if ((umask & 1) && context->usedfp) {
  333. fregs = (u64 *) &current->thread.fpu;
  334. for(i = 0; i < 32; i++)
  335. fregs[i] = (u64) context->fpregs[i];
  336. __get_user(current->thread.fpu.hard.control, &context->fpcsr);
  337. }
  339. /* XXX do sigstack crapola here... XXX */
  341. if (__copy_from_user(&blocked, &context->sigset, sizeof(blocked)))
  342. goto badframe;
  344. sigdelsetmask(&blocked, ~_BLOCKABLE);
  345. spin_lock_irq(&current->sigmask_lock);
  346. current->blocked = blocked;
  347. recalc_sigpending(current);
  348. spin_unlock_irq(&current->sigmask_lock);
  350. /*
  351.  * Don't let your children do this ...
  352.  */
  353. if (current->ptrace & PT_TRACESYS)
  354. syscall_trace();
  355. __asm__ __volatile__(
  356. "movet$29,%0nt"
  357. "jtret_from_sys_call"
  358. :/* no outputs */
  359. :"r" (&regs));
  360. /* Unreached */
  362. badframe:
  363. force_sig(SIGSEGV, current);
  364. }
  366. struct sigact_irix5 {
  367. int flags;
  368. void (*handler)(int);
  369. u32 sigset[4];
  370. int _unused0[2];
  371. };
  373. #ifdef DEBUG_SIG
  374. static inline void dump_sigact_irix5(struct sigact_irix5 *p)
  375. {
  376. printk("<f[%d] hndlr[%08lx] msk[%08lx]>", p->flags,
  377.        (unsigned long) p->handler,
  378.        (unsigned long) p->sigset[0]);
  379. }
  380. #endif
  382. asmlinkage int 
  383. irix_sigaction(int sig, const struct sigaction *act,
  384.       struct sigaction *oact, void *trampoline)
  385. {
  386. struct k_sigaction new_ka, old_ka;
  387. int ret;
  389. #ifdef DEBUG_SIG
  390. printk(" (%d,%s,%s,%08lx) ", sig, (!new ? "0" : "NEW"),
  391.        (!old ? "0" : "OLD"), trampoline);
  392. if(new) {
  393. dump_sigact_irix5(new); printk(" ");
  394. }
  395. #endif
  396. if (act) {
  397. sigset_t mask;
  398. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  399.     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  400.     __get_user(new_ka.sa.sa_flags, &act->sa_flags))
  401. return -EFAULT;
  403. __copy_from_user(&mask, &act->sa_mask, sizeof(sigset_t));
  405. /*
  406.  * Hmmm... methinks IRIX libc always passes a valid trampoline
  407.  * value for all invocations of sigaction.  Will have to
  408.  * investigate.  POSIX POSIX, die die die...
  409.  */
  410. new_ka.sa.sa_restorer = trampoline;
  411. }
  413. /* XXX Implement SIG_SETMASK32 for IRIX compatibility */
  414. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  416. if (!ret && oact) {
  417. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  418.     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  419.     __put_user(old_ka.sa.sa_flags, &oact->sa_flags))
  420. return -EFAULT;
  421. __copy_to_user(&old_ka.sa.sa_mask, &oact->sa_mask,
  422.                sizeof(sigset_t));
  423. }
  425. return ret;
  426. }
  428. asmlinkage int irix_sigpending(irix_sigset_t *set)
  429. {
  430. return do_sigpending(set, sizeof(*set));
  431. }
  433. asmlinkage int irix_sigprocmask(int how, irix_sigset_t *new, irix_sigset_t *old)
  434. {
  435. sigset_t oldbits, newbits;
  436. int error;
  438. if (new) {
  439. error = verify_area(VERIFY_READ, new, sizeof(*new));
  440. if (error)
  441. return error;
  442. __copy_from_user(&newbits, new, sizeof(unsigned long)*4);
  443. sigdelsetmask(&newbits, ~_BLOCKABLE);
  445. spin_lock_irq(&current->sigmask_lock);
  446. oldbits = current->blocked;
  448. switch(how) {
  449. case 1:
  450. sigorsets(&newbits, &oldbits, &newbits);
  451. break;
  453. case 2:
  454. sigandsets(&newbits, &oldbits, &newbits);
  455. break;
  457. case 3:
  458. break;
  460. case 256:
  461. siginitset(&newbits, newbits.sig[0]);
  462. break;
  464. default:
  465. return -EINVAL;
  466. }
  467. recalc_sigpending(current);
  468. spin_unlock_irq(&current->sigmask_lock);
  469. }
  470. if(old) {
  471. error = verify_area(VERIFY_WRITE, old, sizeof(*old));
  472. if(error)
  473. return error;
  474. __copy_to_user(old, &current->blocked, sizeof(unsigned long)*4);
  475. }
  477. return 0;
  478. }
  480. asmlinkage int irix_sigsuspend(struct pt_regs *regs)
  481. {
  482. sigset_t *uset, saveset, newset;
  484. uset = (sigset_t *) regs->regs[4];
  485. if (copy_from_user(&newset, uset, sizeof(sigset_t)))
  486. return -EFAULT;
  487. sigdelsetmask(&newset, ~_BLOCKABLE);
  489. spin_lock_irq(&current->sigmask_lock);
  490. saveset = current->blocked;
  491. current->blocked = newset;
  492. recalc_sigpending(current);
  493. spin_unlock_irq(&current->sigmask_lock);
  495. regs->regs[2] = -EINTR;
  496. while (1) {
  497. current->state = TASK_INTERRUPTIBLE;
  498. schedule();
  499. if (do_irix_signal(&saveset, regs))
  500. return -EINTR;
  501. }
  502. }
  504. /* hate hate hate... */
  505. struct irix5_siginfo {
  506. int sig, code, error;
  507. union {
  508. char unused[128 - (3 * 4)]; /* Safety net. */
  509. struct {
  510. int pid;
  511. union {
  512. int uid;
  513. struct {
  514. int utime, status, stime;
  515. } child;
  516. } procdata;
  517. } procinfo;
  519. unsigned long fault_addr;
  521. struct {
  522. int fd;
  523. long band;
  524. } fileinfo;
  526. unsigned long sigval;
  527. } stuff;
  528. };
  530. static inline unsigned long timespectojiffies(struct timespec *value)
  531. {
  532. unsigned long sec = (unsigned) value->tv_sec;
  533. long nsec = value->tv_nsec;
  535. if (sec > (LONG_MAX / HZ))
  536. return LONG_MAX;
  537. nsec += 1000000000L / HZ - 1;
  538. nsec /= 1000000000L / HZ;
  539. return HZ * sec + nsec;
  540. }
  542. asmlinkage int irix_sigpoll_sys(unsigned long *set, struct irix5_siginfo *info,
  543. struct timespec *tp)
  544. {
  545. long expire = MAX_SCHEDULE_TIMEOUT;
  546. sigset_t kset;
  547. int i, sig, error, timeo = 0;
  549. #ifdef DEBUG_SIG
  550. printk("[%s:%d] irix_sigpoll_sys(%p,%p,%p)n",
  551.        current->comm, current->pid, set, info, tp);
  552. #endif
  554. /* Must always specify the signal set. */
  555. if(!set)
  556. return -EINVAL;
  558. error = verify_area(VERIFY_READ, set, sizeof(kset));
  559. if (error)
  560. goto out;
  562. __copy_from_user(&kset, set, sizeof(set));
  563. if (error)
  564. goto out;
  566. if (info && clear_user(info, sizeof(*info))) {
  567. error = -EFAULT;
  568. goto out;
  569. }
  571. if(tp) {
  572. error = verify_area(VERIFY_READ, tp, sizeof(*tp));
  573. if(error)
  574. return error;
  575. if(!tp->tv_sec && !tp->tv_nsec) {
  576. error = -EINVAL;
  577. goto out;
  578. }
  579. expire = timespectojiffies(tp)+(tp->tv_sec||tp->tv_nsec);
  580. }
  582. while(1) {
  583. long tmp = 0;
  585. current->state = TASK_INTERRUPTIBLE;
  586. expire = schedule_timeout(expire);
  588. for (i=0; i<=4; i++)
  589. tmp |= (current->pending.signal.sig[i] & kset.sig[i]);
  591. if (tmp)
  592. break;
  593. if (!expire) {
  594. timeo = 1;
  595. break;
  596. }
  597. if (signal_pending(current))
  598. return -EINTR;
  599. }
  600. if (timeo)
  601. return -EAGAIN;
  603. for(sig = 1; i <= 65 /* IRIX_NSIG */; sig++) {
  604. if (sigismember (&kset, sig))
  605. continue;
  606. if (sigismember (&current->pending.signal, sig)) {
  607. /* XXX need more than this... */
  608. if (info)
  609. info->sig = sig;
  610. error = 0;
  611. goto out;
  612. }
  613. }
  615. /* Should not get here, but do something sane if we do. */
  616. error = -EINTR;
  618. out:
  619. return error;
  620. }
  622. /* This is here because of irix5_siginfo definition. */
  623. #define P_PID    0
  624. #define P_PGID   2
  625. #define P_ALL    7
  627. extern int getrusage(struct task_struct *, int, struct rusage *);
  629. #define W_EXITED     1
  630. #define W_TRAPPED    2
  631. #define W_STOPPED    4
  632. #define W_CONT       8
  633. #define W_NOHANG    64
  635. #define W_MASK      (W_EXITED | W_TRAPPED | W_STOPPED | W_CONT | W_NOHANG)
  637. asmlinkage int irix_waitsys(int type, int pid, struct irix5_siginfo *info,
  638.     int options, struct rusage *ru)
  639. {
  640. int flag, retval;
  641. DECLARE_WAITQUEUE(wait, current);
  642. struct task_struct *p;
  644. if (!info) {
  645. retval = -EINVAL;
  646. goto out;
  647. }
  648. retval = verify_area(VERIFY_WRITE, info, sizeof(*info));
  649. if(retval)
  650. goto out;
  651. if (ru) {
  652. retval = verify_area(VERIFY_WRITE, ru, sizeof(*ru));
  653. if(retval)
  654. goto out;
  655. }
  656. if (options & ~(W_MASK)) {
  657. retval = -EINVAL;
  658. goto out;
  659. }
  660. if (type != P_PID && type != P_PGID && type != P_ALL) {
  661. retval = -EINVAL;
  662. goto out;
  663. }
  664. add_wait_queue(&current->wait_chldexit, &wait);
  665. repeat:
  666. flag = 0;
  667. current->state = TASK_INTERRUPTIBLE;
  668. read_lock(&tasklist_lock);
  669. for (p = current->p_cptr; p; p = p->p_osptr) {
  670. if ((type == P_PID) && p->pid != pid)
  671. continue;
  672. if ((type == P_PGID) && p->pgrp != pid)
  673. continue;
  674. if ((p->exit_signal != SIGCHLD))
  675. continue;
  676. flag = 1;
  677. switch (p->state) {
  678. case TASK_STOPPED:
  679. if (!p->exit_code)
  680. continue;
  681. if (!(options & (W_TRAPPED|W_STOPPED)) &&
  682.     !(p->ptrace & PT_PTRACED))
  683. continue;
  684. if (ru != NULL)
  685. getrusage(p, RUSAGE_BOTH, ru);
  686. __put_user(SIGCHLD, &info->sig);
  687. __put_user(0, &info->code);
  688. __put_user(p->pid, &info->stuff.procinfo.pid);
  689. __put_user((p->exit_code >> 8) & 0xff,
  690.            &info->stuff.procinfo.procdata.child.status);
  691. __put_user(p->times.tms_utime, &info->stuff.procinfo.procdata.child.utime);
  692. __put_user(p->times.tms_stime, &info->stuff.procinfo.procdata.child.stime);
  693. p->exit_code = 0;
  694. retval = 0;
  695. goto end_waitsys;
  696. case TASK_ZOMBIE:
  697. current->times.tms_cutime += p->times.tms_utime + p->times.tms_cutime;
  698. current->times.tms_cstime += p->times.tms_stime + p->times.tms_cstime;
  699. if (ru != NULL)
  700. getrusage(p, RUSAGE_BOTH, ru);
  701. __put_user(SIGCHLD, &info->sig);
  702. __put_user(1, &info->code);      /* CLD_EXITED */
  703. __put_user(p->pid, &info->stuff.procinfo.pid);
  704. __put_user((p->exit_code >> 8) & 0xff,
  705.            &info->stuff.procinfo.procdata.child.status);
  706. __put_user(p->times.tms_utime,
  707.            &info->stuff.procinfo.procdata.child.utime);
  708. __put_user(p->times.tms_stime,
  709.            &info->stuff.procinfo.procdata.child.stime);
  710. retval = 0;
  711. if (p->p_opptr != p->p_pptr) {
  712. REMOVE_LINKS(p);
  713. p->p_pptr = p->p_opptr;
  714. SET_LINKS(p);
  715. notify_parent(p, SIGCHLD);
  716. } else
  717. release_task(p);
  718. goto end_waitsys;
  719. default:
  720. continue;
  721. }
  722. }
  723. read_unlock(&tasklist_lock);
  724. if (flag) {
  725. retval = 0;
  726. if (options & W_NOHANG)
  727. goto end_waitsys;
  728. retval = -ERESTARTSYS;
  729. if (signal_pending(current))
  730. goto end_waitsys;
  731. current->state = TASK_INTERRUPTIBLE;
  732. schedule();
  733. goto repeat;
  734. }
  735. retval = -ECHILD;
  736. end_waitsys:
  737. current->state = TASK_RUNNING;
  738. remove_wait_queue(&current->wait_chldexit, &wait);
  740. out:
  741. return retval;
  742. }
  744. struct irix5_context {
  745. u32 flags;
  746. u32 link;
  747. u32 sigmask[4];
  748. struct { u32 sp, size, flags; } stack;
  749. int regs[36];
  750. u32 fpregs[32];
  751. u32 fpcsr;
  752. u32 _unused0;
  753. u32 _unused1[47];
  754. u32 weird_graphics_thing;
  755. };
  757. asmlinkage int irix_getcontext(struct pt_regs *regs)
  758. {
  759. int error, i, base = 0;
  760. struct irix5_context *ctx;
  761. unsigned long flags;
  763. if (regs->regs[2] == 1000)
  764. base = 1;
  765. ctx = (struct irix5_context *) regs->regs[base + 4];
  767. #ifdef DEBUG_SIG
  768. printk("[%s:%d] irix_getcontext(%p)n",
  769.        current->comm, current->pid, ctx);
  770. #endif
  772. error = verify_area(VERIFY_WRITE, ctx, sizeof(*ctx));
  773. if(error)
  774. goto out;
  775. __put_user(current->thread.irix_oldctx, &ctx->link);
  777. __copy_to_user(&ctx->sigmask, &current->blocked, sizeof(irix_sigset_t));
  779. /* XXX Do sigstack stuff someday... */
  780. __put_user(0, &ctx->stack.sp);
  781. __put_user(0, &ctx->stack.size);
  782. __put_user(0, &ctx->stack.flags);
  784. __put_user(0, &ctx->weird_graphics_thing);
  785. __put_user(0, &ctx->regs[0]);
  786. for (i = 1; i < 32; i++)
  787. __put_user(regs->regs[i], &ctx->regs[i]);
  788. __put_user(regs->lo, &ctx->regs[32]);
  789. __put_user(regs->hi, &ctx->regs[33]);
  790. __put_user(regs->cp0_cause, &ctx->regs[34]);
  791. __put_user(regs->cp0_epc, &ctx->regs[35]);
  793. flags = 0x0f;
  794. if(!current->used_math) {
  795. flags &= ~(0x08);
  796. } else {
  797. /* XXX wheee... */
  798. printk("Wheee, no code for saving IRIX FPU context yet.n");
  799. }
  800. __put_user(flags, &ctx->flags);
  801. error = 0;
  803. out:
  804. return error;
  805. }
  807. asmlinkage unsigned long irix_setcontext(struct pt_regs *regs)
  808. {
  809. int error, base = 0;
  810. struct irix5_context *ctx;
  812. if(regs->regs[2] == 1000)
  813. base = 1;
  814. ctx = (struct irix5_context *) regs->regs[base + 4];
  816. #ifdef DEBUG_SIG
  817. printk("[%s:%d] irix_setcontext(%p)n",
  818.        current->comm, current->pid, ctx);
  819. #endif
  821. error = verify_area(VERIFY_READ, ctx, sizeof(*ctx));
  822. if (error)
  823. goto out;
  825. if (ctx->flags & 0x02) {
  826. /* XXX sigstack garbage, todo... */
  827. printk("Wheee, cannot do sigstack stuff in setcontextn");
  828. }
  830. if (ctx->flags & 0x04) {
  831. int i;
  833. /* XXX extra control block stuff... todo... */
  834. for(i = 1; i < 32; i++)
  835. regs->regs[i] = ctx->regs[i];
  836. regs->lo = ctx->regs[32];
  837. regs->hi = ctx->regs[33];
  838. regs->cp0_epc = ctx->regs[35];
  839. }
  841. if (ctx->flags & 0x08) {
  842. /* XXX fpu context, blah... */
  843. printk("Wheee, cannot restore FPU context yet...n");
  844. }
  845. current->thread.irix_oldctx = ctx->link;
  846. error = regs->regs[2];
  848. out:
  849. return error;
  850. }
  852. struct irix_sigstack { unsigned long sp; int status; };
  854. asmlinkage int irix_sigstack(struct irix_sigstack *new, struct irix_sigstack *old)
  855. {
  856. int error;
  858. #ifdef DEBUG_SIG
  859. printk("[%s:%d] irix_sigstack(%p,%p)n",
  860.        current->comm, current->pid, new, old);
  861. #endif
  862. if(new) {
  863. error = verify_area(VERIFY_READ, new, sizeof(*new));
  864. if(error)
  865. goto out;
  866. }
  868. if(old) {
  869. error = verify_area(VERIFY_WRITE, old, sizeof(*old));
  870. if(error)
  871. goto out;
  872. }
  873. error = 0;
  875. out:
  876. return error;
  877. }
  879. struct irix_sigaltstack { unsigned long sp; int size; int status; };
  881. asmlinkage int irix_sigaltstack(struct irix_sigaltstack *new,
  882. struct irix_sigaltstack *old)
  883. {
  884. int error;
  886. #ifdef DEBUG_SIG
  887. printk("[%s:%d] irix_sigaltstack(%p,%p)n",
  888.        current->comm, current->pid, new, old);
  889. #endif
  890. if (new) {
  891. error = verify_area(VERIFY_READ, new, sizeof(*new));
  892. if(error)
  893. goto out;
  894. }
  896. if (old) {
  897. error = verify_area(VERIFY_WRITE, old, sizeof(*old));
  898. if(error)
  899. goto out;
  900. }
  901. error = 0;
  903. out:
  904. error = 0;
  906. return error;
  907. }
  909. struct irix_procset {
  910. int cmd, ltype, lid, rtype, rid;
  911. };
  913. asmlinkage int irix_sigsendset(struct irix_procset *pset, int sig)
  914. {
  915. int error;
  917. error = verify_area(VERIFY_READ, pset, sizeof(*pset));
  918. if(error)
  919. goto out;
  920. #ifdef DEBUG_SIG
  921. printk("[%s:%d] irix_sigsendset([%d,%d,%d,%d,%d],%d)n",
  922.        current->comm, current->pid,
  923.        pset->cmd, pset->ltype, pset->lid, pset->rtype, pset->rid,
  924.        sig);
  925. #endif
  926. error = -EINVAL;
  928. out:
  929. return error;
  930. }