linux-imx

/*    Signal support for 32-bit kernel builds

 *

 *    Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org>

 *    Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org>

 *

 *    Code was mostly borrowed from kernel/signal.c.

 *    See kernel/signal.c for additional Copyrights.

 *

 *

 *    This program is free software; you can redistribute it and/or modify

 *    it under the terms of the GNU General Public License as published by

 *    the Free Software Foundation; either version 2 of the License, or

 *    (at your option) any later version.

 *

 *    This program is distributed in the hope that it will be useful,

 *    but WITHOUT ANY WARRANTY; without even the implied warranty of

 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *    GNU General Public License for more details.

 *

 *    You should have received a copy of the GNU General Public License

 *    along with this program; if not, write to the Free Software

 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

​

#include <linux/compat.h>

#include <linux/module.h>

#include <linux/unistd.h>

#include <linux/init.h>

#include <linux/sched.h>

#include <linux/syscalls.h>

#include <linux/types.h>

#include <linux/errno.h>

​

#include <linux/uaccess.h>

​

#include "signal32.h"

​

#define DEBUG_COMPAT_SIG 0 

#define DEBUG_COMPAT_SIG_LEVEL 2

​

#if DEBUG_COMPAT_SIG

#define DBG(LEVEL, ...) \

    ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \

    ? printk(__VA_ARGS__) : (void) 0)

#else

#define DBG(LEVEL, ...)

#endif

​

long

restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,

        struct pt_regs *regs)

{

    long err = 0;

    compat_uint_t compat_reg;

    compat_uint_t compat_regt;

    int regn;

    /* When loading 32-bit values into 64-bit registers make

       sure to clear the upper 32-bits */

    DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");

    DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs);

    DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc));

    for(regn=0; regn < 32; regn++){

        err |= __get_user(compat_reg,&sc->sc_gr[regn]);

        regs->gr[regn] = compat_reg;

        /* Load upper half */

        err |= __get_user(compat_regt,&rf->rf_gr[regn]);

        regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg;

        DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n", 

                regn, regs->gr[regn], compat_regt, compat_reg);

    }

    DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr));

    /* XXX: BE WARNED FR's are 64-BIT! */

    err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));

    /* Better safe than sorry, pass __get_user two things of

       the same size and let gcc do the upward conversion to 

       64-bits */       

    err |= __get_user(compat_reg, &sc->sc_iaoq[0]);

    /* Load upper half */

    err |= __get_user(compat_regt, &rf->rf_iaoq[0]);

    regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;

    DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt);

    DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n", 

            &sc->sc_iaoq[0], compat_reg);

​

    err |= __get_user(compat_reg, &sc->sc_iaoq[1]);

    /* Load upper half */

    err |= __get_user(compat_regt, &rf->rf_iaoq[1]);

    regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;

    DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt);

    DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n",