Patched in Tegra support.

7 files changed, 220 insertions, 52 deletions

diff --git a/arch/score/kernel/Makefile b/arch/score/kernel/Makefile
index fb1802b3f54..f218673b5d3 100644
--- a/arch/score/kernel/Makefile
+++ b/arch/score/kernel/Makefile
@@ -4,7 +4,7 @@
 
 extra-y := head.o vmlinux.lds
 
-obj-y += entry.o irq.o process.o ptrace.o \
+obj-y += entry.o init_task.o irq.o process.o ptrace.o \
         setup.o signal.o sys_score.o time.o traps.o \
         sys_call_table.o
 
diff --git a/arch/score/kernel/entry.S b/arch/score/kernel/entry.S
index 1557ca1a295..577abba3fac 100644
--- a/arch/score/kernel/entry.S
+++ b/arch/score/kernel/entry.S
@@ -278,13 +278,6 @@ need_resched:
         nop
 #endif
 
-ENTRY(ret_from_kernel_thread)
-        bl      schedule_tail                   # r4=struct task_struct *prev
-        nop
-        mv      r4, r13
-        brl     r12
-        j       syscall_exit
-
 ENTRY(ret_from_fork)
         bl      schedule_tail                   # r4=struct task_struct *prev
 
@@ -415,7 +408,7 @@ ENTRY(handle_sys)
         sw      r9, [r0, PT_EPC]
 
         cmpi.c  r27, __NR_syscalls      # check syscall number
-        bgeu    illegal_syscall
+        bgtu    illegal_syscall
 
         slli    r8, r27, 2              # get syscall routine
         la      r11, sys_call_table
@@ -487,6 +480,16 @@ illegal_syscall:
         sw      r9, [r0, PT_R7]
         j       syscall_return
 
+ENTRY(sys_execve)
+        mv      r4, r0
+        la      r8, score_execve
+        br      r8
+
+ENTRY(sys_clone)
+        mv      r4, r0
+        la      r8, score_clone
+        br      r8
+
 ENTRY(sys_rt_sigreturn)
         mv      r4, r0
         la      r8, score_rt_sigreturn
@@ -496,3 +499,16 @@ ENTRY(sys_sigaltstack)
         mv      r4, r0
         la      r8, score_sigaltstack
         br      r8
+
+#ifdef __ARCH_WANT_SYSCALL_DEPRECATED
+ENTRY(sys_fork)
+        mv      r4, r0
+        la      r8, score_fork
+        br      r8
+
+ENTRY(sys_vfork)
+        mv      r4, r0
+        la      r8, score_vfork
+        br      r8
+#endif /* __ARCH_WANT_SYSCALL_DEPRECATED */
+
diff --git a/arch/score/kernel/module.c b/arch/score/kernel/module.c
index 1378d99baa3..469e3b64e2f 100644
--- a/arch/score/kernel/module.c
+++ b/arch/score/kernel/module.c
@@ -125,6 +125,16 @@ int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
         return 0;
 }
 
+int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
+                unsigned int symindex, unsigned int relsec,
+                struct module *me)
+{
+        /* Non-standard return value... most other arch's return -ENOEXEC
+         * for an unsupported relocation variant
+         */
+        return 0;
+}
+
 /* Given an address, look for it in the module exception tables. */
 const struct exception_table_entry *search_module_dbetables(unsigned long addr)
 {
diff --git a/arch/score/kernel/process.c b/arch/score/kernel/process.c
index 79568466b57..25d08030a88 100644
--- a/arch/score/kernel/process.c
+++ b/arch/score/kernel/process.c
@@ -27,7 +27,6 @@
 #include <linux/reboot.h>
 #include <linux/elfcore.h>
 #include <linux/pm.h>
-#include <linux/rcupdate.h>
 
 void (*pm_power_off)(void);
 EXPORT_SYMBOL(pm_power_off);
@@ -51,16 +50,16 @@ void __noreturn cpu_idle(void)
 {
         /* endless idle loop with no priority at all */
         while (1) {
-                rcu_idle_enter();
                 while (!need_resched())
                         barrier();
-                rcu_idle_exit();
-                schedule_preempt_disabled();
+
+                preempt_enable_no_resched();
+                schedule();
+                preempt_disable();
         }
 }
 
 void ret_from_fork(void);
-void ret_from_kernel_thread(void);
 
 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)
 {
@@ -87,27 +86,29 @@ void flush_thread(void) {}
  * set up the kernel stack and exception frames for a new process
  */
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long arg, struct task_struct *p)
+                unsigned long unused,
+                struct task_struct *p, struct pt_regs *regs)
 {
         struct thread_info *ti = task_thread_info(p);
         struct pt_regs *childregs = task_pt_regs(p);
-        struct pt_regs *regs = current_pt_regs();
 
-        p->thread.reg0 = (unsigned long) childregs;
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                memset(childregs, 0, sizeof(struct pt_regs));
-                p->thread->reg12 = usp;
-                p->thread->reg13 = arg;
-                p->thread.reg3 = (unsigned long) ret_from_kernel_thread;
+        p->set_child_tid = NULL;
+        p->clear_child_tid = NULL;
+
+        *childregs = *regs;
+        childregs->regs[7] = 0;         /* Clear error flag */
+        childregs->regs[4] = 0;         /* Child gets zero as return value */
+        regs->regs[4] = p->pid;
+
+        if (childregs->cp0_psr & 0x8) { /* test kernel fork or user fork */
+                childregs->regs[0] = usp;               /* user fork */
         } else {
-                *childregs = *current_pt_regs();
-                childregs->regs[7] = 0;         /* Clear error flag */
-                childregs->regs[4] = 0;         /* Child gets zero as return value */
-                if (usp)
-                        childregs->regs[0] = usp;       /* user fork */
-                p->thread.reg3 = (unsigned long) ret_from_fork;
+                childregs->regs[28] = (unsigned long) ti; /* kernel fork */
+                childregs->regs[0] = (unsigned long) childregs;
         }
 
+        p->thread.reg0 = (unsigned long) childregs;
+        p->thread.reg3 = (unsigned long) ret_from_fork;
         p->thread.cp0_psr = 0;
 
         return 0;
@@ -119,6 +120,32 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
         return 1;
 }
 
