2 * irixsig.c: WHEEE, IRIX signals! YOW, am I compatible or what?!?!
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.
8 #include <linux/kernel.h>
9 #include <linux/sched.h>
11 #include <linux/errno.h>
12 #include <linux/smp.h>
13 #include <linux/smp_lock.h>
14 #include <linux/time.h>
15 #include <linux/ptrace.h>
16 #include <linux/resource.h>
18 #include <asm/ptrace.h>
19 #include <asm/uaccess.h>
20 #include <asm/unistd.h>
24 #define _S(nr) (1<<((nr)-1))
26 #define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
33 u32 rmask
, cp0_status
;
37 u32 usedfp
, fpcsr
, fpeir
, sstk_flags
;
39 u64 cp0_cause
, cp0_badvaddr
, _unused0
;
47 static inline void dump_irix5_sigctx(struct sigctx_irix5
*c
)
51 printk("misc: rmask[%08lx] status[%08lx] pc[%08lx]\n",
52 (unsigned long) c
->rmask
,
53 (unsigned long) c
->cp0_status
,
54 (unsigned long) c
->pc
);
56 for(i
= 0; i
< 16; i
++)
57 printk("[%d]<%08lx> ", i
, (unsigned long) c
->regs
[i
]);
59 for(i
= 16; i
< 32; i
++)
60 printk("[%d]<%08lx> ", i
, (unsigned long) c
->regs
[i
]);
62 for(i
= 0; i
< 16; i
++)
63 printk("[%d]<%08lx> ", i
, (unsigned long) c
->fpregs
[i
]);
65 for(i
= 16; i
< 32; i
++)
66 printk("[%d]<%08lx> ", i
, (unsigned long) c
->fpregs
[i
]);
67 printk("misc: usedfp[%d] fpcsr[%08lx] fpeir[%08lx] stk_flgs[%08lx]\n",
68 (int) c
->usedfp
, (unsigned long) c
->fpcsr
,
69 (unsigned long) c
->fpeir
, (unsigned long) c
->sstk_flags
);
70 printk("misc: hi[%08lx] lo[%08lx] cause[%08lx] badvaddr[%08lx]\n",
71 (unsigned long) c
->hi
, (unsigned long) c
->lo
,
72 (unsigned long) c
->cp0_cause
, (unsigned long) c
->cp0_badvaddr
);
73 printk("misc: sigset<0>[%08lx] sigset<1>[%08lx] sigset<2>[%08lx] "
74 "sigset<3>[%08lx]\n", (unsigned long) c
->sigset
.sig
[0],
75 (unsigned long) c
->sigset
.sig
[1],
76 (unsigned long) c
->sigset
.sig
[2],
77 (unsigned long) c
->sigset
.sig
[3]);
81 static int setup_irix_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
82 int signr
, sigset_t
*oldmask
)
84 struct sigctx_irix5 __user
*ctx
;
89 sp
-= sizeof(struct sigctx_irix5
);
91 ctx
= (struct sigctx_irix5 __user
*) sp
;
92 if (!access_ok(VERIFY_WRITE
, ctx
, sizeof(*ctx
)))
95 error
= __put_user(0, &ctx
->weird_fpu_thing
);
96 error
|= __put_user(~(0x00000001), &ctx
->rmask
);
97 error
|= __put_user(0, &ctx
->regs
[0]);
98 for(i
= 1; i
< 32; i
++)
99 error
|= __put_user((u64
) regs
->regs
[i
], &ctx
->regs
[i
]);
101 error
|= __put_user((u64
) regs
->hi
, &ctx
->hi
);
102 error
|= __put_user((u64
) regs
->lo
, &ctx
->lo
);
103 error
|= __put_user((u64
) regs
->cp0_epc
, &ctx
->pc
);
104 error
|= __put_user(!!used_math(), &ctx
->usedfp
);
105 error
|= __put_user((u64
) regs
->cp0_cause
, &ctx
->cp0_cause
);
106 error
|= __put_user((u64
) regs
->cp0_badvaddr
, &ctx
->cp0_badvaddr
);
108 error
|= __put_user(0, &ctx
->sstk_flags
); /* XXX sigstack unimp... todo... */
110 error
|= __copy_to_user(&ctx
->sigset
, oldmask
, sizeof(irix_sigset_t
)) ? -EFAULT
: 0;
116 dump_irix5_sigctx(ctx
);
119 regs
->regs
[4] = (unsigned long) signr
;
120 regs
->regs
[5] = 0; /* XXX sigcode XXX */
121 regs
->regs
[6] = regs
->regs
[29] = sp
;
122 regs
->regs
[7] = (unsigned long) ka
->sa
.sa_handler
;
123 regs
->regs
[25] = regs
->cp0_epc
= (unsigned long) ka
->sa_restorer
;
128 force_sigsegv(signr
, current
);
133 setup_irix_rt_frame(struct k_sigaction
* ka
, struct pt_regs
*regs
,
134 int signr
, sigset_t
*oldmask
, siginfo_t
*info
)
136 printk("Aiee: setup_tr_frame wants to be written");
140 static inline int handle_signal(unsigned long sig
, siginfo_t
*info
,
141 struct k_sigaction
*ka
, sigset_t
*oldset
, struct pt_regs
* regs
)
145 switch(regs
->regs
[0]) {
147 regs
->regs
[2] = EINTR
;
150 if(!(ka
->sa
.sa_flags
& SA_RESTART
)) {
151 regs
->regs
[2] = EINTR
;
155 case ERESTARTNOINTR
: /* Userland will reload $v0. */
159 regs
->regs
[0] = 0; /* Don't deal with this again. */
161 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
162 ret
= setup_irix_rt_frame(ka
, regs
, sig
, oldset
, info
);
164 ret
= setup_irix_frame(ka
, regs
, sig
, oldset
);
166 spin_lock_irq(¤t
->sighand
->siglock
);
167 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
168 if (!(ka
->sa
.sa_flags
& SA_NODEFER
))
169 sigaddset(¤t
->blocked
,sig
);
171 spin_unlock_irq(¤t
->sighand
->siglock
);
176 void do_irix_signal(struct pt_regs
*regs
)
178 struct k_sigaction ka
;
184 * We want the common case to go fast, which is why we may in certain
185 * cases get here from kernel mode. Just return without doing anything
188 if (!user_mode(regs
))
191 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
192 oldset
= ¤t
->saved_sigmask
;
194 oldset
= ¤t
->blocked
;
196 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
198 /* Whee! Actually deliver the signal. */
199 if (handle_signal(signr
, &info
, &ka
, oldset
, regs
) == 0) {
200 /* a signal was successfully delivered; the saved
201 * sigmask will have been stored in the signal frame,
202 * and will be restored by sigreturn, so we can simply
203 * clear the TIF_RESTORE_SIGMASK flag */
204 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
205 clear_thread_flag(TIF_RESTORE_SIGMASK
);
212 * Who's code doesn't conform to the restartable syscall convention
213 * dies here!!! The li instruction, a single machine instruction,
214 * must directly be followed by the syscall instruction.
217 if (regs
->regs
[2] == ERESTARTNOHAND
||
218 regs
->regs
[2] == ERESTARTSYS
||
219 regs
->regs
[2] == ERESTARTNOINTR
) {
222 if (regs
->regs
[2] == ERESTART_RESTARTBLOCK
) {
223 regs
->regs
[2] = __NR_restart_syscall
;
224 regs
->regs
[7] = regs
->regs
[26];
230 * If there's no signal to deliver, we just put the saved sigmask
233 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
234 clear_thread_flag(TIF_RESTORE_SIGMASK
);
235 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
240 irix_sigreturn(struct pt_regs
*regs
)
242 struct sigctx_irix5 __user
*context
, *magic
;
243 unsigned long umask
, mask
;
246 int error
, sig
, i
, base
= 0;
249 /* Always make any pending restarted system calls return -EINTR */
250 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
252 if (regs
->regs
[2] == 1000)
255 context
= (struct sigctx_irix5 __user
*) regs
->regs
[base
+ 4];
256 magic
= (struct sigctx_irix5 __user
*) regs
->regs
[base
+ 5];
257 sig
= (int) regs
->regs
[base
+ 6];
259 printk("[%s:%d] IRIX sigreturn(scp[%p],ucp[%p],sig[%d])\n",
260 current
->comm
, current
->pid
, context
, magic
, sig
);
264 if (!access_ok(VERIFY_READ
, context
, sizeof(struct sigctx_irix5
)))
268 dump_irix5_sigctx(context
);
271 error
= __get_user(regs
->cp0_epc
, &context
->pc
);
272 error
|= __get_user(umask
, &context
->rmask
);
275 for (i
= 1; i
< 32; i
++, mask
<<= 1) {
277 error
|= __get_user(regs
->regs
[i
], &context
->regs
[i
]);
279 error
|= __get_user(regs
->hi
, &context
->hi
);
280 error
|= __get_user(regs
->lo
, &context
->lo
);
282 error
|= __get_user(usedfp
, &context
->usedfp
);
283 if ((umask
& 1) && usedfp
) {
284 fregs
= (u64
*) ¤t
->thread
.fpu
;
286 for(i
= 0; i
< 32; i
++)
287 error
|= __get_user(fregs
[i
], &context
->fpregs
[i
]);
288 error
|= __get_user(current
->thread
.fpu
.fcr31
, &context
->fpcsr
);
291 /* XXX do sigstack crapola here... XXX */
293 error
|= __copy_from_user(&blocked
, &context
->sigset
, sizeof(blocked
)) ? -EFAULT
: 0;
298 sigdelsetmask(&blocked
, ~_BLOCKABLE
);
299 spin_lock_irq(¤t
->sighand
->siglock
);
300 current
->blocked
= blocked
;
302 spin_unlock_irq(¤t
->sighand
->siglock
);
305 * Don't let your children do this ...
307 __asm__
__volatile__(
315 force_sig(SIGSEGV
, current
);
318 struct sigact_irix5
{
320 void (*handler
)(int);
326 static inline void dump_sigact_irix5(struct sigact_irix5
*p
)
328 printk("<f[%d] hndlr[%08lx] msk[%08lx]>", p
->flags
,
329 (unsigned long) p
->handler
,
330 (unsigned long) p
->sigset
[0]);
335 irix_sigaction(int sig
, const struct sigaction __user
*act
,
336 struct sigaction __user
*oact
, void __user
*trampoline
)
338 struct k_sigaction new_ka
, old_ka
;
342 printk(" (%d,%s,%s,%08lx) ", sig
, (!new ? "0" : "NEW"),
343 (!old
? "0" : "OLD"), trampoline
);
345 dump_sigact_irix5(new); printk(" ");
352 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)))
354 err
= __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
);
355 err
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
357 err
|= __copy_from_user(&mask
, &act
->sa_mask
, sizeof(sigset_t
)) ? -EFAULT
: 0;
362 * Hmmm... methinks IRIX libc always passes a valid trampoline
363 * value for all invocations of sigaction. Will have to
364 * investigate. POSIX POSIX, die die die...
366 new_ka
.sa_restorer
= trampoline
;
369 /* XXX Implement SIG_SETMASK32 for IRIX compatibility */
370 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
375 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)))
378 err
= __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
);
379 err
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
380 err
|= __copy_to_user(&oact
->sa_mask
, &old_ka
.sa
.sa_mask
,
381 sizeof(sigset_t
)) ? -EFAULT
: 0;
389 asmlinkage
int irix_sigpending(irix_sigset_t __user
*set
)
391 return do_sigpending(set
, sizeof(*set
));
394 asmlinkage
int irix_sigprocmask(int how
, irix_sigset_t __user
*new,
395 irix_sigset_t __user
*old
)
397 sigset_t oldbits
, newbits
;
400 if (!access_ok(VERIFY_READ
, new, sizeof(*new)))
402 if (__copy_from_user(&newbits
, new, sizeof(unsigned long)*4))
404 sigdelsetmask(&newbits
, ~_BLOCKABLE
);
406 spin_lock_irq(¤t
->sighand
->siglock
);
407 oldbits
= current
->blocked
;
411 sigorsets(&newbits
, &oldbits
, &newbits
);
415 sigandsets(&newbits
, &oldbits
, &newbits
);
422 siginitset(&newbits
, newbits
.sig
[0]);
429 spin_unlock_irq(¤t
->sighand
->siglock
);
432 return copy_to_user(old
, ¤t
->blocked
,
433 sizeof(unsigned long)*4) ? -EFAULT
: 0;
438 asmlinkage
int irix_sigsuspend(struct pt_regs
*regs
)
441 sigset_t __user
*uset
;
443 uset
= (sigset_t __user
*) regs
->regs
[4];
444 if (copy_from_user(&newset
, uset
, sizeof(sigset_t
)))
446 sigdelsetmask(&newset
, ~_BLOCKABLE
);
448 spin_lock_irq(¤t
->sighand
->siglock
);
449 current
->saved_sigmask
= current
->blocked
;
450 current
->blocked
= newset
;
452 spin_unlock_irq(¤t
->sighand
->siglock
);
454 current
->state
= TASK_INTERRUPTIBLE
;
456 set_thread_flag(TIF_RESTORE_SIGMASK
);
457 return -ERESTARTNOHAND
;
460 /* hate hate hate... */
461 struct irix5_siginfo
{
462 int sig
, code
, error
;
464 char unused
[128 - (3 * 4)]; /* Safety net. */
470 int utime
, status
, stime
;
475 unsigned long fault_addr
;
482 unsigned long sigval
;
486 asmlinkage
int irix_sigpoll_sys(unsigned long __user
*set
,
487 struct irix5_siginfo __user
*info
, struct timespec __user
*tp
)
489 long expire
= MAX_SCHEDULE_TIMEOUT
;
491 int i
, sig
, error
, timeo
= 0;
495 printk("[%s:%d] irix_sigpoll_sys(%p,%p,%p)\n",
496 current
->comm
, current
->pid
, set
, info
, tp
);
499 /* Must always specify the signal set. */
503 if (copy_from_user(&kset
, set
, sizeof(set
)))
506 if (info
&& clear_user(info
, sizeof(*info
))) {
512 if (copy_from_user(&ktp
, tp
, sizeof(*tp
)))
515 if (!ktp
.tv_sec
&& !ktp
.tv_nsec
)
518 expire
= timespec_to_jiffies(&ktp
) +
519 (ktp
.tv_sec
|| ktp
.tv_nsec
);
525 expire
= schedule_timeout_interruptible(expire
);
528 tmp
|= (current
->pending
.signal
.sig
[i
] & kset
.sig
[i
]);
536 if (signal_pending(current
))
542 for (sig
= 1; i
<= 65 /* IRIX_NSIG */; sig
++) {
543 if (sigismember (&kset
, sig
))
545 if (sigismember (¤t
->pending
.signal
, sig
)) {
546 /* XXX need more than this... */
548 return copy_to_user(&info
->sig
, &sig
, sizeof(sig
));
553 /* Should not get here, but do something sane if we do. */
560 /* This is here because of irix5_siginfo definition. */
562 #define IRIX_P_PGID 2
571 #define W_MASK (W_EXITED | W_TRAPPED | W_STOPPED | W_CONT | W_NOHANG)
573 asmlinkage
int irix_waitsys(int type
, int pid
,
574 struct irix5_siginfo __user
*info
, int options
,
575 struct rusage __user
*ru
)
578 DECLARE_WAITQUEUE(wait
, current
);
579 struct task_struct
*tsk
;
580 struct task_struct
*p
;
581 struct list_head
*_p
;
586 if (!access_ok(VERIFY_WRITE
, info
, sizeof(*info
)))
590 if (!access_ok(VERIFY_WRITE
, ru
, sizeof(*ru
)))
593 if (options
& ~W_MASK
)
596 if (type
!= IRIX_P_PID
&& type
!= IRIX_P_PGID
&& type
!= IRIX_P_ALL
)
599 add_wait_queue(¤t
->signal
->wait_chldexit
, &wait
);
602 current
->state
= TASK_INTERRUPTIBLE
;
603 read_lock(&tasklist_lock
);
605 list_for_each(_p
,&tsk
->children
) {
606 p
= list_entry(_p
,struct task_struct
,sibling
);
607 if ((type
== IRIX_P_PID
) && p
->pid
!= pid
)
609 if ((type
== IRIX_P_PGID
) && process_group(p
) != pid
)
611 if ((p
->exit_signal
!= SIGCHLD
))
618 if (!(options
& (W_TRAPPED
|W_STOPPED
)) &&
619 !(p
->ptrace
& PT_PTRACED
))
621 read_unlock(&tasklist_lock
);
623 /* move to end of parent's list to avoid starvation */
624 write_lock_irq(&tasklist_lock
);
627 write_unlock_irq(&tasklist_lock
);
628 retval
= ru
? getrusage(p
, RUSAGE_BOTH
, ru
) : 0;
632 retval
= __put_user(SIGCHLD
, &info
->sig
);
633 retval
|= __put_user(0, &info
->code
);
634 retval
|= __put_user(p
->pid
, &info
->stuff
.procinfo
.pid
);
635 retval
|= __put_user((p
->exit_code
>> 8) & 0xff,
636 &info
->stuff
.procinfo
.procdata
.child
.status
);
637 retval
|= __put_user(p
->utime
, &info
->stuff
.procinfo
.procdata
.child
.utime
);
638 retval
|= __put_user(p
->stime
, &info
->stuff
.procinfo
.procdata
.child
.stime
);
646 current
->signal
->cutime
+= p
->utime
+ p
->signal
->cutime
;
647 current
->signal
->cstime
+= p
->stime
+ p
->signal
->cstime
;
649 getrusage(p
, RUSAGE_BOTH
, ru
);
650 retval
= __put_user(SIGCHLD
, &info
->sig
);
651 retval
|= __put_user(1, &info
->code
); /* CLD_EXITED */
652 retval
|= __put_user(p
->pid
, &info
->stuff
.procinfo
.pid
);
653 retval
|= __put_user((p
->exit_code
>> 8) & 0xff,
654 &info
->stuff
.procinfo
.procdata
.child
.status
);
655 retval
|= __put_user(p
->utime
,
656 &info
->stuff
.procinfo
.procdata
.child
.utime
);
657 retval
|= __put_user(p
->stime
,
658 &info
->stuff
.procinfo
.procdata
.child
.stime
);
662 if (p
->real_parent
!= p
->parent
) {
663 write_lock_irq(&tasklist_lock
);
665 p
->parent
= p
->real_parent
;
667 do_notify_parent(p
, SIGCHLD
);
668 write_unlock_irq(&tasklist_lock
);
675 tsk
= next_thread(tsk
);
677 read_unlock(&tasklist_lock
);
680 if (options
& W_NOHANG
)
682 retval
= -ERESTARTSYS
;
683 if (signal_pending(current
))
685 current
->state
= TASK_INTERRUPTIBLE
;
691 current
->state
= TASK_RUNNING
;
692 remove_wait_queue(¤t
->signal
->wait_chldexit
, &wait
);
697 struct irix5_context
{
701 struct { u32 sp
, size
, flags
; } stack
;
707 u32 weird_graphics_thing
;
710 asmlinkage
int irix_getcontext(struct pt_regs
*regs
)
712 int error
, i
, base
= 0;
713 struct irix5_context __user
*ctx
;
716 if (regs
->regs
[2] == 1000)
718 ctx
= (struct irix5_context __user
*) regs
->regs
[base
+ 4];
721 printk("[%s:%d] irix_getcontext(%p)\n",
722 current
->comm
, current
->pid
, ctx
);
725 if (!access_ok(VERIFY_WRITE
, ctx
, sizeof(*ctx
)));
728 error
= __put_user(current
->thread
.irix_oldctx
, &ctx
->link
);
730 error
|= __copy_to_user(&ctx
->sigmask
, ¤t
->blocked
, sizeof(irix_sigset_t
)) ? -EFAULT
: 0;
732 /* XXX Do sigstack stuff someday... */
733 error
|= __put_user(0, &ctx
->stack
.sp
);
734 error
|= __put_user(0, &ctx
->stack
.size
);
735 error
|= __put_user(0, &ctx
->stack
.flags
);
737 error
|= __put_user(0, &ctx
->weird_graphics_thing
);
738 error
|= __put_user(0, &ctx
->regs
[0]);
739 for (i
= 1; i
< 32; i
++)
740 error
|= __put_user(regs
->regs
[i
], &ctx
->regs
[i
]);
741 error
|= __put_user(regs
->lo
, &ctx
->regs
[32]);
742 error
|= __put_user(regs
->hi
, &ctx
->regs
[33]);
743 error
|= __put_user(regs
->cp0_cause
, &ctx
->regs
[34]);
744 error
|= __put_user(regs
->cp0_epc
, &ctx
->regs
[35]);
751 printk("Wheee, no code for saving IRIX FPU context yet.\n");
753 error
|= __put_user(flags
, &ctx
->flags
);
758 asmlinkage
void irix_setcontext(struct pt_regs
*regs
)
760 struct irix5_context __user
*ctx
;
764 if (regs
->regs
[2] == 1000)
766 ctx
= (struct irix5_context __user
*) regs
->regs
[base
+ 4];
769 printk("[%s:%d] irix_setcontext(%p)\n",
770 current
->comm
, current
->pid
, ctx
);
773 if (!access_ok(VERIFY_READ
, ctx
, sizeof(*ctx
)))
776 err
= __get_user(flags
, &ctx
->flags
);
778 /* XXX sigstack garbage, todo... */
779 printk("Wheee, cannot do sigstack stuff in setcontext\n");
785 /* XXX extra control block stuff... todo... */
786 for (i
= 1; i
< 32; i
++)
787 err
|= __get_user(regs
->regs
[i
], &ctx
->regs
[i
]);
788 err
|= __get_user(regs
->lo
, &ctx
->regs
[32]);
789 err
|= __get_user(regs
->hi
, &ctx
->regs
[33]);
790 err
|= __get_user(regs
->cp0_epc
, &ctx
->regs
[35]);
794 /* XXX fpu context, blah... */
795 printk(KERN_ERR
"Wheee, cannot restore FPU context yet...\n");
797 err
|= __get_user(current
->thread
.irix_oldctx
, &ctx
->link
);
802 * Don't let your children do this ...
804 __asm__
__volatile__(
812 force_sigsegv(SIGSEGV
, current
);
815 struct irix_sigstack
{
820 asmlinkage
int irix_sigstack(struct irix_sigstack __user
*new,
821 struct irix_sigstack __user
*old
)
824 printk("[%s:%d] irix_sigstack(%p,%p)\n",
825 current
->comm
, current
->pid
, new, old
);
828 if (!access_ok(VERIFY_READ
, new, sizeof(*new)))
833 if (!access_ok(VERIFY_WRITE
, old
, sizeof(*old
)))
840 struct irix_sigaltstack
{ unsigned long sp
; int size
; int status
; };
842 asmlinkage
int irix_sigaltstack(struct irix_sigaltstack __user
*new,
843 struct irix_sigaltstack __user
*old
)
846 printk("[%s:%d] irix_sigaltstack(%p,%p)\n",
847 current
->comm
, current
->pid
, new, old
);
850 if (!access_ok(VERIFY_READ
, new, sizeof(*new)))
854 if (!access_ok(VERIFY_WRITE
, old
, sizeof(*old
)))
861 struct irix_procset
{
862 int cmd
, ltype
, lid
, rtype
, rid
;
865 asmlinkage
int irix_sigsendset(struct irix_procset __user
*pset
, int sig
)
867 if (!access_ok(VERIFY_READ
, pset
, sizeof(*pset
)))
870 printk("[%s:%d] irix_sigsendset([%d,%d,%d,%d,%d],%d)\n",
871 current
->comm
, current
->pid
,
872 pset
->cmd
, pset
->ltype
, pset
->lid
, pset
->rtype
, pset
->rid
,
This page took 0.049415 seconds and 5 git commands to generate.