]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - arch/mips/kernel/irixsig.c
33506ff25910f4d8f8974c7a0d9b2098649e8681
[linux-3.10.git] / arch / mips / kernel / irixsig.c
1 /*
2  * irixsig.c: WHEEE, IRIX signals!  YOW, am I compatible 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/time.h>
14 #include <linux/ptrace.h>
15 #include <linux/resource.h>
16
17 #include <asm/ptrace.h>
18 #include <asm/uaccess.h>
19 #include <asm/unistd.h>
20
21 #undef DEBUG_SIG
22
23 #define _S(nr) (1<<((nr)-1))
24
25 #define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
26
27 #define _IRIX_NSIG              128
28 #define _IRIX_NSIG_BPW          BITS_PER_LONG
29 #define _IRIX_NSIG_WORDS        (_IRIX_NSIG / _IRIX_NSIG_BPW)
30
31 typedef struct {
32         unsigned long sig[_IRIX_NSIG_WORDS];
33 } irix_sigset_t;
34
35 struct sigctx_irix5 {
36         u32 rmask, cp0_status;
37         u64 pc;
38         u64 regs[32];
39         u64 fpregs[32];
40         u32 usedfp, fpcsr, fpeir, sstk_flags;
41         u64 hi, lo;
42         u64 cp0_cause, cp0_badvaddr, _unused0;
43         irix_sigset_t sigset;
44         u64 weird_fpu_thing;
45         u64 _unused1[31];
46 };
47
48 #ifdef DEBUG_SIG
49 /* Debugging */
50 static inline void dump_irix5_sigctx(struct sigctx_irix5 *c)
51 {
52         int i;
53
54         printk("misc: rmask[%08lx] status[%08lx] pc[%08lx]\n",
55                (unsigned long) c->rmask,
56                (unsigned long) c->cp0_status,
57                (unsigned long) c->pc);
58         printk("regs: ");
59         for(i = 0; i < 16; i++)
60                 printk("[%d]<%08lx> ", i, (unsigned long) c->regs[i]);
61         printk("\nregs: ");
62         for(i = 16; i < 32; i++)
63                 printk("[%d]<%08lx> ", i, (unsigned long) c->regs[i]);
64         printk("\nfpregs: ");
65         for(i = 0; i < 16; i++)
66                 printk("[%d]<%08lx> ", i, (unsigned long) c->fpregs[i]);
67         printk("\nfpregs: ");
68         for(i = 16; i < 32; i++)
69                 printk("[%d]<%08lx> ", i, (unsigned long) c->fpregs[i]);
70         printk("misc: usedfp[%d] fpcsr[%08lx] fpeir[%08lx] stk_flgs[%08lx]\n",
71                (int) c->usedfp, (unsigned long) c->fpcsr,
72                (unsigned long) c->fpeir, (unsigned long) c->sstk_flags);
73         printk("misc: hi[%08lx] lo[%08lx] cause[%08lx] badvaddr[%08lx]\n",
74                (unsigned long) c->hi, (unsigned long) c->lo,
75                (unsigned long) c->cp0_cause, (unsigned long) c->cp0_badvaddr);
76         printk("misc: sigset<0>[%08lx] sigset<1>[%08lx] sigset<2>[%08lx] "
77                "sigset<3>[%08lx]\n", (unsigned long) c->sigset.sig[0],
78                (unsigned long) c->sigset.sig[1],
79                (unsigned long) c->sigset.sig[2],
80                (unsigned long) c->sigset.sig[3]);
81 }
82 #endif
83
84 static int setup_irix_frame(struct k_sigaction *ka, struct pt_regs *regs,
85                             int signr, sigset_t *oldmask)
86 {
87         struct sigctx_irix5 __user *ctx;
88         unsigned long sp;
89         int error, i;
90
91         sp = regs->regs[29];
92         sp -= sizeof(struct sigctx_irix5);
93         sp &= ~(0xf);
94         ctx = (struct sigctx_irix5 __user *) sp;
95         if (!access_ok(VERIFY_WRITE, ctx, sizeof(*ctx)))
96                 goto segv_and_exit;
97
98         error = __put_user(0, &ctx->weird_fpu_thing);
99         error |= __put_user(~(0x00000001), &ctx->rmask);
100         error |= __put_user(0, &ctx->regs[0]);
101         for(i = 1; i < 32; i++)
102                 error |= __put_user((u64) regs->regs[i], &ctx->regs[i]);
103
104         error |= __put_user((u64) regs->hi, &ctx->hi);
105         error |= __put_user((u64) regs->lo, &ctx->lo);
106         error |= __put_user((u64) regs->cp0_epc, &ctx->pc);
107         error |= __put_user(!!used_math(), &ctx->usedfp);
108         error |= __put_user((u64) regs->cp0_cause, &ctx->cp0_cause);
109         error |= __put_user((u64) regs->cp0_badvaddr, &ctx->cp0_badvaddr);
110
111         error |= __put_user(0, &ctx->sstk_flags); /* XXX sigstack unimp... todo... */
112
113         error |= __copy_to_user(&ctx->sigset, oldmask, sizeof(irix_sigset_t)) ? -EFAULT : 0;
114
115         if (error)
116                 goto segv_and_exit;
117
118 #ifdef DEBUG_SIG
119         dump_irix5_sigctx(ctx);
120 #endif
121
122         regs->regs[4] = (unsigned long) signr;
123         regs->regs[5] = 0; /* XXX sigcode XXX */
124         regs->regs[6] = regs->regs[29] = sp;
125         regs->regs[7] = (unsigned long) ka->sa.sa_handler;
126         regs->regs[25] = regs->cp0_epc = (unsigned long) ka->sa_restorer;
127
128         return 1;
129
130 segv_and_exit:
131         force_sigsegv(signr, current);
132         return 0;
133 }
134
135 static int inline
136 setup_irix_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
137                int signr, sigset_t *oldmask, siginfo_t *info)
138 {
139         printk("Aiee: setup_tr_frame wants to be written");
140         do_exit(SIGSEGV);
141 }
142
143 static inline int handle_signal(unsigned long sig, siginfo_t *info,
144         struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
145 {
146         int ret;
147
148         switch(regs->regs[0]) {
149         case ERESTARTNOHAND:
150                 regs->regs[2] = EINTR;
151                 break;
152         case ERESTARTSYS:
153                 if(!(ka->sa.sa_flags & SA_RESTART)) {
154                         regs->regs[2] = EINTR;
155                         break;
156                 }
157         /* fallthrough */
158         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
159                 regs->cp0_epc -= 8;
160         }
161
162         regs->regs[0] = 0;              /* Don't deal with this again.  */
163
164         if (ka->sa.sa_flags & SA_SIGINFO)
165                 ret = setup_irix_rt_frame(ka, regs, sig, oldset, info);
166         else
167                 ret = setup_irix_frame(ka, regs, sig, oldset);
168
169         spin_lock_irq(&current->sighand->siglock);
170         sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
171         if (!(ka->sa.sa_flags & SA_NODEFER))
172                 sigaddset(&current->blocked, sig);
173         recalc_sigpending();
174         spin_unlock_irq(&current->sighand->siglock);
175
176         return ret;
177 }
178
179 void do_irix_signal(struct pt_regs *regs)
180 {
181         struct k_sigaction ka;
182         siginfo_t info;
183         int signr;
184         sigset_t *oldset;
185
186         /*
187          * We want the common case to go fast, which is why we may in certain
188          * cases get here from kernel mode. Just return without doing anything
189          * if so.
190          */
191         if (!user_mode(regs))
192                 return;
193
194         if (test_thread_flag(TIF_RESTORE_SIGMASK))
195                 oldset = &current->saved_sigmask;
196         else
197                 oldset = &current->blocked;
198
199         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
200         if (signr > 0) {
201                 /* Whee!  Actually deliver the signal.  */
202                 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
203                         /* a signal was successfully delivered; the saved
204                          * sigmask will have been stored in the signal frame,
205                          * and will be restored by sigreturn, so we can simply
206                          * clear the TIF_RESTORE_SIGMASK flag */
207                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
208                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
209                 }
210
211                 return;
212         }
213
214         /*
215          * Who's code doesn't conform to the restartable syscall convention
216          * dies here!!!  The li instruction, a single machine instruction,
217          * must directly be followed by the syscall instruction.
218          */
219         if (regs->regs[0]) {
220                 if (regs->regs[2] == ERESTARTNOHAND ||
221                     regs->regs[2] == ERESTARTSYS ||
222                     regs->regs[2] == ERESTARTNOINTR) {
223                         regs->cp0_epc -= 8;
224                 }
225                 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
226                         regs->regs[2] = __NR_restart_syscall;
227                         regs->regs[7] = regs->regs[26];
228                         regs->cp0_epc -= 4;
229                 }
230                 regs->regs[0] = 0;      /* Don't deal with this again.  */
231         }
232
233         /*
234         * If there's no signal to deliver, we just put the saved sigmask
235         * back
236         */
237         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
238                 clear_thread_flag(TIF_RESTORE_SIGMASK);
239                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
240         }
241 }
242
243 asmlinkage void
244 irix_sigreturn(struct pt_regs *regs)
245 {
246         struct sigctx_irix5 __user *context, *magic;
247         unsigned long umask, mask;
248         u64 *fregs;
249         u32 usedfp;
250         int error, sig, i, base = 0;
251         sigset_t blocked;
252
253         /* Always make any pending restarted system calls return -EINTR */
254         current_thread_info()->restart_block.fn = do_no_restart_syscall;
255
256         if (regs->regs[2] == 1000)
257                 base = 1;
258
259         context = (struct sigctx_irix5 __user *) regs->regs[base + 4];
260         magic = (struct sigctx_irix5 __user *) regs->regs[base + 5];
261         sig = (int) regs->regs[base + 6];
262 #ifdef DEBUG_SIG
263         printk("[%s:%d] IRIX sigreturn(scp[%p],ucp[%p],sig[%d])\n",
264                current->comm, current->pid, context, magic, sig);
265 #endif
266         if (!context)
267                 context = magic;
268         if (!access_ok(VERIFY_READ, context, sizeof(struct sigctx_irix5)))
269                 goto badframe;
270
271 #ifdef DEBUG_SIG
272         dump_irix5_sigctx(context);
273 #endif
274
275         error = __get_user(regs->cp0_epc, &context->pc);
276         error |= __get_user(umask, &context->rmask);
277
278         mask = 2;
279         for (i = 1; i < 32; i++, mask <<= 1) {
280                 if (umask & mask)
281                         error |= __get_user(regs->regs[i], &context->regs[i]);
282         }
283         error |= __get_user(regs->hi, &context->hi);
284         error |= __get_user(regs->lo, &context->lo);
285
286         error |= __get_user(usedfp, &context->usedfp);
287         if ((umask & 1) && usedfp) {
288                 fregs = (u64 *) &current->thread.fpu;
289
290                 for(i = 0; i < 32; i++)
291                         error |= __get_user(fregs[i], &context->fpregs[i]);
292                 error |= __get_user(current->thread.fpu.fcr31, &context->fpcsr);
293         }
294
295         /* XXX do sigstack crapola here... XXX */
296
297         error |= __copy_from_user(&blocked, &context->sigset, sizeof(blocked)) ? -EFAULT : 0;
298
299         if (error)
300                 goto badframe;
301
302         sigdelsetmask(&blocked, ~_BLOCKABLE);
303         spin_lock_irq(&current->sighand->siglock);
304         current->blocked = blocked;
305         recalc_sigpending();
306         spin_unlock_irq(&current->sighand->siglock);
307
308         /*
309          * Don't let your children do this ...
310          */
311         __asm__ __volatile__(
312                 "move\t$29,%0\n\t"
313                 "j\tsyscall_exit"
314                 :/* no outputs */
315                 :"r" (&regs));
316                 /* Unreached */
317
318 badframe:
319         force_sig(SIGSEGV, current);
320 }
321
322 struct sigact_irix5 {
323         int flags;
324         void (*handler)(int);
325         u32 sigset[4];
326         int _unused0[2];
327 };
328
329 #define SIG_SETMASK32   256     /* Goodie from SGI for BSD compatibility:
330                                    set only the low 32 bit of the sigset.  */
331
332 #ifdef DEBUG_SIG
333 static inline void dump_sigact_irix5(struct sigact_irix5 *p)
334 {
335         printk("<f[%d] hndlr[%08lx] msk[%08lx]>", p->flags,
336                (unsigned long) p->handler,
337                (unsigned long) p->sigset[0]);
338 }
339 #endif
340
341 asmlinkage int
342 irix_sigaction(int sig, const struct sigaction __user *act,
343               struct sigaction __user *oact, void __user *trampoline)
344 {
345         struct k_sigaction new_ka, old_ka;
346         int ret;
347
348 #ifdef DEBUG_SIG
349         printk(" (%d,%s,%s,%08lx) ", sig, (!new ? "0" : "NEW"),
350                (!old ? "0" : "OLD"), trampoline);
351         if(new) {
352                 dump_sigact_irix5(new); printk(" ");
353         }
354 #endif
355         if (act) {
356                 sigset_t mask;
357                 int err;
358
359                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
360                         return -EFAULT;
361                 err = __get_user(new_ka.sa.sa_handler, &act->sa_handler);
362                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
363
364                 err |= __copy_from_user(&mask, &act->sa_mask, sizeof(sigset_t)) ? -EFAULT : 0;
365                 if (err)
366                         return err;
367
368                 /*
369                  * Hmmm... methinks IRIX libc always passes a valid trampoline
370                  * value for all invocations of sigaction.  Will have to
371                  * investigate.  POSIX POSIX, die die die...
372                  */
373                 new_ka.sa_restorer = trampoline;
374         }
375
376 /* XXX Implement SIG_SETMASK32 for IRIX compatibility */
377         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
378
379         if (!ret && oact) {
380                 int err;
381
382                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
383                         return -EFAULT;
384
385                 err = __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
386                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
387                 err |= __copy_to_user(&oact->sa_mask, &old_ka.sa.sa_mask,
388                                sizeof(sigset_t)) ? -EFAULT : 0;
389                 if (err)
390                         return -EFAULT;
391         }
392
393         return ret;
394 }
395
396 asmlinkage int irix_sigpending(irix_sigset_t __user *set)
397 {
398         return do_sigpending(set, sizeof(*set));
399 }
400
401 asmlinkage int irix_sigprocmask(int how, irix_sigset_t __user *new,
402         irix_sigset_t __user *old)
403 {
404         sigset_t oldbits, newbits;
405
406         if (new) {
407                 if (!access_ok(VERIFY_READ, new, sizeof(*new)))
408                         return -EFAULT;
409                 if (__copy_from_user(&newbits, new, sizeof(unsigned long)*4))
410                         return -EFAULT;
411                 sigdelsetmask(&newbits, ~_BLOCKABLE);
412
413                 spin_lock_irq(&current->sighand->siglock);
414                 oldbits = current->blocked;
415
416                 switch(how) {
417                 case 1:
418                         sigorsets(&newbits, &oldbits, &newbits);
419                         break;
420
421                 case 2:
422                         sigandsets(&newbits, &oldbits, &newbits);
423                         break;
424
425                 case 3:
426                         break;
427
428                 case 256:
429                         siginitset(&newbits, newbits.sig[0]);
430                         break;
431
432                 default:
433                         return -EINVAL;
434                 }
435                 recalc_sigpending();
436                 spin_unlock_irq(&current->sighand->siglock);
437         }
438         if (old)
439                 return copy_to_user(old, &current->blocked,
440                                   sizeof(unsigned long)*4) ? -EFAULT : 0;
441
442         return 0;
443 }
444
445 asmlinkage int irix_sigsuspend(struct pt_regs *regs)
446 {
447         sigset_t newset;
448         sigset_t __user *uset;
449
450         uset = (sigset_t __user *) regs->regs[4];
451         if (copy_from_user(&newset, uset, sizeof(sigset_t)))
452                 return -EFAULT;
453         sigdelsetmask(&newset, ~_BLOCKABLE);
454
455         spin_lock_irq(&current->sighand->siglock);
456         current->saved_sigmask = current->blocked;
457         current->blocked = newset;
458         recalc_sigpending();
459         spin_unlock_irq(&current->sighand->siglock);
460
461         current->state = TASK_INTERRUPTIBLE;
462         schedule();
463         set_thread_flag(TIF_RESTORE_SIGMASK);
464         return -ERESTARTNOHAND;
465 }
466
467 /* hate hate hate... */
468 struct irix5_siginfo {
469         int sig, code, error;
470         union {
471                 char unused[128 - (3 * 4)]; /* Safety net. */
472                 struct {
473                         int pid;
474                         union {
475                                 int uid;
476                                 struct {
477                                         int utime, status, stime;
478                                 } child;
479                         } procdata;
480                 } procinfo;
481
482                 unsigned long fault_addr;
483
484                 struct {
485                         int fd;
486                         long band;
487                 } fileinfo;
488
489                 unsigned long sigval;
490         } stuff;
491 };
492
493 asmlinkage int irix_sigpoll_sys(unsigned long __user *set,
494         struct irix5_siginfo __user *info, struct timespec __user *tp)
495 {
496         long expire = MAX_SCHEDULE_TIMEOUT;
497         sigset_t kset;
498         int i, sig, error, timeo = 0;
499         struct timespec ktp;
500
501 #ifdef DEBUG_SIG
502         printk("[%s:%d] irix_sigpoll_sys(%p,%p,%p)\n",
503                current->comm, current->pid, set, info, tp);
504 #endif
505
506         /* Must always specify the signal set. */
507         if (!set)
508                 return -EINVAL;
509
510         if (copy_from_user(&kset, set, sizeof(set)))
511                 return -EFAULT;
512
513         if (info && clear_user(info, sizeof(*info))) {
514                 error = -EFAULT;
515                 goto out;
516         }
517
518         if (tp) {
519                 if (copy_from_user(&ktp, tp, sizeof(*tp)))
520                         return -EFAULT;
521
522                 if (!ktp.tv_sec && !ktp.tv_nsec)
523                         return -EINVAL;
524
525                 expire = timespec_to_jiffies(&ktp) +
526                          (ktp.tv_sec || ktp.tv_nsec);
527         }
528
529         while(1) {
530                 long tmp = 0;
531
532                 expire = schedule_timeout_interruptible(expire);
533
534                 for (i=0; i < _IRIX_NSIG_WORDS; i++)
535                         tmp |= (current->pending.signal.sig[i] & kset.sig[i]);
536
537                 if (tmp)
538                         break;
539                 if (!expire) {
540                         timeo = 1;
541                         break;
542                 }
543                 if (signal_pending(current))
544                         return -EINTR;
545         }
546         if (timeo)
547                 return -EAGAIN;
548
549         for (sig = 1; i <= 65 /* IRIX_NSIG */; sig++) {
550                 if (sigismember (&kset, sig))
551                         continue;
552                 if (sigismember (&current->pending.signal, sig)) {
553                         /* XXX need more than this... */
554                         if (info)
555                                 return copy_to_user(&info->sig, &sig, sizeof(sig));
556                         return 0;
557                 }
558         }
559
560         /* Should not get here, but do something sane if we do. */
561         error = -EINTR;
562
563 out:
564         return error;
565 }
566
567 /* This is here because of irix5_siginfo definition. */
568 #define IRIX_P_PID    0
569 #define IRIX_P_PGID   2
570 #define IRIX_P_ALL    7
571
572 #define W_EXITED     1
573 #define W_TRAPPED    2
574 #define W_STOPPED    4
575 #define W_CONT       8
576 #define W_NOHANG    64
577
578 #define W_MASK      (W_EXITED | W_TRAPPED | W_STOPPED | W_CONT | W_NOHANG)
579
580 asmlinkage int irix_waitsys(int type, int pid,
581         struct irix5_siginfo __user *info, int options,
582         struct rusage __user *ru)
583 {
584         int flag, retval;
585         DECLARE_WAITQUEUE(wait, current);
586         struct task_struct *tsk;
587         struct task_struct *p;
588         struct list_head *_p;
589
590         if (!info)
591                 return -EINVAL;
592
593         if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
594                 return -EFAULT;
595
596         if (ru)
597                 if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)))
598                         return -EFAULT;
599
600         if (options & ~W_MASK)
601                 return -EINVAL;
602
603         if (type != IRIX_P_PID && type != IRIX_P_PGID && type != IRIX_P_ALL)
604                 return -EINVAL;
605
606         add_wait_queue(&current->signal->wait_chldexit, &wait);
607 repeat:
608         flag = 0;
609         current->state = TASK_INTERRUPTIBLE;
610         read_lock(&tasklist_lock);
611         tsk = current;
612         list_for_each(_p, &tsk->children) {
613                 p = list_entry(_p, struct task_struct, sibling);
614                 if ((type == IRIX_P_PID) && p->pid != pid)
615                         continue;
616                 if ((type == IRIX_P_PGID) && task_pgrp_nr(p) != pid)
617                         continue;
618                 if ((p->exit_signal != SIGCHLD))
619                         continue;
620                 flag = 1;
621                 switch (p->state) {
622                 case TASK_STOPPED:
623                         if (!p->exit_code)
624                                 continue;
625                         if (!(options & (W_TRAPPED|W_STOPPED)) &&
626                             !(p->ptrace & PT_PTRACED))
627                                 continue;
628                         read_unlock(&tasklist_lock);
629
630                         /* move to end of parent's list to avoid starvation */
631                         write_lock_irq(&tasklist_lock);
632                         remove_parent(p);
633                         add_parent(p);
634                         write_unlock_irq(&tasklist_lock);
635                         retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
636                         if (retval)
637                                 goto end_waitsys;
638
639                         retval = __put_user(SIGCHLD, &info->sig);
640                         retval |= __put_user(0, &info->code);
641                         retval |= __put_user(p->pid, &info->stuff.procinfo.pid);
642                         retval |= __put_user((p->exit_code >> 8) & 0xff,
643                                    &info->stuff.procinfo.procdata.child.status);
644                         retval |= __put_user(p->utime, &info->stuff.procinfo.procdata.child.utime);
645                         retval |= __put_user(p->stime, &info->stuff.procinfo.procdata.child.stime);
646                         if (retval)
647                                 goto end_waitsys;
648
649                         p->exit_code = 0;
650                         goto end_waitsys;
651
652                 case EXIT_ZOMBIE:
653                         current->signal->cutime += p->utime + p->signal->cutime;
654                         current->signal->cstime += p->stime + p->signal->cstime;
655                         if (ru != NULL)
656                                 getrusage(p, RUSAGE_BOTH, ru);
657                         retval = __put_user(SIGCHLD, &info->sig);
658                         retval |= __put_user(1, &info->code);      /* CLD_EXITED */
659                         retval |= __put_user(p->pid, &info->stuff.procinfo.pid);
660                         retval |= __put_user((p->exit_code >> 8) & 0xff,
661                                    &info->stuff.procinfo.procdata.child.status);
662                         retval |= __put_user(p->utime,
663                                    &info->stuff.procinfo.procdata.child.utime);
664                         retval |= __put_user(p->stime,
665                                    &info->stuff.procinfo.procdata.child.stime);
666                         if (retval)
667                                 return retval;
668
669                         if (p->real_parent != p->parent) {
670                                 write_lock_irq(&tasklist_lock);
671                                 remove_parent(p);
672                                 p->parent = p->real_parent;
673                                 add_parent(p);
674                                 do_notify_parent(p, SIGCHLD);
675                                 write_unlock_irq(&tasklist_lock);
676                         } else
677                                 release_task(p);
678                         goto end_waitsys;
679                 default:
680                         continue;
681                 }
682                 tsk = next_thread(tsk);
683         }
684         read_unlock(&tasklist_lock);
685         if (flag) {
686                 retval = 0;
687                 if (options & W_NOHANG)
688                         goto end_waitsys;
689                 retval = -ERESTARTSYS;
690                 if (signal_pending(current))
691                         goto end_waitsys;
692                 current->state = TASK_INTERRUPTIBLE;
693                 schedule();
694                 goto repeat;
695         }
696         retval = -ECHILD;
697 end_waitsys:
698         current->state = TASK_RUNNING;
699         remove_wait_queue(&current->signal->wait_chldexit, &wait);
700
701         return retval;
702 }
703
704 struct irix5_context {
705         u32 flags;
706         u32 link;
707         u32 sigmask[4];
708         struct { u32 sp, size, flags; } stack;
709         int regs[36];
710         u32 fpregs[32];
711         u32 fpcsr;
712         u32 _unused0;
713         u32 _unused1[47];
714         u32 weird_graphics_thing;
715 };
716
717 asmlinkage int irix_getcontext(struct pt_regs *regs)
718 {
719         int error, i, base = 0;
720         struct irix5_context __user *ctx;
721         unsigned long flags;
722
723         if (regs->regs[2] == 1000)
724                 base = 1;
725         ctx = (struct irix5_context __user *) regs->regs[base + 4];
726
727 #ifdef DEBUG_SIG
728         printk("[%s:%d] irix_getcontext(%p)\n",
729                current->comm, current->pid, ctx);
730 #endif
731
732         if (!access_ok(VERIFY_WRITE, ctx, sizeof(*ctx)))
733                 return -EFAULT;
734
735         error = __put_user(current->thread.irix_oldctx, &ctx->link);
736
737         error |= __copy_to_user(&ctx->sigmask, &current->blocked, sizeof(irix_sigset_t)) ? -EFAULT : 0;
738
739         /* XXX Do sigstack stuff someday... */
740         error |= __put_user(0, &ctx->stack.sp);
741         error |= __put_user(0, &ctx->stack.size);
742         error |= __put_user(0, &ctx->stack.flags);
743
744         error |= __put_user(0, &ctx->weird_graphics_thing);
745         error |= __put_user(0, &ctx->regs[0]);
746         for (i = 1; i < 32; i++)
747                 error |= __put_user(regs->regs[i], &ctx->regs[i]);
748         error |= __put_user(regs->lo, &ctx->regs[32]);
749         error |= __put_user(regs->hi, &ctx->regs[33]);
750         error |= __put_user(regs->cp0_cause, &ctx->regs[34]);
751         error |= __put_user(regs->cp0_epc, &ctx->regs[35]);
752
753         flags = 0x0f;
754         if (!used_math()) {
755                 flags &= ~(0x08);
756         } else {
757                 /* XXX wheee... */
758                 printk("Wheee, no code for saving IRIX FPU context yet.\n");
759         }
760         error |= __put_user(flags, &ctx->flags);
761
762         return error;
763 }
764
765 asmlinkage void irix_setcontext(struct pt_regs *regs)
766 {
767         struct irix5_context __user *ctx;
768         int err, base = 0;
769         u32 flags;
770
771         if (regs->regs[2] == 1000)
772                 base = 1;
773         ctx = (struct irix5_context __user *) regs->regs[base + 4];
774
775 #ifdef DEBUG_SIG
776         printk("[%s:%d] irix_setcontext(%p)\n",
777                current->comm, current->pid, ctx);
778 #endif
779
780         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)))
781                 goto segv_and_exit;
782
783         err = __get_user(flags, &ctx->flags);
784         if (flags & 0x02) {
785                 /* XXX sigstack garbage, todo... */
786                 printk("Wheee, cannot do sigstack stuff in setcontext\n");
787         }
788
789         if (flags & 0x04) {
790                 int i;
791
792                 /* XXX extra control block stuff... todo... */
793                 for (i = 1; i < 32; i++)
794                         err |= __get_user(regs->regs[i], &ctx->regs[i]);
795                 err |= __get_user(regs->lo, &ctx->regs[32]);
796                 err |= __get_user(regs->hi, &ctx->regs[33]);
797                 err |= __get_user(regs->cp0_epc, &ctx->regs[35]);
798         }
799
800         if (flags & 0x08)
801                 /* XXX fpu context, blah... */
802                 printk(KERN_ERR "Wheee, cannot restore FPU context yet...\n");
803
804         err |= __get_user(current->thread.irix_oldctx, &ctx->link);
805         if (err)
806                 goto segv_and_exit;
807
808         /*
809          * Don't let your children do this ...
810          */
811         __asm__ __volatile__(
812                 "move\t$29,%0\n\t"
813                 "j\tsyscall_exit"
814                 :/* no outputs */
815                 :"r" (&regs));
816                 /* Unreached */
817
818 segv_and_exit:
819         force_sigsegv(SIGSEGV, current);
820 }
821
822 struct irix_sigstack {
823         unsigned long sp;
824         int status;
825 };
826
827 asmlinkage int irix_sigstack(struct irix_sigstack __user *new,
828         struct irix_sigstack __user *old)
829 {
830 #ifdef DEBUG_SIG
831         printk("[%s:%d] irix_sigstack(%p,%p)\n",
832                current->comm, current->pid, new, old);
833 #endif
834         if (new) {
835                 if (!access_ok(VERIFY_READ, new, sizeof(*new)))
836                         return -EFAULT;
837         }
838
839         if (old) {
840                 if (!access_ok(VERIFY_WRITE, old, sizeof(*old)))
841                         return -EFAULT;
842         }
843
844         return 0;
845 }
846
847 struct irix_sigaltstack { unsigned long sp; int size; int status; };
848
849 asmlinkage int irix_sigaltstack(struct irix_sigaltstack __user *new,
850                                 struct irix_sigaltstack __user *old)
851 {
852 #ifdef DEBUG_SIG
853         printk("[%s:%d] irix_sigaltstack(%p,%p)\n",
854                current->comm, current->pid, new, old);
855 #endif
856         if (new)
857                 if (!access_ok(VERIFY_READ, new, sizeof(*new)))
858                         return -EFAULT;
859
860         if (old) {
861                 if (!access_ok(VERIFY_WRITE, old, sizeof(*old)))
862                         return -EFAULT;
863         }
864
865         return 0;
866 }
867
868 struct irix_procset {
869         int cmd, ltype, lid, rtype, rid;
870 };
871
872 asmlinkage int irix_sigsendset(struct irix_procset __user *pset, int sig)
873 {
874         if (!access_ok(VERIFY_READ, pset, sizeof(*pset)))
875                 return -EFAULT;
876 #ifdef DEBUG_SIG
877         printk("[%s:%d] irix_sigsendset([%d,%d,%d,%d,%d],%d)\n",
878                current->comm, current->pid,
879                pset->cmd, pset->ltype, pset->lid, pset->rtype, pset->rid,
880                sig);
881 #endif
882         return -EINVAL;
883 }