Skip to content

Commit

Permalink
sparc: Remove old style signal frame support.
Browse files Browse the repository at this point in the history 
Back around the same time we were bootstrapping the first 32-bit sparc
Linux kernel with a SunOS userland, we made the signal frame match
that of SunOS.

By the time we even started putting together a native Linux userland
for 32-bit Sparc we realized this layout wasn't sufficient for Linux's
needs.

Therefore we changed the layout, yet kept support for the old style
signal frame layout in there.  The detection mechanism is that we had
sys_sigaction() start passing in a negative signal number to indicate
"new style signal frames please".

Anyways, no binaries exist in the world that use the old stuff.  In
fact, I bet Jakub Jelinek and myself are the only two people who ever
had such binaries to be honest.

So let's get rid of this stuff.

I added an assertion using WARN_ON_ONCE() that makes sure 32-bit
applications are passing in that negative signal number still.

Signed-off-by: David S. Miller <davem@davemloft.net>
  • Loading branch information
David S. Miller committed Apr 27, 2008
1 parent 7cf0699 commit 5526b7e
Show file tree
Hide file tree
Showing 8 changed files with 47 additions and 528 deletions.
2 changes: 0 additions & 2 deletions arch/sparc/kernel/process.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -357,8 +357,6 @@ void flush_thread(void)
{
current_thread_info()->w_saved = 0;

/* No new signal delivery by default */
current->thread.new_signal = 0;
#ifndef CONFIG_SMP
if(last_task_used_math == current) {
#else
Expand Down
260 changes: 20 additions & 240 deletions arch/sparc/kernel/signal.c
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,4 @@
/* $Id: signal.c,v 1.110 2002/02/08 03:57:14 davem Exp $
* linux/arch/sparc/kernel/signal.c
/* linux/arch/sparc/kernel/signal.c
*
* Copyright (C) 1991, 1992 Linus Torvalds
* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
Expand Down Expand Up @@ -32,37 +31,7 @@ extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
void *fpqueue, unsigned long *fpqdepth);
extern void fpload(unsigned long *fpregs, unsigned long *fsr);

/* Signal frames: the original one (compatible with SunOS):
*
* Set up a signal frame... Make the stack look the way SunOS
* expects it to look which is basically:
*
* ---------------------------------- <-- %sp at signal time
* Struct sigcontext
* Signal address
* Ptr to sigcontext area above
* Signal code
* The signal number itself
* One register window
* ---------------------------------- <-- New %sp
*/
struct signal_sframe {
struct reg_window sig_window;
int sig_num;
int sig_code;
struct sigcontext __user *sig_scptr;
int sig_address;
struct sigcontext sig_context;
unsigned int extramask[_NSIG_WORDS - 1];
};

/*
* And the new one, intended to be used for Linux applications only
* (we have enough in there to work with clone).
* All the interesting bits are in the info field.
*/

struct new_signal_frame {
struct signal_frame {
struct sparc_stackf ss;
__siginfo_t info;
__siginfo_fpu_t __user *fpu_save;
Expand All @@ -85,8 +54,7 @@ struct rt_signal_frame {
};

/* Align macros */
#define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
#define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
#define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7)))
#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))

static int _sigpause_common(old_sigset_t set)
Expand Down Expand Up @@ -141,15 +109,20 @@ restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
return err;
}

static inline void do_new_sigreturn (struct pt_regs *regs)
asmlinkage void do_sigreturn(struct pt_regs *regs)
{
struct new_signal_frame __user *sf;
struct signal_frame __user *sf;
unsigned long up_psr, pc, npc;
sigset_t set;
__siginfo_fpu_t __user *fpu_save;
int err;

sf = (struct new_signal_frame __user *) regs->u_regs[UREG_FP];
/* Always make any pending restarted system calls return -EINTR */
current_thread_info()->restart_block.fn = do_no_restart_syscall;

synchronize_user_stack();

sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];

/* 1. Make sure we are not getting garbage from the user */
if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
Expand Down Expand Up @@ -198,73 +171,6 @@ static inline void do_new_sigreturn (struct pt_regs *regs)
force_sig(SIGSEGV, current);
}

asmlinkage void do_sigreturn(struct pt_regs *regs)
{
struct sigcontext __user *scptr;
unsigned long pc, npc, psr;
sigset_t set;
int err;

/* Always make any pending restarted system calls return -EINTR */
current_thread_info()->restart_block.fn = do_no_restart_syscall;

synchronize_user_stack();

if (current->thread.new_signal) {
do_new_sigreturn(regs);
return;
}

scptr = (struct sigcontext __user *) regs->u_regs[UREG_I0];

/* Check sanity of the user arg. */
if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext)) ||
(((unsigned long) scptr) & 3))
goto segv_and_exit;