+static void __noreturn
+kernel_thread_helper(void *unused0, int (*fn)(void *),
+                 void *arg, void *unused1)
+{
+        do_exit(fn(arg));
+}
+
+/*
+ * Create a kernel thread.
+ */
+long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+        struct pt_regs regs;
+
+        memset(&regs, 0, sizeof(regs));
+
+        regs.regs[6] = (unsigned long) arg;
+        regs.regs[5] = (unsigned long) fn;
+        regs.cp0_epc = (unsigned long) kernel_thread_helper;
+        regs.cp0_psr = (regs.cp0_psr & ~(0x1|0x4|0x8)) | \
+                        ((regs.cp0_psr & 0x3) << 2);
+
+        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, \
+                        0, &regs, 0, NULL, NULL);
+}
+
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
         return task_pt_regs(tsk)->cp0_epc;
diff --git a/arch/score/kernel/setup.c b/arch/score/kernel/setup.c
index b48459afefd..6f898c05787 100644
--- a/arch/score/kernel/setup.c
+++ b/arch/score/kernel/setup.c
@@ -26,7 +26,6 @@
 #include <linux/bootmem.h>
 #include <linux/initrd.h>
 #include <linux/ioport.h>
-#include <linux/memblock.h>
 #include <linux/mm.h>
 #include <linux/seq_file.h>
 #include <linux/screen_info.h>
@@ -55,8 +54,7 @@ static void __init bootmem_init(void)
         /* Initialize the boot-time allocator with low memory only. */
         bootmap_size = init_bootmem_node(NODE_DATA(0), start_pfn,
                                          min_low_pfn, max_low_pfn);
-        memblock_add_node(PFN_PHYS(min_low_pfn),
-                          PFN_PHYS(max_low_pfn - min_low_pfn), 0);
+        add_active_range(0, min_low_pfn, max_low_pfn);
 
         free_bootmem(PFN_PHYS(start_pfn),
                      (max_low_pfn - start_pfn) << PAGE_SHIFT);
diff --git a/arch/score/kernel/signal.c b/arch/score/kernel/signal.c
index 02353bde92d..aa57440e497 100644
--- a/arch/score/kernel/signal.c
+++ b/arch/score/kernel/signal.c
@@ -28,12 +28,13 @@
 #include <linux/ptrace.h>
 #include <linux/unistd.h>
 #include <linux/uaccess.h>
