mirror of
https://github.com/torvalds/linux.git
synced 2025-11-04 10:40:15 +02:00
[MIPS] IRIX: Goodbye and thanks for all the fish
Never terribly functional or popular, plagued by hard to fix bugs the time to say goodbye has more than arrived. Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
This commit is contained in:
Ralf Baechle
parent
997288517e
commit
2957c9e61e
14 changed files with 5 additions and 5843 deletions
|
|
@ -2064,10 +2064,6 @@ source "fs/Kconfig.binfmt"
|
|||
config TRAD_SIGNALS
|
||||
bool
|
||||
|
||||
config BINFMT_IRIX
|
||||
bool "Include IRIX binary compatibility"
|
||||
depends on CPU_BIG_ENDIAN && 32BIT && BROKEN
|
||||
|
||||
config MIPS32_COMPAT
|
||||
bool "Kernel support for Linux/MIPS 32-bit binary compatibility"
|
||||
depends on 64BIT
|
||||
|
|
|
|||
|
|
@ -20,9 +20,6 @@ obj-$(CONFIG_CSRC_R4K) += csrc-r4k.o
|
|||
obj-$(CONFIG_CSRC_SB1250) += csrc-sb1250.o
|
||||
obj-$(CONFIG_SYNC_R4K) += sync-r4k.o
|
||||
|
||||
binfmt_irix-objs := irixelf.o irixinv.o irixioctl.o irixsig.o \
|
||||
irix5sys.o sysirix.o
|
||||
|
||||
obj-$(CONFIG_STACKTRACE) += stacktrace.o
|
||||
obj-$(CONFIG_MODULES) += mips_ksyms.o module.o
|
||||
|
||||
|
|
@ -70,7 +67,6 @@ obj-$(CONFIG_IRQ_GIC) += irq-gic.o
|
|||
|
||||
obj-$(CONFIG_32BIT) += scall32-o32.o
|
||||
obj-$(CONFIG_64BIT) += scall64-64.o
|
||||
obj-$(CONFIG_BINFMT_IRIX) += binfmt_irix.o
|
||||
obj-$(CONFIG_MIPS32_COMPAT) += linux32.o ptrace32.o signal32.o
|
||||
obj-$(CONFIG_MIPS32_N32) += binfmt_elfn32.o scall64-n32.o signal_n32.o
|
||||
obj-$(CONFIG_MIPS32_O32) += binfmt_elfo32.o scall64-o32.o
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -1,78 +0,0 @@
|
|||
/*
|
||||
* Support the inventory interface for IRIX binaries
|
||||
* This is invoked before the mm layer is working, so we do not
|
||||
* use the linked lists for the inventory yet.
|
||||
*
|
||||
* Miguel de Icaza, 1997.
|
||||
*/
|
||||
#include <linux/mm.h>
|
||||
#include <asm/inventory.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#define MAX_INVENTORY 50
|
||||
int inventory_items = 0;
|
||||
|
||||
static inventory_t inventory [MAX_INVENTORY];
|
||||
|
||||
void add_to_inventory(int class, int type, int controller, int unit, int state)
|
||||
{
|
||||
inventory_t *ni = &inventory [inventory_items];
|
||||
|
||||
if (inventory_items == MAX_INVENTORY)
|
||||
return;
|
||||
|
||||
ni->inv_class = class;
|
||||
ni->inv_type = type;
|
||||
ni->inv_controller = controller;
|
||||
ni->inv_unit = unit;
|
||||
ni->inv_state = state;
|
||||
ni->inv_next = ni;
|
||||
inventory_items++;
|
||||
}
|
||||
|
||||
int dump_inventory_to_user(void __user *userbuf, int size)
|
||||
{
|
||||
inventory_t *inv = &inventory [0];
|
||||
inventory_t __user *user = userbuf;
|
||||
int v;
|
||||
|
||||
if (!access_ok(VERIFY_WRITE, userbuf, size))
|
||||
return -EFAULT;
|
||||
|
||||
for (v = 0; v < inventory_items; v++){
|
||||
inv = &inventory [v];
|
||||
if (copy_to_user (user, inv, sizeof (inventory_t)))
|
||||
return -EFAULT;
|
||||
user++;
|
||||
}
|
||||
return inventory_items * sizeof(inventory_t);
|
||||
}
|
||||
|
||||
int __init init_inventory(void)
|
||||
{
|
||||
/*
|
||||
* gross hack while we put the right bits all over the kernel
|
||||
* most likely this will not let just anyone run the X server
|
||||
* until we put the right values all over the place
|
||||
*/
|
||||
add_to_inventory(10, 3, 0, 0, 16400);
|
||||
add_to_inventory(1, 1, 150, -1, 12);
|
||||
add_to_inventory(1, 3, 0, 0, 8976);
|
||||
add_to_inventory(1, 2, 0, 0, 8976);
|
||||
add_to_inventory(4, 8, 0, 0, 2);
|
||||
add_to_inventory(5, 5, 0, 0, 1);
|
||||
add_to_inventory(3, 3, 0, 0, 32768);
|
||||
add_to_inventory(3, 4, 0, 0, 32768);
|
||||
add_to_inventory(3, 8, 0, 0, 524288);
|
||||
add_to_inventory(3, 9, 0, 0, 64);
|
||||
add_to_inventory(3, 1, 0, 0, 67108864);
|
||||
add_to_inventory(12, 3, 0, 0, 16);
|
||||
add_to_inventory(8, 7, 17, 0, 16777472);
|
||||
add_to_inventory(8, 0, 0, 0, 1);
|
||||
add_to_inventory(2, 1, 0, 13, 2);
|
||||
add_to_inventory(2, 2, 0, 2, 0);
|
||||
add_to_inventory(2, 2, 0, 1, 0);
|
||||
add_to_inventory(7, 14, 0, 0, 6);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,213 +0,0 @@
|
|||
/*
|
||||
* irixioctl.c: A fucking mess...
|
||||
*
|
||||
* Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/smp.h>
|
||||
#include <linux/sockios.h>
|
||||
#include <linux/syscalls.h>
|
||||
#include <linux/tty.h>
|
||||
#include <linux/file.h>
|
||||
#include <linux/rcupdate.h>
|
||||
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/ioctl.h>
|
||||
#include <asm/ioctls.h>
|
||||
|
||||
#undef DEBUG_IOCTLS
|
||||
#undef DEBUG_MISSING_IOCTL
|
||||
|
||||
struct irix_termios {
|
||||
tcflag_t c_iflag, c_oflag, c_cflag, c_lflag;
|
||||
cc_t c_cc[NCCS];
|
||||
};
|
||||
|
||||
asmlinkage int irix_ioctl(int fd, unsigned long cmd, unsigned long arg)
|
||||
{
|
||||
struct tty_struct *tp, *rtp;
|
||||
mm_segment_t old_fs;
|
||||
int i, error = 0;
|
||||
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("[%s:%d] irix_ioctl(%d, ", current->comm, current->pid, fd);
|
||||
#endif
|
||||
switch(cmd) {
|
||||
case 0x00005401:
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TCGETA, %08lx) ", arg);
|
||||
#endif
|
||||
error = sys_ioctl(fd, TCGETA, arg);
|
||||
break;
|
||||
|
||||
case 0x0000540d: {
|
||||
struct termios kt;
|
||||
struct irix_termios __user *it =
|
||||
(struct irix_termios __user *) arg;
|
||||
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TCGETS, %08lx) ", arg);
|
||||
#endif
|
||||
if (!access_ok(VERIFY_WRITE, it, sizeof(*it))) {
|
||||
error = -EFAULT;
|
||||
break;
|
||||
}
|
||||
old_fs = get_fs(); set_fs(get_ds());
|
||||
error = sys_ioctl(fd, TCGETS, (unsigned long) &kt);
|
||||
set_fs(old_fs);
|
||||
if (error)
|
||||
break;
|
||||
|
||||
error = __put_user(kt.c_iflag, &it->c_iflag);
|
||||
error |= __put_user(kt.c_oflag, &it->c_oflag);
|
||||
error |= __put_user(kt.c_cflag, &it->c_cflag);
|
||||
error |= __put_user(kt.c_lflag, &it->c_lflag);
|
||||
|
||||
for (i = 0; i < NCCS; i++)
|
||||
error |= __put_user(kt.c_cc[i], &it->c_cc[i]);
|
||||
break;
|
||||
}
|
||||
|
||||
case 0x0000540e: {
|
||||
struct termios kt;
|
||||
struct irix_termios *it = (struct irix_termios *) arg;
|
||||
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TCSETS, %08lx) ", arg);
|
||||
#endif
|
||||
if (!access_ok(VERIFY_READ, it, sizeof(*it))) {
|
||||
error = -EFAULT;
|
||||
break;
|
||||
}
|
||||
old_fs = get_fs(); set_fs(get_ds());
|
||||
error = sys_ioctl(fd, TCGETS, (unsigned long) &kt);
|
||||
set_fs(old_fs);
|
||||
if (error)
|
||||
break;
|
||||
|
||||
error = __get_user(kt.c_iflag, &it->c_iflag);
|
||||
error |= __get_user(kt.c_oflag, &it->c_oflag);
|
||||
error |= __get_user(kt.c_cflag, &it->c_cflag);
|
||||
error |= __get_user(kt.c_lflag, &it->c_lflag);
|
||||
|
||||
for (i = 0; i < NCCS; i++)
|
||||
error |= __get_user(kt.c_cc[i], &it->c_cc[i]);
|
||||
|
||||
if (error)
|
||||
break;
|
||||
old_fs = get_fs(); set_fs(get_ds());
|
||||
error = sys_ioctl(fd, TCSETS, (unsigned long) &kt);
|
||||
set_fs(old_fs);
|
||||
break;
|
||||
}
|
||||
|
||||
case 0x0000540f:
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TCSETSW, %08lx) ", arg);
|
||||
#endif
|
||||
error = sys_ioctl(fd, TCSETSW, arg);
|
||||
break;
|
||||
|
||||
case 0x00005471:
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TIOCNOTTY, %08lx) ", arg);
|
||||
#endif
|
||||
error = sys_ioctl(fd, TIOCNOTTY, arg);
|
||||
break;
|
||||
|
||||
case 0x00007416: {
|
||||
pid_t pid;
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TIOCGSID, %08lx) ", arg);
|
||||
#endif
|
||||
old_fs = get_fs(); set_fs(get_ds());
|
||||
error = sys_ioctl(fd, TIOCGSID, (unsigned long)&pid);
|
||||
set_fs(old_fs);
|
||||
if (!error)
|
||||
error = put_user(pid, (unsigned long __user *) arg);
|
||||
break;
|
||||
}
|
||||
case 0x746e:
|
||||
/* TIOCSTART, same effect as hitting ^Q */
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TIOCSTART, %08lx) ", arg);
|
||||
#endif
|
||||
error = sys_ioctl(fd, TCXONC, TCOON);
|
||||
break;
|
||||
|
||||
case 0x20006968:
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("SIOCGETLABEL, %08lx) ", arg);
|
||||
#endif
|
||||
error = -ENOPKG;
|
||||
break;
|
||||
|
||||
case 0x40047477:
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TIOCGPGRP, %08lx) ", arg);
|
||||
#endif
|
||||
error = sys_ioctl(fd, TIOCGPGRP, arg);
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("arg=%d ", *(int *)arg);
|
||||
#endif
|
||||
break;
|
||||
|
||||
case 0x40087468:
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("TIOCGWINSZ, %08lx) ", arg);
|
||||
#endif
|
||||
error = sys_ioctl(fd, TIOCGWINSZ, arg);
|
||||
break;
|
||||
|
||||
case 0x8004667e:
|
||||
error = sys_ioctl(fd, FIONBIO, arg);
|
||||
break;
|
||||
|
||||
case 0x80047476:
|
||||
error = sys_ioctl(fd, TIOCSPGRP, arg);
|
||||
break;
|
||||
|
||||
case 0x8020690c:
|
||||
error = sys_ioctl(fd, SIOCSIFADDR, arg);
|
||||
break;
|
||||
|
||||
case 0x80206910:
|
||||
error = sys_ioctl(fd, SIOCSIFFLAGS, arg);
|
||||
break;
|
||||
|
||||
case 0xc0206911:
|
||||
error = sys_ioctl(fd, SIOCGIFFLAGS, arg);
|
||||
break;
|
||||
|
||||
case 0xc020691b:
|
||||
error = sys_ioctl(fd, SIOCGIFMETRIC, arg);
|
||||
break;
|
||||
|
||||
default: {
|
||||
#ifdef DEBUG_MISSING_IOCTL
|
||||
char *msg = "Unimplemented IOCTL cmd tell linux-mips@linux-mips.org\n";
|
||||
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("UNIMP_IOCTL, %08lx)\n", arg);
|
||||
#endif
|
||||
old_fs = get_fs(); set_fs(get_ds());
|
||||
sys_write(2, msg, strlen(msg));
|
||||
set_fs(old_fs);
|
||||
printk("[%s:%d] Does unimplemented IRIX ioctl cmd %08lx\n",
|
||||
current->comm, current->pid, cmd);
|
||||
do_exit(255);
|
||||
#else
|
||||
error = sys_ioctl(fd, cmd, arg);
|
||||
#endif
|
||||
}
|
||||
|
||||
};
|
||||
#ifdef DEBUG_IOCTLS
|
||||
printk("error=%d\n", error);
|
||||
#endif
|
||||
return error;
|
||||
}
|
||||
|
|
@ -1,888 +0,0 @@
|
|||
/*
|
||||
* irixsig.c: WHEEE, IRIX signals! YOW, am I compatible or what?!?!
|
||||
*
|
||||
* Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
|
||||
* Copyright (C) 1997 - 2000 Ralf Baechle (ralf@gnu.org)
|
||||
* Copyright (C) 2000 Silicon Graphics, Inc.
|
||||
*/
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/smp.h>
|
||||
#include <linux/time.h>
|
||||
#include <linux/ptrace.h>
|
||||
#include <linux/resource.h>
|
||||
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/unistd.h>
|
||||
|
||||
#undef DEBUG_SIG
|
||||
|
||||
#define _S(nr) (1<<((nr)-1))
|
||||
|
||||
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
|
||||
|
||||
#define _IRIX_NSIG 128
|
||||
#define _IRIX_NSIG_BPW BITS_PER_LONG
|
||||
#define _IRIX_NSIG_WORDS (_IRIX_NSIG / _IRIX_NSIG_BPW)
|
||||
|
||||
typedef struct {
|
||||
unsigned long sig[_IRIX_NSIG_WORDS];
|
||||
} irix_sigset_t;
|
||||
|
||||
struct sigctx_irix5 {
|
||||
u32 rmask, cp0_status;
|
||||
u64 pc;
|
||||
u64 regs[32];
|
||||
u64 fpregs[32];
|
||||
u32 usedfp, fpcsr, fpeir, sstk_flags;
|
||||
u64 hi, lo;
|
||||
u64 cp0_cause, cp0_badvaddr, _unused0;
|
||||
irix_sigset_t sigset;
|
||||
u64 weird_fpu_thing;
|
||||
u64 _unused1[31];
|
||||
};
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
/* Debugging */
|
||||
static inline void dump_irix5_sigctx(struct sigctx_irix5 *c)
|
||||
{
|
||||
int i;
|
||||
|
||||
printk("misc: rmask[%08lx] status[%08lx] pc[%08lx]\n",
|
||||
(unsigned long) c->rmask,
|
||||
(unsigned long) c->cp0_status,
|
||||
(unsigned long) c->pc);
|
||||
printk("regs: ");
|
||||
for(i = 0; i < 16; i++)
|
||||
printk("[%d]<%08lx> ", i, (unsigned long) c->regs[i]);
|
||||
printk("\nregs: ");
|
||||
for(i = 16; i < 32; i++)
|
||||
printk("[%d]<%08lx> ", i, (unsigned long) c->regs[i]);
|
||||
printk("\nfpregs: ");
|
||||
for(i = 0; i < 16; i++)
|
||||
printk("[%d]<%08lx> ", i, (unsigned long) c->fpregs[i]);
|
||||
printk("\nfpregs: ");
|
||||
for(i = 16; i < 32; i++)
|
||||
printk("[%d]<%08lx> ", i, (unsigned long) c->fpregs[i]);
|
||||
printk("misc: usedfp[%d] fpcsr[%08lx] fpeir[%08lx] stk_flgs[%08lx]\n",
|
||||
(int) c->usedfp, (unsigned long) c->fpcsr,
|
||||
(unsigned long) c->fpeir, (unsigned long) c->sstk_flags);
|
||||
printk("misc: hi[%08lx] lo[%08lx] cause[%08lx] badvaddr[%08lx]\n",
|
||||
(unsigned long) c->hi, (unsigned long) c->lo,
|
||||
(unsigned long) c->cp0_cause, (unsigned long) c->cp0_badvaddr);
|
||||
printk("misc: sigset<0>[%08lx] sigset<1>[%08lx] sigset<2>[%08lx] "
|
||||
"sigset<3>[%08lx]\n", (unsigned long) c->sigset.sig[0],
|
||||
(unsigned long) c->sigset.sig[1],
|
||||
(unsigned long) c->sigset.sig[2],
|
||||
(unsigned long) c->sigset.sig[3]);
|
||||
}
|
||||
#endif
|
||||
|
||||
static int setup_irix_frame(struct k_sigaction *ka, struct pt_regs *regs,
|
||||
int signr, sigset_t *oldmask)
|
||||
{
|
||||
struct sigctx_irix5 __user *ctx;
|
||||
unsigned long sp;
|
||||
int error, i;
|
||||
|
||||
sp = regs->regs[29];
|
||||
sp -= sizeof(struct sigctx_irix5);
|
||||
sp &= ~(0xf);
|
||||
ctx = (struct sigctx_irix5 __user *) sp;
|
||||
if (!access_ok(VERIFY_WRITE, ctx, sizeof(*ctx)))
|
||||
goto segv_and_exit;
|
||||
|
||||
error = __put_user(0, &ctx->weird_fpu_thing);
|
||||
error |= __put_user(~(0x00000001), &ctx->rmask);
|
||||
error |= __put_user(0, &ctx->regs[0]);
|
||||
for(i = 1; i < 32; i++)
|
||||
error |= __put_user((u64) regs->regs[i], &ctx->regs[i]);
|
||||
|
||||
error |= __put_user((u64) regs->hi, &ctx->hi);
|
||||
error |= __put_user((u64) regs->lo, &ctx->lo);
|
||||
error |= __put_user((u64) regs->cp0_epc, &ctx->pc);
|
||||
error |= __put_user(!!used_math(), &ctx->usedfp);
|
||||
error |= __put_user((u64) regs->cp0_cause, &ctx->cp0_cause);
|
||||
error |= __put_user((u64) regs->cp0_badvaddr, &ctx->cp0_badvaddr);
|
||||
|
||||
error |= __put_user(0, &ctx->sstk_flags); /* XXX sigstack unimp... todo... */
|
||||
|
||||
error |= __copy_to_user(&ctx->sigset, oldmask, sizeof(irix_sigset_t)) ? -EFAULT : 0;
|
||||
|
||||
if (error)
|
||||
goto segv_and_exit;
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
dump_irix5_sigctx(ctx);
|
||||
#endif
|
||||
|
||||
regs->regs[4] = (unsigned long) signr;
|
||||
regs->regs[5] = 0; /* XXX sigcode XXX */
|
||||
regs->regs[6] = regs->regs[29] = sp;
|
||||
regs->regs[7] = (unsigned long) ka->sa.sa_handler;
|
||||
regs->regs[25] = regs->cp0_epc = (unsigned long) ka->sa_restorer;
|
||||
|
||||
return 1;
|
||||
|
||||
segv_and_exit:
|
||||
force_sigsegv(signr, current);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int inline
|
||||
setup_irix_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
|
||||
int signr, sigset_t *oldmask, siginfo_t *info)
|
||||
{
|
||||
printk("Aiee: setup_tr_frame wants to be written");
|
||||
do_exit(SIGSEGV);
|
||||
}
|
||||
|
||||
static inline int handle_signal(unsigned long sig, siginfo_t *info,
|
||||
struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
|
||||
{
|
||||
int ret;
|
||||
|
||||
switch(regs->regs[0]) {
|
||||
case ERESTARTNOHAND:
|
||||
regs->regs[2] = EINTR;
|
||||
break;
|
||||
case ERESTARTSYS:
|
||||
if(!(ka->sa.sa_flags & SA_RESTART)) {
|
||||
regs->regs[2] = EINTR;
|
||||
break;
|
||||
}
|
||||
/* fallthrough */
|
||||
case ERESTARTNOINTR: /* Userland will reload $v0. */
|
||||
regs->cp0_epc -= 8;
|
||||
}
|
||||
|
||||
regs->regs[0] = 0; /* Don't deal with this again. */
|
||||
|
||||
if (ka->sa.sa_flags & SA_SIGINFO)
|
||||
ret = setup_irix_rt_frame(ka, regs, sig, oldset, info);
|
||||
else
|
||||
ret = setup_irix_frame(ka, regs, sig, oldset);
|
||||
|
||||
spin_lock_irq(¤t->sighand->siglock);
|
||||
sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask);
|
||||
if (!(ka->sa.sa_flags & SA_NODEFER))
|
||||
sigaddset(¤t->blocked, sig);
|
||||
recalc_sigpending();
|
||||
spin_unlock_irq(¤t->sighand->siglock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void do_irix_signal(struct pt_regs *regs)
|
||||
{
|
||||
struct k_sigaction ka;
|
||||
siginfo_t info;
|
||||
int signr;
|
||||
sigset_t *oldset;
|
||||
|
||||
/*
|
||||
* We want the common case to go fast, which is why we may in certain
|
||||
* cases get here from kernel mode. Just return without doing anything
|
||||
* if so.
|
||||
*/
|
||||
if (!user_mode(regs))
|
||||
return;
|
||||
|
||||
if (test_thread_flag(TIF_RESTORE_SIGMASK))
|
||||
oldset = ¤t->saved_sigmask;
|
||||
else
|
||||
oldset = ¤t->blocked;
|
||||
|
||||
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
|
||||
if (signr > 0) {
|
||||
/* Whee! Actually deliver the signal. */
|
||||
if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
|
||||
/* a signal was successfully delivered; the saved
|
||||
* sigmask will have been stored in the signal frame,
|
||||
* and will be restored by sigreturn, so we can simply
|
||||
* clear the TIF_RESTORE_SIGMASK flag */
|
||||
if (test_thread_flag(TIF_RESTORE_SIGMASK))
|
||||
clear_thread_flag(TIF_RESTORE_SIGMASK);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Who's code doesn't conform to the restartable syscall convention
|
||||
* dies here!!! The li instruction, a single machine instruction,
|
||||
* must directly be followed by the syscall instruction.
|
||||
*/
|
||||
if (regs->regs[0]) {
|
||||
if (regs->regs[2] == ERESTARTNOHAND ||
|
||||
regs->regs[2] == ERESTARTSYS ||
|
||||
regs->regs[2] == ERESTARTNOINTR) {
|
||||
regs->cp0_epc -= 8;
|
||||
}
|
||||
if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
|
||||
regs->regs[2] = __NR_restart_syscall;
|
||||
regs->regs[7] = regs->regs[26];
|
||||
regs->cp0_epc -= 4;
|
||||
}
|
||||
regs->regs[0] = 0; /* Don't deal with this again. */
|
||||
}
|
||||
|
||||
/*
|
||||
* If there's no signal to deliver, we just put the saved sigmask
|
||||
* back
|
||||
*/
|
||||
if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
|
||||
clear_thread_flag(TIF_RESTORE_SIGMASK);
|
||||
sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
asmlinkage void
|
||||
irix_sigreturn(struct pt_regs *regs)
|
||||
{
|
||||
struct sigctx_irix5 __user *context, *magic;
|
||||
unsigned long umask, mask;
|
||||
u64 *fregs;
|
||||
u32 usedfp;
|
||||
int error, sig, i, base = 0;
|
||||
sigset_t blocked;
|
||||
|
||||
/* Always make any pending restarted system calls return -EINTR */
|
||||
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
||||
|
||||
if (regs->regs[2] == 1000)
|
||||
base = 1;
|
||||
|
||||
context = (struct sigctx_irix5 __user *) regs->regs[base + 4];
|
||||
magic = (struct sigctx_irix5 __user *) regs->regs[base + 5];
|
||||
sig = (int) regs->regs[base + 6];
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] IRIX sigreturn(scp[%p],ucp[%p],sig[%d])\n",
|
||||
current->comm, current->pid, context, magic, sig);
|
||||
#endif
|
||||
if (!context)
|
||||
context = magic;
|
||||
if (!access_ok(VERIFY_READ, context, sizeof(struct sigctx_irix5)))
|
||||
goto badframe;
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
dump_irix5_sigctx(context);
|
||||
#endif
|
||||
|
||||
error = __get_user(regs->cp0_epc, &context->pc);
|
||||
error |= __get_user(umask, &context->rmask);
|
||||
|
||||
mask = 2;
|
||||
for (i = 1; i < 32; i++, mask <<= 1) {
|
||||
if (umask & mask)
|
||||
error |= __get_user(regs->regs[i], &context->regs[i]);
|
||||
}
|
||||
error |= __get_user(regs->hi, &context->hi);
|
||||
error |= __get_user(regs->lo, &context->lo);
|
||||
|
||||
error |= __get_user(usedfp, &context->usedfp);
|
||||
if ((umask & 1) && usedfp) {
|
||||
fregs = (u64 *) ¤t->thread.fpu;
|
||||
|
||||
for(i = 0; i < 32; i++)
|
||||
error |= __get_user(fregs[i], &context->fpregs[i]);
|
||||
error |= __get_user(current->thread.fpu.fcr31, &context->fpcsr);
|
||||
}
|
||||
|
||||
/* XXX do sigstack crapola here... XXX */
|
||||
|
||||
error |= __copy_from_user(&blocked, &context->sigset, sizeof(blocked)) ? -EFAULT : 0;
|
||||
|
||||
if (error)
|
||||
goto badframe;
|
||||
|
||||
sigdelsetmask(&blocked, ~_BLOCKABLE);
|
||||
spin_lock_irq(¤t->sighand->siglock);
|
||||
current->blocked = blocked;
|
||||
recalc_sigpending();
|
||||
spin_unlock_irq(¤t->sighand->siglock);
|
||||
|
||||
/*
|
||||
* Don't let your children do this ...
|
||||
*/
|
||||
__asm__ __volatile__(
|
||||
"move\t$29,%0\n\t"
|
||||
"j\tsyscall_exit"
|
||||
:/* no outputs */
|
||||
:"r" (®s));
|
||||
/* Unreached */
|
||||
|
||||
badframe:
|
||||
force_sig(SIGSEGV, current);
|
||||
}
|
||||
|
||||
struct sigact_irix5 {
|
||||
int flags;
|
||||
void (*handler)(int);
|
||||
u32 sigset[4];
|
||||
int _unused0[2];
|
||||
};
|
||||
|
||||
#define SIG_SETMASK32 256 /* Goodie from SGI for BSD compatibility:
|
||||
set only the low 32 bit of the sigset. */
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
static inline void dump_sigact_irix5(struct sigact_irix5 *p)
|
||||
{
|
||||
printk("<f[%d] hndlr[%08lx] msk[%08lx]>", p->flags,
|
||||
(unsigned long) p->handler,
|
||||
(unsigned long) p->sigset[0]);
|
||||
}
|
||||
#endif
|
||||
|
||||
asmlinkage int
|
||||
irix_sigaction(int sig, const struct sigaction __user *act,
|
||||
struct sigaction __user *oact, void __user *trampoline)
|
||||
{
|
||||
struct k_sigaction new_ka, old_ka;
|
||||
int ret;
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
printk(" (%d,%s,%s,%08lx) ", sig, (!new ? "0" : "NEW"),
|
||||
(!old ? "0" : "OLD"), trampoline);
|
||||
if(new) {
|
||||
dump_sigact_irix5(new); printk(" ");
|
||||
}
|
||||
#endif
|
||||
if (act) {
|
||||
sigset_t mask;
|
||||
int err;
|
||||
|
||||
if (!access_ok(VERIFY_READ, act, sizeof(*act)))
|
||||
return -EFAULT;
|
||||
err = __get_user(new_ka.sa.sa_handler, &act->sa_handler);
|
||||
err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
|
||||
|
||||
err |= __copy_from_user(&mask, &act->sa_mask, sizeof(sigset_t)) ? -EFAULT : 0;
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/*
|
||||
* Hmmm... methinks IRIX libc always passes a valid trampoline
|
||||
* value for all invocations of sigaction. Will have to
|
||||
* investigate. POSIX POSIX, die die die...
|
||||
*/
|
||||
new_ka.sa_restorer = trampoline;
|
||||
}
|
||||
|
||||
/* XXX Implement SIG_SETMASK32 for IRIX compatibility */
|
||||
ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
|
||||
|
||||
if (!ret && oact) {
|
||||
int err;
|
||||
|
||||
if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
|
||||
return -EFAULT;
|
||||
|
||||
err = __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
|
||||
err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
|
||||
err |= __copy_to_user(&oact->sa_mask, &old_ka.sa.sa_mask,
|
||||
sizeof(sigset_t)) ? -EFAULT : 0;
|
||||
if (err)
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
asmlinkage int irix_sigpending(irix_sigset_t __user *set)
|
||||
{
|
||||
return do_sigpending(set, sizeof(*set));
|
||||
}
|
||||
|
||||
asmlinkage int irix_sigprocmask(int how, irix_sigset_t __user *new,
|
||||
irix_sigset_t __user *old)
|
||||
{
|
||||
sigset_t oldbits, newbits;
|
||||
|
||||
if (new) {
|
||||
if (!access_ok(VERIFY_READ, new, sizeof(*new)))
|
||||
return -EFAULT;
|
||||
if (__copy_from_user(&newbits, new, sizeof(unsigned long)*4))
|
||||
return -EFAULT;
|
||||
sigdelsetmask(&newbits, ~_BLOCKABLE);
|
||||
|
||||
spin_lock_irq(¤t->sighand->siglock);
|
||||
oldbits = current->blocked;
|
||||
|
||||
switch(how) {
|
||||
case 1:
|
||||
sigorsets(&newbits, &oldbits, &newbits);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
sigandsets(&newbits, &oldbits, &newbits);
|
||||
break;
|
||||
|
||||
case 3:
|
||||
break;
|
||||
|
||||
case 256:
|
||||
siginitset(&newbits, newbits.sig[0]);
|
||||
break;
|
||||
|
||||
default:
|
||||
spin_unlock_irq(¤t->sighand->siglock);
|
||||
return -EINVAL;
|
||||
}
|
||||
recalc_sigpending();
|
||||
spin_unlock_irq(¤t->sighand->siglock);
|
||||
}
|
||||
if (old)
|
||||
return copy_to_user(old, ¤t->blocked,
|
||||
sizeof(unsigned long)*4) ? -EFAULT : 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
asmlinkage int irix_sigsuspend(struct pt_regs *regs)
|
||||
{
|
||||
sigset_t newset;
|
||||
sigset_t __user *uset;
|
||||
|
||||
uset = (sigset_t __user *) regs->regs[4];
|
||||
if (copy_from_user(&newset, uset, sizeof(sigset_t)))
|
||||
return -EFAULT;
|
||||
sigdelsetmask(&newset, ~_BLOCKABLE);
|
||||
|
||||
spin_lock_irq(¤t->sighand->siglock);
|
||||
current->saved_sigmask = current->blocked;
|
||||
current->blocked = newset;
|
||||
recalc_sigpending();
|
||||
spin_unlock_irq(¤t->sighand->siglock);
|
||||
|
||||
current->state = TASK_INTERRUPTIBLE;
|
||||
schedule();
|
||||
set_thread_flag(TIF_RESTORE_SIGMASK);
|
||||
return -ERESTARTNOHAND;
|
||||
}
|
||||
|
||||
/* hate hate hate... */
|
||||
struct irix5_siginfo {
|
||||
int sig, code, error;
|
||||
union {
|
||||
char unused[128 - (3 * 4)]; /* Safety net. */
|
||||
struct {
|
||||
int pid;
|
||||
union {
|
||||
int uid;
|
||||
struct {
|
||||
int utime, status, stime;
|
||||
} child;
|
||||
} procdata;
|
||||
} procinfo;
|
||||
|
||||
unsigned long fault_addr;
|
||||
|
||||
struct {
|
||||
int fd;
|
||||
long band;
|
||||
} fileinfo;
|
||||
|
||||
unsigned long sigval;
|
||||
} stuff;
|
||||
};
|
||||
|
||||
asmlinkage int irix_sigpoll_sys(unsigned long __user *set,
|
||||
struct irix5_siginfo __user *info, struct timespec __user *tp)
|
||||
{
|
||||
long expire = MAX_SCHEDULE_TIMEOUT;
|
||||
sigset_t kset;
|
||||
int i, sig, error, timeo = 0;
|
||||
struct timespec ktp;
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] irix_sigpoll_sys(%p,%p,%p)\n",
|
||||
current->comm, current->pid, set, info, tp);
|
||||
#endif
|
||||
|
||||
/* Must always specify the signal set. */
|
||||
if (!set)
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&kset, set, sizeof(set)))
|
||||
return -EFAULT;
|
||||
|
||||
if (info && clear_user(info, sizeof(*info))) {
|
||||
error = -EFAULT;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (tp) {
|
||||
if (copy_from_user(&ktp, tp, sizeof(*tp)))
|
||||
return -EFAULT;
|
||||
|
||||
if (!ktp.tv_sec && !ktp.tv_nsec)
|
||||
return -EINVAL;
|
||||
|
||||
expire = timespec_to_jiffies(&ktp) +
|
||||
(ktp.tv_sec || ktp.tv_nsec);
|
||||
}
|
||||
|
||||
while(1) {
|
||||
long tmp = 0;
|
||||
|
||||
expire = schedule_timeout_interruptible(expire);
|
||||
|
||||
for (i=0; i < _IRIX_NSIG_WORDS; i++)
|
||||
tmp |= (current->pending.signal.sig[i] & kset.sig[i]);
|
||||
|
||||
if (tmp)
|
||||
break;
|
||||
if (!expire) {
|
||||
timeo = 1;
|
||||
break;
|
||||
}
|
||||
if (signal_pending(current))
|
||||
return -EINTR;
|
||||
}
|
||||
if (timeo)
|
||||
return -EAGAIN;
|
||||
|
||||
for (sig = 1; i <= 65 /* IRIX_NSIG */; sig++) {
|
||||
if (sigismember (&kset, sig))
|
||||
continue;
|
||||
if (sigismember (¤t->pending.signal, sig)) {
|
||||
/* XXX need more than this... */
|
||||
if (info)
|
||||
return copy_to_user(&info->sig, &sig, sizeof(sig));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Should not get here, but do something sane if we do. */
|
||||
error = -EINTR;
|
||||
|
||||
out:
|
||||
return error;
|
||||
}
|
||||
|
||||
/* This is here because of irix5_siginfo definition. */
|
||||
#define IRIX_P_PID 0
|
||||
#define IRIX_P_PGID 2
|
||||
#define IRIX_P_ALL 7
|
||||
|
||||
#define W_EXITED 1
|
||||
#define W_TRAPPED 2
|
||||
#define W_STOPPED 4
|
||||
#define W_CONT 8
|
||||
#define W_NOHANG 64
|
||||
|
||||
#define W_MASK (W_EXITED | W_TRAPPED | W_STOPPED | W_CONT | W_NOHANG)
|
||||
|
||||
asmlinkage int irix_waitsys(int type, int upid,
|
||||
struct irix5_siginfo __user *info, int options,
|
||||
struct rusage __user *ru)
|
||||
{
|
||||
struct pid *pid = NULL;
|
||||
int flag, retval;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
struct task_struct *tsk;
|
||||
struct task_struct *p;
|
||||
struct list_head *_p;
|
||||
|
||||
if (!info)
|
||||
return -EINVAL;
|
||||
|
||||
if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
|
||||
return -EFAULT;
|
||||
|
||||
if (ru)
|
||||
if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)))
|
||||
return -EFAULT;
|
||||
|
||||
if (options & ~W_MASK)
|
||||
return -EINVAL;
|
||||
|
||||
if (type != IRIX_P_PID && type != IRIX_P_PGID && type != IRIX_P_ALL)
|
||||
return -EINVAL;
|
||||
|
||||
if (type != IRIX_P_ALL)
|
||||
pid = find_get_pid(upid);
|
||||
add_wait_queue(¤t->signal->wait_chldexit, &wait);
|
||||
repeat:
|
||||
flag = 0;
|
||||
current->state = TASK_INTERRUPTIBLE;
|
||||
read_lock(&tasklist_lock);
|
||||
tsk = current;
|
||||
list_for_each(_p, &tsk->children) {
|
||||
p = list_entry(_p, struct task_struct, sibling);
|
||||
if ((type == IRIX_P_PID) && task_pid(p) != pid)
|
||||
continue;
|
||||
if ((type == IRIX_P_PGID) && task_pgrp(p) != pid)
|
||||
continue;
|
||||
if ((p->exit_signal != SIGCHLD))
|
||||
continue;
|
||||
flag = 1;
|
||||
switch (p->state) {
|
||||
case TASK_STOPPED:
|
||||
if (!p->exit_code)
|
||||
continue;
|
||||
if (!(options & (W_TRAPPED|W_STOPPED)) &&
|
||||
!(p->ptrace & PT_PTRACED))
|
||||
continue;
|
||||
read_unlock(&tasklist_lock);
|
||||
|
||||
/* move to end of parent's list to avoid starvation */
|
||||
write_lock_irq(&tasklist_lock);
|
||||
remove_parent(p);
|
||||
add_parent(p);
|
||||
write_unlock_irq(&tasklist_lock);
|
||||
retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
|
||||
if (retval)
|
||||
goto end_waitsys;
|
||||
|
||||
retval = __put_user(SIGCHLD, &info->sig);
|
||||
retval |= __put_user(0, &info->code);
|
||||
retval |= __put_user(task_pid_vnr(p), &info->stuff.procinfo.pid);
|
||||
retval |= __put_user((p->exit_code >> 8) & 0xff,
|
||||
&info->stuff.procinfo.procdata.child.status);
|
||||
retval |= __put_user(p->utime, &info->stuff.procinfo.procdata.child.utime);
|
||||
retval |= __put_user(p->stime, &info->stuff.procinfo.procdata.child.stime);
|
||||
if (retval)
|
||||
goto end_waitsys;
|
||||
|
||||
p->exit_code = 0;
|
||||
goto end_waitsys;
|
||||
|
||||
case EXIT_ZOMBIE:
|
||||
current->signal->cutime += p->utime + p->signal->cutime;
|
||||
current->signal->cstime += p->stime + p->signal->cstime;
|
||||
if (ru != NULL)
|
||||
getrusage(p, RUSAGE_BOTH, ru);
|
||||
retval = __put_user(SIGCHLD, &info->sig);
|
||||
retval |= __put_user(1, &info->code); /* CLD_EXITED */
|
||||
retval |= __put_user(task_pid_vnr(p), &info->stuff.procinfo.pid);
|
||||
retval |= __put_user((p->exit_code >> 8) & 0xff,
|
||||
&info->stuff.procinfo.procdata.child.status);
|
||||
retval |= __put_user(p->utime,
|
||||
&info->stuff.procinfo.procdata.child.utime);
|
||||
retval |= __put_user(p->stime,
|
||||
&info->stuff.procinfo.procdata.child.stime);
|
||||
if (retval)
|
||||
goto end_waitsys;
|
||||
|
||||
if (p->real_parent != p->parent) {
|
||||
write_lock_irq(&tasklist_lock);
|
||||
remove_parent(p);
|
||||
p->parent = p->real_parent;
|
||||
add_parent(p);
|
||||
do_notify_parent(p, SIGCHLD);
|
||||
write_unlock_irq(&tasklist_lock);
|
||||
} else
|
||||
release_task(p);
|
||||
goto end_waitsys;
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
tsk = next_thread(tsk);
|
||||
}
|
||||
read_unlock(&tasklist_lock);
|
||||
if (flag) {
|
||||
retval = 0;
|
||||
if (options & W_NOHANG)
|
||||
goto end_waitsys;
|
||||
retval = -ERESTARTSYS;
|
||||
if (signal_pending(current))
|
||||
goto end_waitsys;
|
||||
current->state = TASK_INTERRUPTIBLE;
|
||||
schedule();
|
||||
goto repeat;
|
||||
}
|
||||
retval = -ECHILD;
|
||||
end_waitsys:
|
||||
current->state = TASK_RUNNING;
|
||||
remove_wait_queue(¤t->signal->wait_chldexit, &wait);
|
||||
put_pid(pid);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
struct irix5_context {
|
||||
u32 flags;
|
||||
u32 link;
|
||||
u32 sigmask[4];
|
||||
struct { u32 sp, size, flags; } stack;
|
||||
int regs[36];
|
||||
u32 fpregs[32];
|
||||
u32 fpcsr;
|
||||
u32 _unused0;
|
||||
u32 _unused1[47];
|
||||
u32 weird_graphics_thing;
|
||||
};
|
||||
|
||||
asmlinkage int irix_getcontext(struct pt_regs *regs)
|
||||
{
|
||||
int error, i, base = 0;
|
||||
struct irix5_context __user *ctx;
|
||||
unsigned long flags;
|
||||
|
||||
if (regs->regs[2] == 1000)
|
||||
base = 1;
|
||||
ctx = (struct irix5_context __user *) regs->regs[base + 4];
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] irix_getcontext(%p)\n",
|
||||
current->comm, current->pid, ctx);
|
||||
#endif
|
||||
|
||||
if (!access_ok(VERIFY_WRITE, ctx, sizeof(*ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
error = __put_user(current->thread.irix_oldctx, &ctx->link);
|
||||
|
||||
error |= __copy_to_user(&ctx->sigmask, ¤t->blocked, sizeof(irix_sigset_t)) ? -EFAULT : 0;
|
||||
|
||||
/* XXX Do sigstack stuff someday... */
|
||||
error |= __put_user(0, &ctx->stack.sp);
|
||||
error |= __put_user(0, &ctx->stack.size);
|
||||
error |= __put_user(0, &ctx->stack.flags);
|
||||
|
||||
error |= __put_user(0, &ctx->weird_graphics_thing);
|
||||
error |= __put_user(0, &ctx->regs[0]);
|
||||
for (i = 1; i < 32; i++)
|
||||
error |= __put_user(regs->regs[i], &ctx->regs[i]);
|
||||
error |= __put_user(regs->lo, &ctx->regs[32]);
|
||||
error |= __put_user(regs->hi, &ctx->regs[33]);
|
||||
error |= __put_user(regs->cp0_cause, &ctx->regs[34]);
|
||||
error |= __put_user(regs->cp0_epc, &ctx->regs[35]);
|
||||
|
||||
flags = 0x0f;
|
||||
if (!used_math()) {
|
||||
flags &= ~(0x08);
|
||||
} else {
|
||||
/* XXX wheee... */
|
||||
printk("Wheee, no code for saving IRIX FPU context yet.\n");
|
||||
}
|
||||
error |= __put_user(flags, &ctx->flags);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
asmlinkage void irix_setcontext(struct pt_regs *regs)
|
||||
{
|
||||
struct irix5_context __user *ctx;
|
||||
int err, base = 0;
|
||||
u32 flags;
|
||||
|
||||
if (regs->regs[2] == 1000)
|
||||
base = 1;
|
||||
ctx = (struct irix5_context __user *) regs->regs[base + 4];
|
||||
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] irix_setcontext(%p)\n",
|
||||
current->comm, current->pid, ctx);
|
||||
#endif
|
||||
|
||||
if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)))
|
||||
goto segv_and_exit;
|
||||
|
||||
err = __get_user(flags, &ctx->flags);
|
||||
if (flags & 0x02) {
|
||||
/* XXX sigstack garbage, todo... */
|
||||
printk("Wheee, cannot do sigstack stuff in setcontext\n");
|
||||
}
|
||||
|
||||
if (flags & 0x04) {
|
||||
int i;
|
||||
|
||||
/* XXX extra control block stuff... todo... */
|
||||
for (i = 1; i < 32; i++)
|
||||
err |= __get_user(regs->regs[i], &ctx->regs[i]);
|
||||
err |= __get_user(regs->lo, &ctx->regs[32]);
|
||||
err |= __get_user(regs->hi, &ctx->regs[33]);
|
||||
err |= __get_user(regs->cp0_epc, &ctx->regs[35]);
|
||||
}
|
||||
|
||||
if (flags & 0x08)
|
||||
/* XXX fpu context, blah... */
|
||||
printk(KERN_ERR "Wheee, cannot restore FPU context yet...\n");
|
||||
|
||||
err |= __get_user(current->thread.irix_oldctx, &ctx->link);
|
||||
if (err)
|
||||
goto segv_and_exit;
|
||||
|
||||
/*
|
||||
* Don't let your children do this ...
|
||||
*/
|
||||
__asm__ __volatile__(
|
||||
"move\t$29,%0\n\t"
|
||||
"j\tsyscall_exit"
|
||||
:/* no outputs */
|
||||
:"r" (®s));
|
||||
/* Unreached */
|
||||
|
||||
segv_and_exit:
|
||||
force_sigsegv(SIGSEGV, current);
|
||||
}
|
||||
|
||||
struct irix_sigstack {
|
||||
unsigned long sp;
|
||||
int status;
|
||||
};
|
||||
|
||||
asmlinkage int irix_sigstack(struct irix_sigstack __user *new,
|
||||
struct irix_sigstack __user *old)
|
||||
{
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] irix_sigstack(%p,%p)\n",
|
||||
current->comm, current->pid, new, old);
|
||||
#endif
|
||||
if (new) {
|
||||
if (!access_ok(VERIFY_READ, new, sizeof(*new)))
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (old) {
|
||||
if (!access_ok(VERIFY_WRITE, old, sizeof(*old)))
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct irix_sigaltstack { unsigned long sp; int size; int status; };
|
||||
|
||||
asmlinkage int irix_sigaltstack(struct irix_sigaltstack __user *new,
|
||||
struct irix_sigaltstack __user *old)
|
||||
{
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] irix_sigaltstack(%p,%p)\n",
|
||||
current->comm, current->pid, new, old);
|
||||
#endif
|
||||
if (new)
|
||||
if (!access_ok(VERIFY_READ, new, sizeof(*new)))
|
||||
return -EFAULT;
|
||||
|
||||
if (old) {
|
||||
if (!access_ok(VERIFY_WRITE, old, sizeof(*old)))
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct irix_procset {
|
||||
int cmd, ltype, lid, rtype, rid;
|
||||
};
|
||||
|
||||
asmlinkage int irix_sigsendset(struct irix_procset __user *pset, int sig)
|
||||
{
|
||||
if (!access_ok(VERIFY_READ, pset, sizeof(*pset)))
|
||||
return -EFAULT;
|
||||
#ifdef DEBUG_SIG
|
||||
printk("[%s:%d] irix_sigsendset([%d,%d,%d,%d,%d],%d)\n",
|
||||
current->comm, current->pid,
|
||||
pset->cmd, pset->ltype, pset->lid, pset->rtype, pset->rid,
|
||||
sig);
|
||||
#endif
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
@ -125,13 +125,6 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
|
|||
*childregs = *regs;
|
||||
childregs->regs[7] = 0; /* Clear error flag */
|
||||
|
||||
#if defined(CONFIG_BINFMT_IRIX)
|
||||
if (current->personality != PER_LINUX) {
|
||||
/* Under IRIX things are a little different. */
|
||||
childregs->regs[3] = 1;
|
||||
regs->regs[3] = 0;
|
||||
}
|
||||
#endif
|
||||
childregs->regs[2] = 0; /* Child gets zero as return value */
|
||||
regs->regs[2] = p->pid;
|
||||
|
||||
|
|
|
|||
|
|
@ -34,12 +34,8 @@ NESTED(handle_sys, PT_SIZE, sp)
|
|||
|
||||
lw t1, PT_EPC(sp) # skip syscall on return
|
||||
|
||||
#if defined(CONFIG_BINFMT_IRIX)
|
||||
sltiu t0, v0, MAX_SYSCALL_NO + 1 # check syscall number
|
||||
#else
|
||||
subu v0, v0, __NR_O32_Linux # check syscall number
|
||||
sltiu t0, v0, __NR_O32_Linux_syscalls + 1
|
||||
#endif
|
||||
addiu t1, 4 # skip to next instruction
|
||||
sw t1, PT_EPC(sp)
|
||||
beqz t0, illegal_syscall
|
||||
|
|
@ -264,22 +260,14 @@ bad_alignment:
|
|||
END(sys_sysmips)
|
||||
|
||||
LEAF(sys_syscall)
|
||||
#if defined(CONFIG_BINFMT_IRIX)
|
||||
sltiu v0, a0, MAX_SYSCALL_NO + 1 # check syscall number
|
||||
#else
|
||||
subu t0, a0, __NR_O32_Linux # check syscall number
|
||||
sltiu v0, t0, __NR_O32_Linux_syscalls + 1
|
||||
#endif
|
||||
sll t1, t0, 3
|
||||
beqz v0, einval
|
||||
|
||||
lw t2, sys_call_table(t1) # syscall routine
|
||||
|
||||
#if defined(CONFIG_BINFMT_IRIX)
|
||||
li v1, 4000 # nr of sys_syscall
|
||||
#else
|
||||
li v1, 4000 - __NR_O32_Linux # index of sys_syscall
|
||||
#endif
|
||||
beq t0, v1, einval # do not recurse
|
||||
|
||||
/* Some syscalls like execve get their arguments from struct pt_regs
|
||||
|
|
@ -324,13 +312,6 @@ einval: li v0, -EINVAL
|
|||
.endm
|
||||
|
||||
.macro syscalltable
|
||||
#if defined(CONFIG_BINFMT_IRIX)
|
||||
mille sys_ni_syscall 0 /* 0 - 999 SVR4 flavour */
|
||||
mille sys_ni_syscall 0 /* 1000 - 1999 32-bit IRIX */
|
||||
mille sys_ni_syscall 0 /* 2000 - 2999 BSD43 flavour */
|
||||
mille sys_ni_syscall 0 /* 3000 - 3999 POSIX flavour */
|
||||
#endif
|
||||
|
||||
sys sys_syscall 8 /* 4000 */
|
||||
sys sys_exit 1
|
||||
sys sys_fork 0
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,24 +0,0 @@
|
|||
/*
|
||||
* Miguel de Icaza
|
||||
*/
|
||||
#ifndef __ASM_INVENTORY_H
|
||||
#define __ASM_INVENTORY_H
|
||||
|
||||
#include <linux/compiler.h>
|
||||
|
||||
typedef struct inventory_s {
|
||||
struct inventory_s *inv_next;
|
||||
int inv_class;
|
||||
int inv_type;
|
||||
int inv_controller;
|
||||
int inv_unit;
|
||||
int inv_state;
|
||||
} inventory_t;
|
||||
|
||||
extern int inventory_items;
|
||||
|
||||
extern void add_to_inventory(int class, int type, int controller, int unit, int state);
|
||||
extern int dump_inventory_to_user(void __user *userbuf, int size);
|
||||
extern int __init init_inventory(void);
|
||||
|
||||
#endif /* __ASM_INVENTORY_H */
|
||||
|
|
@ -1,26 +1,11 @@
|
|||
#ifndef _ASM_NAMEI_H
|
||||
#define _ASM_NAMEI_H
|
||||
|
||||
#include <linux/personality.h>
|
||||
#include <linux/stddef.h>
|
||||
/*
|
||||
* This dummy routine maybe changed to something useful
|
||||
* for /usr/gnemul/ emulation stuff.
|
||||
*/
|
||||
|
||||
#define IRIX_EMUL "/usr/gnemul/irix/"
|
||||
#define RISCOS_EMUL "/usr/gnemul/riscos/"
|
||||
|
||||
static inline char *__emul_prefix(void)
|
||||
{
|
||||
switch (current->personality) {
|
||||
case PER_IRIX32:
|
||||
case PER_IRIXN32:
|
||||
case PER_IRIX64:
|
||||
return IRIX_EMUL;
|
||||
|
||||
case PER_RISCOS:
|
||||
return RISCOS_EMUL;
|
||||
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
#define __emul_prefix() NULL
|
||||
|
||||
#endif /* _ASM_NAMEI_H */
|
||||
|
|
|
|||
|
|
@ -1,41 +0,0 @@
|
|||
/*
|
||||
* IRIX prctl interface
|
||||
*
|
||||
* The IRIX kernel maps a page at PRDA_ADDRESS with the
|
||||
* contents of prda and fills it the bits on prda_sys.
|
||||
*/
|
||||
|
||||
#ifndef __PRCTL_H__
|
||||
#define __PRCTL_H__
|
||||
|
||||
#define PRDA_ADDRESS 0x200000L
|
||||
#define PRDA ((struct prda *) PRDA_ADDRESS)
|
||||
|
||||
struct prda_sys {
|
||||
pid_t t_pid;
|
||||
u32 t_hint;
|
||||
u32 t_dlactseq;
|
||||
u32 t_fpflags;
|
||||
u32 t_prid; /* processor type, $prid CP0 register */
|
||||
u32 t_dlendseq;
|
||||
u64 t_unused1[5];
|
||||
pid_t t_rpid;
|
||||
s32 t_resched;
|
||||
u32 t_unused[8];
|
||||
u32 t_cpu; /* current/last cpu */
|
||||
|
||||
/* FIXME: The signal information, not supported by Linux now */
|
||||
u32 t_flags; /* if true, then the sigprocmask is in userspace */
|
||||
u32 t_sigprocmask [1]; /* the sigprocmask */
|
||||
};
|
||||
|
||||
struct prda {
|
||||
char fill [0xe00];
|
||||
struct prda_sys prda_sys;
|
||||
};
|
||||
|
||||
#define t_sys prda_sys
|
||||
|
||||
ptrdiff_t prctl(int op, int v1, int v2);
|
||||
|
||||
#endif
|
||||
|
|
@ -119,9 +119,6 @@ struct sigaction {
|
|||
|
||||
struct k_sigaction {
|
||||
struct sigaction sa;
|
||||
#ifdef CONFIG_BINFMT_IRIX
|
||||
void (*sa_restorer)(void);
|
||||
#endif
|
||||
};
|
||||
|
||||
/* IRIX compatible stack_t */
|
||||
|
|
|
|||
Loading…
Reference in a new issue