Patched in Tegra support.

10 files changed, 202 insertions, 45 deletions

diff --git a/arch/m32r/kernel/Makefile b/arch/m32r/kernel/Makefile
index 0c09dad8b1f..b1a4b603659 100644
--- a/arch/m32r/kernel/Makefile
+++ b/arch/m32r/kernel/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the Linux/M32R kernel.
 #
 
-extra-y := head.o vmlinux.lds
+extra-y := head.o init_task.o vmlinux.lds
 
 obj-y   := process.o entry.o traps.o align.o irq.o setup.o time.o \
         m32r_ksyms.o sys_m32r.o signal.o ptrace.o
diff --git a/arch/m32r/kernel/entry.S b/arch/m32r/kernel/entry.S
index 0c01543f10c..225412bc227 100644
--- a/arch/m32r/kernel/entry.S
+++ b/arch/m32r/kernel/entry.S
@@ -125,15 +125,6 @@
         and     \reg, sp
         .endm
 
-ENTRY(ret_from_kernel_thread)
-        pop     r0
-        bl      schedule_tail
-        GET_THREAD_INFO(r8)
-        ld      r0, R0(r8)
-        ld      r1, R1(r8)
-        jl      r1
-        bra     syscall_exit
-
 ENTRY(ret_from_fork)
         pop     r0
         bl      schedule_tail
diff --git a/arch/m32r/kernel/m32r_ksyms.c b/arch/m32r/kernel/m32r_ksyms.c
index b727e693c80..700570747a9 100644
--- a/arch/m32r/kernel/m32r_ksyms.c
+++ b/arch/m32r/kernel/m32r_ksyms.c
@@ -21,6 +21,7 @@ EXPORT_SYMBOL(boot_cpu_data);
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
+EXPORT_SYMBOL(kernel_thread);
 
 EXPORT_SYMBOL(strncpy_from_user);
 EXPORT_SYMBOL(__strncpy_from_user);
diff --git a/arch/m32r/kernel/module.c b/arch/m32r/kernel/module.c
index 38233b6596b..3071fe83ffc 100644
--- a/arch/m32r/kernel/module.c
+++ b/arch/m32r/kernel/module.c
@@ -201,3 +201,18 @@ int apply_relocate_add(Elf32_Shdr *sechdrs,
         }
         return 0;
 }
+
+int apply_relocate(Elf32_Shdr *sechdrs,
+                       const char *strtab,
+                       unsigned int symindex,
+                       unsigned int relsec,
+                       struct module *me)
+{
+#if 0
+        printk(KERN_ERR "module %s: REL RELOCATION unsupported\n",
+               me->name);
+        return -ENOEXEC;
+#endif
+        return 0;
+
+}
diff --git a/arch/m32r/kernel/process.c b/arch/m32r/kernel/process.c
index 765d0f57c78..422bea9f1db 100644
--- a/arch/m32r/kernel/process.c
+++ b/arch/m32r/kernel/process.c
@@ -26,7 +26,6 @@
 #include <linux/ptrace.h>
 #include <linux/unistd.h>
 #include <linux/hardirq.h>
-#include <linux/rcupdate.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -83,7 +82,6 @@ void cpu_idle (void)
 {
         /* endless idle loop with no priority at all */
         while (1) {
-                rcu_idle_enter();
                 while (!need_resched()) {
                         void (*idle)(void) = pm_idle;
 
@@ -92,8 +90,9 @@ void cpu_idle (void)
 
                         idle();
                 }
-                rcu_idle_exit();
-                schedule_preempt_disabled();
+                preempt_enable_no_resched();
+                schedule();
+                preempt_disable();
         }
 }
 