-#include <linux/tracehook.h>
 
 #include <asm/cacheflush.h>
 #include <asm/syscalls.h>
 #include <asm/ucontext.h>
 
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 struct rt_sigframe {
         u32 rs_ass[4];          /* argument save space */
         u32 rs_code[2];         /* signal trampoline */
@@ -148,18 +149,20 @@ score_rt_sigreturn(struct pt_regs *regs)
 {
         struct rt_sigframe __user *frame;
         sigset_t set;
+        stack_t st;
         int sig;
 
-        /* Always make any pending restarted system calls return -EINTR */
-        current_thread_info()->restart_block.fn = do_no_restart_syscall;
-
         frame = (struct rt_sigframe __user *) regs->regs[0];
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->rs_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);
 
         sig = restore_sigcontext(regs, &frame->rs_uc.uc_mcontext);
         if (sig < 0)
@@ -167,11 +170,12 @@ score_rt_sigreturn(struct pt_regs *regs)
         else if (sig)
                 force_sig(sig, current);
 
+        if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
+                goto badframe;
+
         /* It is more difficult to avoid calling this function than to
            call it and ignore errors.  */
-        if (do_sigaltstack(&frame->rs_uc.uc_stack, NULL, regs->regs[0]) == -EFAULT)
-                goto badframe;
-        regs->is_syscall = 0;
+        do_sigaltstack((stack_t __user *)&st, NULL, regs->regs[0]);
 
         __asm__ __volatile__(
                 "mv\tr0, %0\n\t"
@@ -232,13 +236,17 @@ static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
         return 0;
 
 give_sigsegv:
-        force_sigsegv(signr, current);
+        if (signr == SIGSEGV)
+                ka->sa.sa_handler = SIG_DFL;
+        force_sig(SIGSEGV, current);
         return -EFAULT;
 }
 
-static void handle_signal(unsigned long sig, siginfo_t *info,
-        struct k_sigaction *ka, struct pt_regs *regs)
+static int handle_signal(unsigned long sig, siginfo_t *info,
+        struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs)
 {
+        int ret;
+
         if (regs->is_syscall) {
                 switch (regs->regs[4]) {
                 case ERESTART_RESTARTBLOCK:
@@ -262,15 +270,22 @@ static void handle_signal(unsigned long sig, siginfo_t *info,
         /*
          * Set up the stack frame
          */
-        if (setup_rt_frame(ka, regs, sig, sigmask_to_save(), info) < 0)
-                return;
+        ret = setup_rt_frame(ka, regs, sig, oldset, info);
+
+        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);
 
-        signal_delivered(sig, info, ka, regs, 0);
+        return ret;
 }
 
 static void do_signal(struct pt_regs *regs)
 {
         struct k_sigaction ka;
+        sigset_t *oldset;
         siginfo_t info;
         int signr;
 
@@ -282,10 +297,25 @@ static void do_signal(struct pt_regs *regs)
         if (!user_mode(regs))
                 return;
 
+        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) {
                 /* Actually deliver the signal.  */
-                handle_signal(signr, &info, &ka, regs);
+                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;
         }
 
@@ -312,7 +342,10 @@ static void do_signal(struct pt_regs *regs)
          * If there's no signal to deliver, we just put the saved sigmask
          * back
          */
-        restore_saved_sigmask();
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 /*
@@ -323,10 +356,6 @@ asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
                                 __u32 thread_info_flags)
 {
         /* deal with pending signal delivery */
-        if (thread_info_flags & _TIF_SIGPENDING)
+        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
                 do_signal(regs);
-        if (thread_info_flags & _TIF_NOTIFY_RESUME) {
-                clear_thread_flag(TIF_NOTIFY_RESUME);
-                tracehook_notify_resume(regs);
-        }
 }
diff --git a/arch/score/kernel/sys_score.c b/arch/score/kernel/sys_score.c
index 47c20ba4616..e478bf9a7e9 100644
--- a/arch/score/kernel/sys_score.c
+++ b/arch/score/kernel/sys_score.c
@@ -48,3 +48,91 @@ sys_mmap(unsigned long addr, unsigned long len, unsigned long prot,
                 return -EINVAL;
         return sys_mmap_pgoff(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
 }
+
+asmlinkage long
+score_fork(struct pt_regs *regs)
+{
+        return do_fork(SIGCHLD, regs->regs[0], regs, 0, NULL, NULL);
+}
+
+/*
+ * Clone a task - this clones the calling program thread.
+ * This is called indirectly via a small wrapper
+ */
+asmlinkage long
+score_clone(struct pt_regs *regs)
+{
+        unsigned long clone_flags;
+        unsigned long newsp;
+        int __user *parent_tidptr, *child_tidptr;
+
+        clone_flags = regs->regs[4];
+        newsp = regs->regs[5];
+        if (!newsp)
+                newsp = regs->regs[0];
+        parent_tidptr = (int __user *)regs->regs[6];
+        child_tidptr = (int __user *)regs->regs[8];
+
+        return do_fork(clone_flags, newsp, regs, 0,
+                        parent_tidptr, child_tidptr);
+}
+
+asmlinkage long
+score_vfork(struct pt_regs *regs)
+{
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
+                        regs->regs[0], regs, 0, NULL, NULL);
+}
+
+/*
+ * sys_execve() executes a new program.
+ * This is called indirectly via a small wrapper
+ */
+asmlinkage long
+score_execve(struct pt_regs *regs)
+{
+        int error;
+        char *filename;
+
+        filename = getname((char __user*)regs->regs[4]);
+        error = PTR_ERR(filename);
+        if (IS_ERR(filename))
+                return error;
+
+        error = do_execve(filename,
+                          (const char __user *const __user *)regs->regs[5],
+                          (const char __user *const __user *)regs->regs[6],
+                          regs);
+
+        putname(filename);
+        return error;
+}
+
+/*
+ * 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 unsigned long __r4 asm("r4") = (unsigned long) filename;
+        register unsigned long __r5 asm("r5") = (unsigned long) argv;
+        register unsigned long __r6 asm("r6") = (unsigned long) envp;
+        register unsigned long __r7 asm("r7");
+
+        __asm__ __volatile__ (" \n"
+                "ldi    r27, %5         \n"
+                "syscall                \n"
+                "mv     %0, r4          \n"
+                "mv     %1, r7          \n"
+                : "=&r" (__r4), "=r" (__r7)
+                : "r" (__r4), "r" (__r5), "r" (__r6), "i" (__NR_execve)
+                : "r8", "r9", "r10", "r11", "r22", "r23", "r24", "r25",
+                  "r26", "r27", "memory");
+
+        if (__r7 == 0)
+                return __r4;
+
+        return -__r4;
+}