err = __get_user(pc, &scptr->sigc_pc);
err |= __get_user(npc, &scptr->sigc_npc);

if ((pc | npc) & 3)
goto segv_and_exit;

/* This is pretty much atomic, no amount locking would prevent
* the races which exist anyways.
*/
err |= __get_user(set.sig[0], &scptr->sigc_mask);
/* Note that scptr + 1 points to extramask */
err |= __copy_from_user(&set.sig[1], scptr + 1,
(_NSIG_WORDS - 1) * sizeof(unsigned int));

if (err)
goto segv_and_exit;

sigdelsetmask(&set, ~_BLOCKABLE);
spin_lock_irq(&current->sighand->siglock);
current->blocked = set;
recalc_sigpending();
spin_unlock_irq(&current->sighand->siglock);

regs->pc = pc;
regs->npc = npc;

err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);

/* User can only change condition codes in %psr. */
err |= __get_user(psr, &scptr->sigc_psr);
if (err)
goto segv_and_exit;

regs->psr &= ~(PSR_ICC);
regs->psr |= (psr & PSR_ICC);
return;

segv_and_exit:
force_sig(SIGSEGV, current);
}

asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
{
struct rt_signal_frame __user *sf;
Expand Down Expand Up @@ -351,128 +257,6 @@ static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *re
return (void __user *)(sp - framesize);
}

static inline void
setup_frame(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
{
struct signal_sframe __user *sframep;
struct sigcontext __user *sc;
int window = 0, err;
unsigned long pc = regs->pc;
unsigned long npc = regs->npc;
struct thread_info *tp = current_thread_info();
void __user *sig_address;
int sig_code;

synchronize_user_stack();
sframep = (struct signal_sframe __user *)
get_sigframe(sa, regs, SF_ALIGNEDSZ);
if (invalid_frame_pointer(sframep, sizeof(*sframep))){
/* Don't change signal code and address, so that
* post mortem debuggers can have a look.
*/
goto sigill_and_return;
}

sc = &sframep->sig_context;

/* We've already made sure frame pointer isn't in kernel space... */
err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
&sc->sigc_onstack);
err |= __put_user(oldset->sig[0], &sc->sigc_mask);
err |= __copy_to_user(sframep->extramask, &oldset->sig[1],
(_NSIG_WORDS - 1) * sizeof(unsigned int));
err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
err |= __put_user(pc, &sc->sigc_pc);
err |= __put_user(npc, &sc->sigc_npc);
err |= __put_user(regs->psr, &sc->sigc_psr);
err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
err |= __put_user(tp->w_saved, &sc->sigc_oswins);
if (tp->w_saved)
for (window = 0; window < tp->w_saved; window++) {
put_user((char *)tp->rwbuf_stkptrs[window],
&sc->sigc_spbuf[window]);
err |= __copy_to_user(&sc->sigc_wbuf[window],
&tp->reg_window[window],
sizeof(struct reg_window));
}
else
err |= __copy_to_user(sframep, (char *) regs->u_regs[UREG_FP],
sizeof(struct reg_window));

tp->w_saved = 0; /* So process is allowed to execute. */

err |= __put_user(signr, &sframep->sig_num);
sig_address = NULL;
sig_code = 0;
if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
sig_address = info->si_addr;
switch (signr) {
case SIGSEGV:
switch (info->si_code) {
case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
default: sig_code = SUBSIG_PROTECTION; break;
}
break;
case SIGILL:
switch (info->si_code) {
case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
default: sig_code = SUBSIG_STACK; break;
}
break;
case SIGFPE:
switch (info->si_code) {
case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
default: sig_code = SUBSIG_FPERROR; break;
}
break;
case SIGBUS:
switch (info->si_code) {
case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
default: sig_code = SUBSIG_BUSTIMEOUT; break;
}
break;
case SIGEMT:
switch (info->si_code) {
case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
}
break;
case SIGSYS:
if (info->si_code == (__SI_FAULT|0x100)) {
sig_code = info->si_trapno;
break;
}
default:
sig_address = NULL;
}
}
err |= __put_user((unsigned long)sig_address, &sframep->sig_address);
err |= __put_user(sig_code, &sframep->sig_code);
err |= __put_user(sc, &sframep->sig_scptr);
if (err)
goto sigsegv;