@@ -165,6 +164,41 @@ void show_regs(struct pt_regs * regs)
 }
 
 /*
+ * Create a kernel thread
+ */
+
+/*
+ * This is the mechanism for creating a new kernel thread.
+ *
+ * NOTE! Only a kernel-only process(ie the swapper or direct descendants
+ * who haven't done an "execve()") should use this: it will work within
+ * a system call from a "real" process, but the process memory space will
+ * not be free'd until both the parent and the child have exited.
+ */
+static void kernel_thread_helper(void *nouse, int (*fn)(void *), void *arg)
+{
+        fn(arg);
+        do_exit(-1);
+}
+
+int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+        struct pt_regs regs;
+
+        memset(&regs, 0, sizeof (regs));
+        regs.r1 = (unsigned long)fn;
+        regs.r2 = (unsigned long)arg;
+
+        regs.bpc = (unsigned long)kernel_thread_helper;
+
+        regs.psw = M32R_PSW_BIE;
+
+        /* Ok, create the new process. */
+        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL,
+                NULL);
+}
+
+/*
  * Free current thread data structures etc..
  */
 void exit_thread(void)
@@ -192,31 +226,88 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 }
 
 int copy_thread(unsigned long clone_flags, unsigned long spu,
-        unsigned long arg, struct task_struct *tsk)
+        unsigned long unused, struct task_struct *tsk, struct pt_regs *regs)
 {
         struct pt_regs *childregs = task_pt_regs(tsk);
         extern void ret_from_fork(void);
-        extern void ret_from_kernel_thread(void);
-
-        if (unlikely(tsk->flags & PF_KTHREAD)) {
-                memset(childregs, 0, sizeof(struct pt_regs));
-                childregs->psw = M32R_PSW_BIE;
-                childregs->r1 = spu;    /* fn */
-                childregs->r0 = arg;
-                tsk->thread.lr = (unsigned long)ret_from_kernel_thread;
-        } else {
-                /* Copy registers */
-                *childregs = *current_pt_regs();
-                if (spu)
-                        childregs->spu = spu;
-                childregs->r0 = 0;      /* Child gets zero as return value */
-                tsk->thread.lr = (unsigned long)ret_from_fork;
-        }
+
+        /* Copy registers */
+        *childregs = *regs;
+
+        childregs->spu = spu;
+        childregs->r0 = 0;      /* Child gets zero as return value */
+        regs->r0 = tsk->pid;
         tsk->thread.sp = (unsigned long)childregs;
+        tsk->thread.lr = (unsigned long)ret_from_fork;
 
         return 0;
 }
 
+asmlinkage int sys_fork(unsigned long r0, unsigned long r1, unsigned long r2,
+        unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6,
+        struct pt_regs regs)
+{
+#ifdef CONFIG_MMU
+        return do_fork(SIGCHLD, regs.spu, &regs, 0, NULL, NULL);
+#else
+        return -EINVAL;
+#endif /* CONFIG_MMU */
+}
+
+asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
+                         unsigned long parent_tidptr,
+                         unsigned long child_tidptr,
+                         unsigned long r4, unsigned long r5, unsigned long r6,
+                         struct pt_regs regs)
+{
+        if (!newsp)
+                newsp = regs.spu;
+
+        return do_fork(clone_flags, newsp, &regs, 0,
+                       (int __user *)parent_tidptr, (int __user *)child_tidptr);
+}
+
+/*
+ * This is trivial, and on the face of it looks like it
+ * could equally well be done in user mode.
+ *
+ * Not so, for quite unobvious reasons - register pressure.
+ * In user mode vfork() cannot have a stack frame, and if
+ * done by calling the "clone()" system call directly, you
+ * do not have enough call-clobbered registers to hold all
+ * the information you need.
+ */
+asmlinkage int sys_vfork(unsigned long r0, unsigned long r1, unsigned long r2,
+        unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6,
+        struct pt_regs regs)
+{
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.spu, &regs, 0,
+                        NULL, NULL);
+}
+
+/*
+ * sys_execve() executes a new program.
+ */
+asmlinkage int sys_execve(const char __user *ufilename,
+                          const char __user *const __user *uargv,
+                          const char __user *const __user *uenvp,
+                          unsigned long r3, unsigned long r4, unsigned long r5,
+                          unsigned long r6, struct pt_regs regs)
+{
+        int error;
+        char *filename;
+
+        filename = getname(ufilename);
+        error = PTR_ERR(filename);
+        if (IS_ERR(filename))
+                goto out;
+
+        error = do_execve(filename, uargv, uenvp, &regs);
+        putname(filename);
+out:
+        return error;
+}
+
 /*
  * These bracket the sleeping functions..
  */
