};
+extern asmlinkage long sys_wait4(pid_t pid,unsigned int * stat_addr,
+ int options, struct rusage * ru);
+/*
+ * Start of nonRT signal support
+ *
+ * sigset_t is 32 bits for non-rt signals
+ *
+ * System Calls
+ * sigaction sys32_sigaction
+ * sigpending sys32_sigpending
+ * sigprocmask sys32_sigprocmask
+ * sigreturn sys32_sigreturn
+ *
+ * Note sigsuspend has no special 32 bit routine - uses the 64 bit routine
+ *
+ * Other routines
+ * setup_frame32
+ */
-extern asmlinkage long sys_wait4(pid_t pid,unsigned int * stat_addr, int options, struct rusage * ru);
-
-
-/****************************************************************************/
-/* Start of nonRT signal support */
-/* */
-/* sigset_t is 32 bits for non-rt signals */
-/* */
-/* System Calls */
-/* sigaction sys32_sigaction */
-/* sigpending sys32_sigpending */
-/* sigprocmask sys32_sigprocmask */
-/* sigreturn sys32_sigreturn */
-/* */
-/* Note sigsuspend has no special 32 bit routine - uses the 64 bit routine */
-/* */
-/* Other routines */
-/* setup_frame32 */
-/* */
-/****************************************************************************/
-
-
-asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact)
+asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 *act,
+ struct old_sigaction32 *oact)
{
struct k_sigaction new_ka, old_ka;
int ret;
if (sig < 0)
- {
sig = -sig;
- }
- if (act)
- {
+ if (act) {
old_sigset_t32 mask;
ret = get_user((long)new_ka.sa.sa_handler, &act->sa_handler);
ret |= __get_user(mask, &act->sa_mask);
if (ret)
return ret;
-
siginitset(&new_ka.sa.sa_mask, mask);
}
- ret = do_sigaction(sig, (act? &new_ka: NULL), (oact? &old_ka: NULL));
-
- if (!ret && oact)
- {
+ ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
+ if (!ret && oact) {
ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
ret |= __put_user((long)old_ka.sa.sa_restorer, &oact->sa_restorer);
ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
old_sigset_t s;
int ret;
mm_segment_t old_fs = get_fs();
-
- set_fs (KERNEL_DS);
+
+ set_fs(KERNEL_DS);
ret = sys_sigpending(&s);
- set_fs (old_fs);
- if (put_user (s, set)) return -EFAULT;
-
+ set_fs(old_fs);
+ if (put_user(s, set))
+ return -EFAULT;
return ret;
}
-extern asmlinkage long sys_sigprocmask(int how, old_sigset_t *set, old_sigset_t *oset);
+extern asmlinkage long sys_sigprocmask(int how, old_sigset_t *set,
+ old_sigset_t *oset);
/*
* Note: it is necessary to treat how as an unsigned int, with the
* of a signed int (msr in 32-bit mode) and the register representation
* of a signed int (msr in 64-bit mode) is performed.
*/
-asmlinkage long sys32_sigprocmask(u32 how, old_sigset_t32 *set, old_sigset_t32 *oset)
+asmlinkage long sys32_sigprocmask(u32 how, old_sigset_t32 *set,
+ old_sigset_t32 *oset)
{
old_sigset_t s;
int ret;
mm_segment_t old_fs = get_fs();
-
- if (set && get_user (s, set)) return -EFAULT;
- set_fs (KERNEL_DS);
+
+ if (set && get_user(s, set))
+ return -EFAULT;
+ set_fs(KERNEL_DS);
ret = sys_sigprocmask((int)how, set ? &s : NULL, oset ? &s : NULL);
- set_fs (old_fs);
- if (ret) return ret;
- if (oset && put_user (s, oset)) return -EFAULT;
-
+ set_fs(old_fs);
+ if (ret)
+ return ret;
+ if (oset && put_user (s, oset))
+ return -EFAULT;
return 0;
}
sr = (struct sigregs32*)(u64)sigctx.regs;
if (regs->msr & MSR_FP )
giveup_fpu(current);
- /* copy the 32 bit register values off the user stack */
- /* into the 32 bit register area */
- if (copy_from_user(saved_regs, &sr->gp_regs,sizeof(sr->gp_regs)))
+ /*
+ * copy the 32 bit register values off the user stack
+ * into the 32 bit register area
+ */
+ if (copy_from_user(saved_regs, &sr->gp_regs,
+ sizeof(sr->gp_regs)))
goto badframe;
- /**********************************************************************/
- /* The saved reg structure in the frame is an elf_grepset_t32, it is */
- /* a 32 bit register save of the registers in the pt_regs structure */
- /* that was stored on the kernel stack during the system call */
- /* when the system call was interrupted for the signal. Only 32 bits*/
- /* are saved because the sigcontext contains a pointer to the regs */
- /* and the sig context address is passed as a pointer to the signal */
- /* handler. */
- /* */
- /* The entries in the elf_grepset have the same index as the elements */
- /* in the pt_regs structure. */
- /* */
- /**********************************************************************/
-
+ /*
+ * The saved reg structure in the frame is an elf_grepset_t32,
+ * it is a 32 bit register save of the registers in the
+ * pt_regs structure that was stored on the kernel stack
+ * during the system call when the system call was interrupted
+ * for the signal. Only 32 bits are saved because the
+ * sigcontext contains a pointer to the regs and the sig
+ * context address is passed as a pointer to the signal
+ * handler.
+ *
+ * The entries in the elf_grepset have the same index as the
+ * elements in the pt_regs structure.
+ */
saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE)
| (saved_regs[PT_MSR] & MSR_USERCHANGE);
regs->gpr[0] = (u64)(saved_regs[0]) & 0xFFFFFFFF;
/* restore the non gpr registers */
/****************************************************/
regs->msr = (u64)(saved_regs[PT_MSR]) & 0xFFFFFFFF;
- /* Insure that the interrupt mode is 64 bit, during 32 bit execution.
- * (This is necessary because we only saved lower 32 bits of msr.)
+ /*
+ * Insure that the interrupt mode is 64 bit, during 32 bit
+ * execution. (This is necessary because we only saved
+ * lower 32 bits of msr.)
*/
regs->msr = regs->msr | MSR_ISF; /* When this thread is interrupted it should run in 64 bit mode. */
goto badframe;
ret = regs->result;
+
return ret;
badframe:
/*
* Set up a signal frame.
*/
-static void
-setup_frame32(struct pt_regs *regs, struct sigregs32 *frame,
+static void setup_frame32(struct pt_regs *regs, struct sigregs32 *frame,
unsigned int newsp)
{
- struct sigcontext32_struct *sc = (struct sigcontext32_struct *)(u64)newsp;
+ struct sigcontext32_struct *sc =
+ (struct sigcontext32_struct *)(u64)newsp;
if (verify_area(VERIFY_WRITE, frame, sizeof(*frame)))
goto badframe;
return;
badframe:
+ udbg_printf("setup_frame32 - badframe in setup_frame, regs=%p frame=%p newsp=%lx\n", regs, frame, newsp); PPCDBG_ENTER_DEBUGGER();
#if DEBUG_SIG
printk("badframe in setup_frame32, regs=%p frame=%p newsp=%lx\n",
regs, frame, newsp);
/* Adjust the inputted reg1 to point to the first rt signal frame */
rt_stack_frame = (struct rt_sigframe_32 *)(regs->gpr[1] + __SIGNAL_FRAMESIZE32);
/* Copy the information from the user stack */
- if (copy_from_user(&sigctx, &rt_stack_frame->uc.uc_mcontext,sizeof(sigctx))
- || copy_from_user(&signal_set, &rt_stack_frame->uc.uc_sigmask,sizeof(signal_set))
- || copy_from_user(&stack,&rt_stack_frame->uc.uc_stack,sizeof(stack)))
- {
- /* unable to copy from user storage */
+ if (copy_from_user(&sigctx, &rt_stack_frame->uc.uc_mcontext,
+ sizeof(sigctx))
+ || copy_from_user(&signal_set, &rt_stack_frame->uc.uc_sigmask,
+ sizeof(signal_set))
+ || copy_from_user(&stack,&rt_stack_frame->uc.uc_stack,
+ sizeof(stack)))
goto badframe;
- }
/*
* Unblock the signal that was processed
signalregs = (struct sigregs32 *) (u64)sigctx.regs;
/* If currently owning the floating point - give them up */
if (regs->msr & MSR_FP)
- {
giveup_fpu(current);
- }
- if (copy_from_user(saved_regs,&signalregs->gp_regs,sizeof(signalregs->gp_regs)))
- {
+ if (copy_from_user(saved_regs, &signalregs->gp_regs,
+ sizeof(signalregs->gp_regs)))
goto badframe;
- }
- /**********************************************************************/
- /* The saved reg structure in the frame is an elf_grepset_t32, it is */
- /* a 32 bit register save of the registers in the pt_regs structure */
- /* that was stored on the kernel stack during the system call */
- /* when the system call was interrupted for the signal. Only 32 bits*/
- /* are saved because the sigcontext contains a pointer to the regs */
- /* and the sig context address is passed as a pointer to the signal */
- /* handler. */
- /* */
- /* The entries in the elf_grepset have the same index as the elements */
- /* in the pt_regs structure. */
- /* */
- /**********************************************************************/
-
+ /*
+ * The saved reg structure in the frame is an elf_grepset_t32,
+ * it is a 32 bit register save of the registers in the
+ * pt_regs structure that was stored on the kernel stack
+ * during the system call when the system call was interrupted
+ * for the signal. Only 32 bits are saved because the
+ * sigcontext contains a pointer to the regs and the sig
+ * context address is passed as a pointer to the signal handler
+ *
+ * The entries in the elf_grepset have the same index as
+ * the elements in the pt_regs structure.
+ */
saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE)
| (saved_regs[PT_MSR] & MSR_USERCHANGE);
regs->gpr[0] = (u64)(saved_regs[0]) & 0xFFFFFFFF;
/* restore the non gpr registers */
/****************************************************/
regs->msr = (u64)(saved_regs[PT_MSR]) & 0xFFFFFFFF;
-
regs->nip = (u64)(saved_regs[PT_NIP]) & 0xFFFFFFFF;
regs->orig_gpr3 = (u64)(saved_regs[PT_ORIG_R3]) & 0xFFFFFFFF;
regs->ctr = (u64)(saved_regs[PT_CTR]) & 0xFFFFFFFF;
regs->xer = (u64)(saved_regs[PT_XER]) & 0xFFFFFFFF;
regs->ccr = (u64)(saved_regs[PT_CCR]) & 0xFFFFFFFF;
/* regs->softe is left unchanged (like MSR.EE) */
- /******************************************************/
- /* the DAR and the DSISR are only relevant during a */
- /* data or instruction storage interrupt. The value */
- /* will be set to zero. */
- /******************************************************/
+ /*
+ * the DAR and the DSISR are only relevant during a
+ * data or instruction storage interrupt. The value
+ * will be set to zero.
+ */
regs->dar = 0;
regs->dsisr = 0;
regs->result = (u64)(saved_regs[PT_RESULT]) & 0xFFFFFFFF;
ret = regs->result;
-
return ret;
badframe:
-asmlinkage long sys32_rt_sigaction(int sig, const struct sigaction32 *act, struct sigaction32 *oact, size_t sigsetsize)
+asmlinkage long sys32_rt_sigaction(int sig, const struct sigaction32 *act,
+ struct sigaction32 *oact, size_t sigsetsize)
{
struct k_sigaction new_ka, old_ka;
int ret;
}
-extern asmlinkage long sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset,
- size_t sigsetsize);
+extern asmlinkage long sys_rt_sigprocmask(int how, sigset_t *set,
+ sigset_t *oset, size_t sigsetsize);
/*
* Note: it is necessary to treat how as an unsigned int, with the
* of a signed int (msr in 32-bit mode) and the register representation
* of a signed int (msr in 64-bit mode) is performed.
*/
-asmlinkage long sys32_rt_sigprocmask(u32 how, sigset32_t *set, sigset32_t *oset, size_t sigsetsize)
+asmlinkage long sys32_rt_sigprocmask(u32 how, sigset32_t *set,
+ sigset32_t *oset, size_t sigsetsize)
{
sigset_t s;
sigset32_t s32;
}
}
- set_fs (KERNEL_DS);
+ set_fs(KERNEL_DS);
ret = sys_rt_sigprocmask((int)how, set ? &s : NULL, oset ? &s : NULL,
sigsetsize);
- set_fs (old_fs);
- if (ret) return ret;
+ set_fs(old_fs);
+ if (ret)
+ return ret;
if (oset) {
switch (_NSIG_WORDS) {
case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
extern asmlinkage long sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
-
-asmlinkage long sys32_rt_sigpending(sigset32_t *set, __kernel_size_t32 sigsetsize)
+asmlinkage long sys32_rt_sigpending(sigset32_t *set,
+ __kernel_size_t32 sigsetsize)
{
sigset_t s;
sigset32_t s32;
int ret;
mm_segment_t old_fs = get_fs();
-
- set_fs (KERNEL_DS);
+
+ set_fs(KERNEL_DS);
ret = sys_rt_sigpending(&s, sigsetsize);
- set_fs (old_fs);
+ set_fs(old_fs);
if (!ret) {
switch (_NSIG_WORDS) {
case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
}
-
-siginfo_t32 *
-siginfo64to32(siginfo_t32 *d, siginfo_t *s)
+siginfo_t32 *siginfo64to32(siginfo_t32 *d, siginfo_t *s)
{
memset (d, 0, sizeof(siginfo_t32));
d->si_signo = s->si_signo;
d->si_pid = s->si_pid;
d->si_uid = s->si_uid;
d->si_int = s->si_int;
- } else switch (s->si_signo) {
- /* XXX: What about POSIX1.b timers */
- case SIGCHLD:
- d->si_pid = s->si_pid;
- d->si_status = s->si_status;
- d->si_utime = s->si_utime;
- d->si_stime = s->si_stime;
- break;
- case SIGSEGV:
- case SIGBUS:
- case SIGFPE:
- case SIGILL:
- d->si_addr = (long)(s->si_addr);
- break;
- case SIGPOLL:
- d->si_band = s->si_band;
- d->si_fd = s->si_fd;
- break;
- default:
- d->si_pid = s->si_pid;
- d->si_uid = s->si_uid;
- break;
+ } else {
+ switch (s->si_signo) {
+ /* XXX: What about POSIX1.b timers */
+ case SIGCHLD:
+ d->si_pid = s->si_pid;
+ d->si_status = s->si_status;
+ d->si_utime = s->si_utime;
+ d->si_stime = s->si_stime;
+ break;
+ case SIGSEGV:
+ case SIGBUS:
+ case SIGFPE:
+ case SIGILL:
+ d->si_addr = (long)(s->si_addr);
+ break;
+ case SIGPOLL:
+ d->si_band = s->si_band;
+ d->si_fd = s->si_fd;
+ break;
+ default:
+ d->si_pid = s->si_pid;
+ d->si_uid = s->si_uid;
+ break;
+ }
}
return d;
}
-extern asmlinkage long
-sys_rt_sigtimedwait(const sigset_t *uthese, siginfo_t *uinfo,
- const struct timespec *uts, size_t sigsetsize);
+extern asmlinkage long sys_rt_sigtimedwait(const sigset_t *uthese,
+ siginfo_t *uinfo, const struct timespec *uts,
+ size_t sigsetsize);
-asmlinkage long
-sys32_rt_sigtimedwait(sigset32_t *uthese, siginfo_t32 *uinfo,
- struct timespec32 *uts, __kernel_size_t32 sigsetsize)
+asmlinkage long sys32_rt_sigtimedwait(sigset32_t *uthese, siginfo_t32 *uinfo,
+ struct timespec32 *uts, __kernel_size_t32 sigsetsize)
{
sigset_t s;
sigset32_t s32;
siginfo_t info;
siginfo_t32 info32;
- if (copy_from_user (&s32, uthese, sizeof(sigset32_t)))
+ if (copy_from_user(&s32, uthese, sizeof(sigset32_t)))
return -EFAULT;
switch (_NSIG_WORDS) {
case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
}
if (uts) {
- ret = get_user (t.tv_sec, &uts->tv_sec);
- ret |= __get_user (t.tv_nsec, &uts->tv_nsec);
+ ret = get_user(t.tv_sec, &uts->tv_sec);
+ ret |= __get_user(t.tv_nsec, &uts->tv_nsec);
if (ret)
return -EFAULT;
}
- set_fs (KERNEL_DS);
+ set_fs(KERNEL_DS);
if (uts)
- {
ret = sys_rt_sigtimedwait(&s, &info, &t, sigsetsize);
- } else {
- ret = sys_rt_sigtimedwait(&s, &info, (struct timespec *)uts, sigsetsize);
- }
-
- set_fs (old_fs);
+ else
+ ret = sys_rt_sigtimedwait(&s, &info, (struct timespec *)uts,
+ sigsetsize);
+ set_fs(old_fs);
if (ret >= 0 && uinfo) {
if (copy_to_user (uinfo, siginfo64to32(&info32, &info),
sizeof(siginfo_t32)))
-siginfo_t *
-siginfo32to64(siginfo_t *d, siginfo_t32 *s)
+siginfo_t * siginfo32to64(siginfo_t *d, siginfo_t32 *s)
{
d->si_signo = s->si_signo;
d->si_errno = s->si_errno;
d->si_pid = s->si_pid;
d->si_uid = s->si_uid;
d->si_int = s->si_int;
-
- } else switch (s->si_signo) {
- /* XXX: What about POSIX1.b timers */
- case SIGCHLD:
- d->si_pid = s->si_pid;
- d->si_status = s->si_status;
- d->si_utime = s->si_utime;
- d->si_stime = s->si_stime;
- break;
- case SIGSEGV:
- case SIGBUS:
- case SIGFPE:
- case SIGILL:
- d->si_addr = (void *)A(s->si_addr);
- break;
- case SIGPOLL:
- d->si_band = s->si_band;
- d->si_fd = s->si_fd;
- break;
- default:
- d->si_pid = s->si_pid;
- d->si_uid = s->si_uid;
- break;
+ } else {
+ switch (s->si_signo) {
+ /* XXX: What about POSIX1.b timers */
+ case SIGCHLD:
+ d->si_pid = s->si_pid;
+ d->si_status = s->si_status;
+ d->si_utime = s->si_utime;
+ d->si_stime = s->si_stime;
+ break;
+ case SIGSEGV:
+ case SIGBUS:
+ case SIGFPE:
+ case SIGILL:
+ d->si_addr = (void *)A(s->si_addr);
+ break;
+ case SIGPOLL:
+ d->si_band = s->si_band;
+ d->si_fd = s->si_fd;
+ break;
+ default:
+ d->si_pid = s->si_pid;
+ d->si_uid = s->si_uid;
+ break;
+ }
}
return d;
}
}
-int do_signal(sigset_t *oldset, struct pt_regs *regs);
-int sys32_rt_sigsuspend(sigset32_t* unewset, size_t sigsetsize, int p3, int p4, int p6, int p7, struct pt_regs *regs)
+extern int do_signal(sigset_t *oldset, struct pt_regs *regs);
+
+int sys32_rt_sigsuspend(sigset32_t* unewset, size_t sigsetsize, int p3,
+ int p4, int p6, int p7, struct pt_regs *regs)
{
sigset_t saveset, newset;
sigset32_t s32;
if (copy_from_user(&s32, unewset, sizeof(s32)))
return -EFAULT;
- /* Swap the 2 words of the 64-bit sigset_t (they are stored in the "wrong" endian in 32-bit user storage). */
- switch (_NSIG_WORDS)
- {
- case 4: newset.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
- case 3: newset.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
- case 2: newset.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
- case 1: newset.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
+ /*
+ * Swap the 2 words of the 64-bit sigset_t (they are stored
+ * in the "wrong" endian in 32-bit user storage).
+ */
+ switch (_NSIG_WORDS) {
+ case 4: newset.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
+ case 3: newset.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
+ case 2: newset.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
+ case 1: newset.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
}
sigdelsetmask(&newset, ~_BLOCKABLE);
/*
* Set up a rt signal frame.
*/
-static void
-setup_rt_frame32(struct pt_regs *regs, struct sigregs32 *frame,
+static void setup_rt_frame32(struct pt_regs *regs, struct sigregs32 *frame,
unsigned int newsp)
{
- unsigned int copyreg4,copyreg5;
+ unsigned int copyreg4, copyreg5;
struct rt_sigframe_32 * rt_sf = (struct rt_sigframe_32 *) (u64)newsp;
return;
badframe:
+ udbg_printf("setup_frame32 - badframe in setup_frame, regs=%p frame=%p newsp=%lx\n", regs, frame, newsp); PPCDBG_ENTER_DEBUGGER();
#if DEBUG_SIG
printk("badframe in setup_frame32, regs=%p frame=%p newsp=%lx\n",
regs, frame, newsp);
/*
* OK, we're invoking a handler
*/
-static void
-handle_signal32(unsigned long sig, siginfo_t *info, sigset_t *oldset,
- struct pt_regs * regs, unsigned int *newspp, unsigned int frame)
+static void handle_signal32(unsigned long sig, siginfo_t *info,
+ sigset_t *oldset, struct pt_regs * regs, unsigned int *newspp,
+ unsigned int frame)
{
struct sigcontext32_struct *sc;
struct rt_sigframe_32 *rt_stack_frame;
!(ka->sa.sa_flags & SA_RESTART))))
regs->result = -EINTR;
- /* Set up the signal frame */
- /* Determine if an real time frame - siginfo required */
- if (ka->sa.sa_flags & SA_SIGINFO)
- {
+ /*
+ * Set up the signal frame
+ * Determine if an real time frame - siginfo required
+ */
+ if (ka->sa.sa_flags & SA_SIGINFO) {
siginfo64to32(&siginfo32bit,info);
*newspp -= sizeof(*rt_stack_frame);
- rt_stack_frame = (struct rt_sigframe_32 *) (u64)(*newspp) ;
-
- if (verify_area(VERIFY_WRITE, rt_stack_frame, sizeof(*rt_stack_frame)))
- {
+ rt_stack_frame = (struct rt_sigframe_32 *)(u64)(*newspp);
+
+ if (verify_area(VERIFY_WRITE, rt_stack_frame,
+ sizeof(*rt_stack_frame)))
goto badframe;
- }
- if (__put_user((u32)(u64)ka->sa.sa_handler, &rt_stack_frame->uc.uc_mcontext.handler)
- || __put_user((u32)(u64)&rt_stack_frame->info, &rt_stack_frame->pinfo)
- || __put_user((u32)(u64)&rt_stack_frame->uc, &rt_stack_frame->puc)
+ if (__put_user((u32)(u64)ka->sa.sa_handler,
+ &rt_stack_frame->uc.uc_mcontext.handler)
+ || __put_user((u32)(u64)&rt_stack_frame->info,
+ &rt_stack_frame->pinfo)
+ || __put_user((u32)(u64)&rt_stack_frame->uc,
+ &rt_stack_frame->puc)
/* put the siginfo on the user stack */
- || __copy_to_user(&rt_stack_frame->info,&siginfo32bit,sizeof(siginfo32bit))
+ || __copy_to_user(&rt_stack_frame->info, &siginfo32bit,
+ sizeof(siginfo32bit))
/* set the ucontext on the user stack */
- || __put_user(0,&rt_stack_frame->uc.uc_flags)
- || __put_user(0,&rt_stack_frame->uc.uc_link)
- || __put_user(current->sas_ss_sp, &rt_stack_frame->uc.uc_stack.ss_sp)
+ || __put_user(0, &rt_stack_frame->uc.uc_flags)
+ || __put_user(0, &rt_stack_frame->uc.uc_link)
+ || __put_user(current->sas_ss_sp,
+ &rt_stack_frame->uc.uc_stack.ss_sp)
|| __put_user(sas_ss_flags(regs->gpr[1]),
- &rt_stack_frame->uc.uc_stack.ss_flags)
- || __put_user(current->sas_ss_size, &rt_stack_frame->uc.uc_stack.ss_size)
- || __copy_to_user(&rt_stack_frame->uc.uc_sigmask, oldset,sizeof(*oldset))
+ &rt_stack_frame->uc.uc_stack.ss_flags)
+ || __put_user(current->sas_ss_size,
+ &rt_stack_frame->uc.uc_stack.ss_size)
+ || __copy_to_user(&rt_stack_frame->uc.uc_sigmask,
+ oldset, sizeof(*oldset))
/* point the mcontext.regs to the pramble register frame */
|| __put_user(frame, &rt_stack_frame->uc.uc_mcontext.regs)
|| __put_user(sig,&rt_stack_frame->uc.uc_mcontext.signal))
- {
goto badframe;
- }
} else {
- /* Put a sigcontext on the stack */
+ /* Put another sigcontext on the stack */
*newspp -= sizeof(*sc);
sc = (struct sigcontext32_struct *)(u64)*newspp;
if (verify_area(VERIFY_WRITE, sc, sizeof(*sc)))
* sigaltatck sys32_sigaltstack
*/
-asmlinkage int sys32_sigaltstack(u32 newstack, u32 oldstack, int p3, int p4, int p6,
- int p7, struct pt_regs *regs)
+asmlinkage int sys32_sigaltstack(u32 newstack, u32 oldstack, int p3,
+ int p4, int p6, int p7, struct pt_regs *regs)
{
stack_t uss, uoss;
int ret;
*/
sp = regs->gpr[1];
- /* Put new stack info in local 64 bit stack struct */
- if (newstack && (get_user((long)uss.ss_sp, &((stack_32_t *)(long)newstack)->ss_sp) ||
- __get_user(uss.ss_flags, &((stack_32_t *)(long)newstack)->ss_flags) ||
- __get_user(uss.ss_size, &((stack_32_t *)(long)newstack)->ss_size)))
+ /* Put new stack info in local 64 bit stack struct */
+ if (newstack &&
+ (get_user((long)uss.ss_sp,
+ &((stack_32_t *)(long)newstack)->ss_sp) ||
+ __get_user(uss.ss_flags,
+ &((stack_32_t *)(long)newstack)->ss_flags) ||
+ __get_user(uss.ss_size,
+ &((stack_32_t *)(long)newstack)->ss_size)))
return -EFAULT;
old_fs = get_fs();
set_fs(KERNEL_DS);
- ret = do_sigaltstack(newstack ? &uss : NULL, oldstack ? &uoss : NULL, sp);
+ ret = do_sigaltstack(newstack ? &uss : NULL, oldstack ? &uoss : NULL,
+ sp);
set_fs(old_fs);
- /* Copy the stack information to the user output buffer */
- if (!ret && oldstack && (put_user((long)uoss.ss_sp, &((stack_32_t *)(long)oldstack)->ss_sp) ||
- __put_user(uoss.ss_flags, &((stack_32_t *)(long)oldstack)->ss_flags) ||
- __put_user(uoss.ss_size, &((stack_32_t *)(long)oldstack)->ss_size)))
+ /* Copy the stack information to the user output buffer */
+ if (!ret && oldstack &&
+ (put_user((long)uoss.ss_sp,
+ &((stack_32_t *)(long)oldstack)->ss_sp) ||
+ __put_user(uoss.ss_flags,
+ &((stack_32_t *)(long)oldstack)->ss_flags) ||
+ __put_user(uoss.ss_size,
+ &((stack_32_t *)(long)oldstack)->ss_size)))
return -EFAULT;
return ret;
}
if (signr > 0) {
ka = ¤t->sig->action[signr-1];
- if ( (ka->sa.sa_flags & SA_ONSTACK)
- && (! on_sig_stack(regs->gpr[1])))
+ if ((ka->sa.sa_flags & SA_ONSTACK) &&
+ (!on_sig_stack(regs->gpr[1])))
newsp = (current->sas_ss_sp + current->sas_ss_size);
else
newsp = regs->gpr[1];
return 0; /* no signals delivered */
/* Invoke correct stack setup routine */
- if (ka->sa.sa_flags & SA_SIGINFO)
+ if (ka->sa.sa_flags & SA_SIGINFO)
setup_rt_frame32(regs, (struct sigregs32*)(u64)frame, newsp);
else
setup_frame32(regs, (struct sigregs32*)(u64)frame, newsp);
projects / linux / commitdiff