regs->u_regs[UREG_FP] = (unsigned long) sframep;
regs->pc = (unsigned long) sa->sa_handler;
regs->npc = (regs->pc + 4);
return;

sigill_and_return:
do_exit(SIGILL);
sigsegv:
force_sigsegv(signr, current);
}


static inline int
save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
{
Expand Down Expand Up @@ -508,21 +292,20 @@ save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
return err;
}

static inline void
new_setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset)
static void setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset)
{
struct new_signal_frame __user *sf;
struct signal_frame __user *sf;
int sigframe_size, err;

/* 1. Make sure everything is clean */
synchronize_user_stack();

sigframe_size = NF_ALIGNEDSZ;
sigframe_size = SF_ALIGNEDSZ;
if (!used_math())
sigframe_size -= sizeof(__siginfo_fpu_t);

sf = (struct new_signal_frame __user *)
sf = (struct signal_frame __user *)
get_sigframe(&ka->sa, regs, sigframe_size);

if (invalid_frame_pointer(sf, sigframe_size))
Expand Down Expand Up @@ -586,9 +369,8 @@ new_setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
force_sigsegv(signo, current);
}

static inline void
new_setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset, siginfo_t *info)
static void setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset, siginfo_t *info)
{
struct rt_signal_frame __user *sf;
int sigframe_size;
Expand Down Expand Up @@ -674,11 +456,9 @@ handle_signal(unsigned long signr, struct k_sigaction *ka,
siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
{
if (ka->sa.sa_flags & SA_SIGINFO)
new_setup_rt_frame(ka, regs, signr, oldset, info);
else if (current->thread.new_signal)
new_setup_frame(ka, regs, signr, oldset);
setup_rt_frame(ka, regs, signr, oldset, info);
else
setup_frame(&ka->sa, regs, signr, oldset, info);
setup_frame(ka, regs, signr, oldset);

spin_lock_irq(&current->sighand->siglock);
sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
Expand Down
14 changes: 3 additions & 11 deletions arch/sparc/kernel/sys_sparc.c
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,4 @@
/* $Id: sys_sparc.c,v 1.70 2001/04/14 01:12:02 davem Exp $
* linux/arch/sparc/kernel/sys_sparc.c
/* linux/arch/sparc/kernel/sys_sparc.c
*
* This file contains various random system calls that
* have a non-standard calling sequence on the Linux/sparc
Expand Down Expand Up @@ -395,10 +394,8 @@ sparc_sigaction (int sig, const struct old_sigaction __user *act,
struct k_sigaction new_ka, old_ka;
int ret;

if (sig < 0) {
current->thread.new_signal = 1;
sig = -sig;
}
WARN_ON_ONCE(sig >= 0);
sig = -sig;

if (act) {
unsigned long mask;
Expand Down Expand Up @@ -446,11 +443,6 @@ sys_rt_sigaction(int sig,
if (sigsetsize != sizeof(sigset_t))
return -EINVAL;

/* All tasks which use RT signals (effectively) use
* new style signals.
*/
current->thread.new_signal = 1;

if (act) {
new_ka.ka_restorer = restorer;
if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
Expand Down
6 changes: 1 addition & 5 deletions arch/sparc64/kernel/process.c
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,4 @@
/* $Id: process.c,v 1.131 2002/02/09 19:49:30 davem Exp $
* arch/sparc64/kernel/process.c
/* arch/sparc64/kernel/process.c
*
* Copyright (C) 1995, 1996 David S. Miller (davem@caip.rutgers.edu)
* Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
Expand Down Expand Up @@ -368,9 +367,6 @@ void flush_thread(void)

if (get_thread_current_ds() != ASI_AIUS)
set_fs(USER_DS);

/* Init new signal delivery disposition. */
clear_thread_flag(TIF_NEWSIGNALS);
}

/* It's a bit more tricky when 64-bit tasks are involved... */
Expand Down
Loading

0 comments on commit 5526b7e

Please sign in to comment.