diff --git a/arch/m32r/kernel/ptrace.c b/arch/m32r/kernel/ptrace.c
index 51f5e9aa490..20743754f2b 100644
--- a/arch/m32r/kernel/ptrace.c
+++ b/arch/m32r/kernel/ptrace.c
@@ -29,6 +29,7 @@
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
+#include <asm/system.h>
 #include <asm/processor.h>
 #include <asm/mmu_context.h>
 
@@ -591,16 +592,17 @@ void user_enable_single_step(struct task_struct *child)
 
         if (access_process_vm(child, pc&~3, &insn, sizeof(insn), 0)
             != sizeof(insn))
-                return;
+                return -EIO;
 
         compute_next_pc(insn, pc, &next_pc, child);
         if (next_pc & 0x80000000)
-                return;
+                return -EIO;
 
         if (embed_debug_trap(child, next_pc))
-                return;
+                return -EIO;
 
         invalidate_cache();
+        return 0;
 }
 
 void user_disable_single_step(struct task_struct *child)
diff --git a/arch/m32r/kernel/signal.c b/arch/m32r/kernel/signal.c
index 6e3c26a1607..a08697f0886 100644
--- a/arch/m32r/kernel/signal.c
+++ b/arch/m32r/kernel/signal.c
@@ -20,6 +20,7 @@
 #include <linux/unistd.h>
 #include <linux/stddef.h>
 #include <linux/personality.h>
+#include <linux/freezer.h>
 #include <linux/tracehook.h>
 #include <asm/cacheflush.h>
 #include <asm/ucontext.h>
@@ -27,6 +28,8 @@
 
 #define DEBUG_SIG 0
 
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 asmlinkage int
 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
                 unsigned long r2, unsigned long r3, unsigned long r4,
@@ -108,7 +111,11 @@ sys_rt_sigreturn(unsigned long r0, unsigned long r1,
         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                 goto badframe;
 
-        set_current_blocked(&set);
+        sigdelsetmask(&set, ~_BLOCKABLE);
+        spin_lock_irq(&current->sighand->siglock);
+        current->blocked = set;
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
 
         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &result))
                 goto badframe;
@@ -263,9 +270,9 @@ static int prev_insn(struct pt_regs *regs)
  * OK, we're invoking a handler
  */
 
-static void
+static int
 handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
-              struct pt_regs *regs)
+              sigset_t *oldset, struct pt_regs *regs)
 {
         /* Are we from a system call? */
         if (regs->syscall_nr >= 0) {
@@ -285,15 +292,21 @@ handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
                         case -ERESTARTNOINTR:
                                 regs->r0 = regs->orig_r0;
                                 if (prev_insn(regs) < 0)
-                                        return;
+                                        return -EFAULT;
                 }
         }
 
         /* Set up the stack frame */
-        if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs))
-                return;
+        if (setup_rt_frame(sig, ka, info, oldset, regs))
+                return -EFAULT;
 
-        signal_delivered(sig, info, ka, regs, 0);
+        spin_lock_irq(&current->sighand->siglock);
+        sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
+        if (!(ka->sa.sa_flags & SA_NODEFER))
+                sigaddset(&current->blocked,sig);
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+        return 0;
 }
 
 /*
@@ -306,6 +319,7 @@ static void do_signal(struct pt_regs *regs)
         siginfo_t info;
         int signr;
         struct k_sigaction ka;
+        sigset_t *oldset;
 
         /*
          * We want the common case to go fast, which
@@ -316,6 +330,14 @@ static void do_signal(struct pt_regs *regs)
         if (!user_mode(regs))
                 return;
 
+        if (try_to_freeze()) 
+                goto no_signal;
+
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
+                oldset = &current->blocked;
+
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
         if (signr > 0) {
                 /* Re-enable any watchpoints before delivering the
@@ -325,11 +347,13 @@ static void do_signal(struct pt_regs *regs)
                  */
 
                 /* Whee!  Actually deliver the signal.  */
-                handle_signal(signr, &ka, &info, regs);
+                if (handle_signal(signr, &ka, &info, oldset, regs) == 0)
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
 
                 return;
         }
 
+ no_signal:
         /* Did we come from a system call? */
         if (regs->syscall_nr >= 0) {
                 /* Restart the system call - no handlers present */
@@ -344,7 +368,10 @@ static void do_signal(struct pt_regs *regs)
                         prev_insn(regs);
                 }
         }
-        restore_saved_sigmask();
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 /*
@@ -364,5 +391,9 @@ void do_notify_resume(struct pt_regs *regs, __u32 thread_info_flags)
         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
                 clear_thread_flag(TIF_NOTIFY_RESUME);
                 tracehook_notify_resume(regs);
+                if (current->replacement_session_keyring)
+                        key_replace_session_keyring();
         }
+
+        clear_thread_flag(TIF_IRET);
 }
diff --git a/arch/m32r/kernel/smpboot.c b/arch/m32r/kernel/smpboot.c
index 13168a769f8..cfdbe5d1500 100644
--- a/arch/m32r/kernel/smpboot.c
+++ b/arch/m32r/kernel/smpboot.c
@@ -109,8 +109,12 @@ static unsigned int calibration_result;
 /* Function Prototypes                                                       */
 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 
+void smp_prepare_boot_cpu(void);
+void smp_prepare_cpus(unsigned int);
 static void init_ipi_lock(void);
 static void do_boot_cpu(int);
+int __cpu_up(unsigned int);
+void smp_cpus_done(unsigned int);
 
 int start_secondary(void *);
 static void smp_callin(void);
@@ -127,7 +131,7 @@ static void unmap_cpu_to_physid(int, int);
 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 /* Boot up APs Routines : BSP                                                */
 /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
-void smp_prepare_boot_cpu(void)
+void __devinit smp_prepare_boot_cpu(void)
 {
         bsp_phys_id = hard_smp_processor_id();
         physid_set(bsp_phys_id, phys_cpu_present_map);
@@ -343,7 +347,7 @@ static void __init do_boot_cpu(int phys_id)
         }
 }
 
-int __cpuinit __cpu_up(unsigned int cpu_id, struct task_struct *tidle)
+int __cpuinit __cpu_up(unsigned int cpu_id)
 {
         int timeout;
 
diff --git a/arch/m32r/kernel/sys_m32r.c b/arch/m32r/kernel/sys_m32r.c
index c3fdd632fba..d841fb6cc70 100644
--- a/arch/m32r/kernel/sys_m32r.c
+++ b/arch/m32r/kernel/sys_m32r.c
@@ -88,3 +88,24 @@ asmlinkage int sys_cachectl(char *addr, int nbytes, int op)
         /* Not implemented yet. */
         return -ENOSYS;
 }
+
+/*
+ * Do a system call from kernel instead of calling sys_execve so we
+ * end up with proper pt_regs.
+ */
+int kernel_execve(const char *filename,
+                  const char *const argv[],
+                  const char *const envp[])
+{
+        register long __scno __asm__ ("r7") = __NR_execve;
+        register long __arg3 __asm__ ("r2") = (long)(envp);
+        register long __arg2 __asm__ ("r1") = (long)(argv);
+        register long __res __asm__ ("r0") = (long)(filename);
+        __asm__ __volatile__ (
+                "trap #" SYSCALL_VECTOR "|| nop"
+                : "=r" (__res)
+                : "r" (__scno), "0" (__res), "r" (__arg2),
+                        "r" (__arg3)
+                : "memory");
+        return __res;
+}
diff --git a/arch/m32r/kernel/traps.c b/arch/m32r/kernel/traps.c
index 3bcb207e5b6..ee6a9199561 100644
--- a/arch/m32r/kernel/traps.c
+++ b/arch/m32r/kernel/traps.c
@@ -18,6 +18,7 @@
 #include <asm/page.h>
 #include <asm/processor.h>
 
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <linux/atomic.h>