Patched in Tegra support.

9 files changed, 219 insertions, 98 deletions

diff --git a/arch/avr32/kernel/Makefile b/arch/avr32/kernel/Makefile
index 119a2e41def..18229d0d186 100644
--- a/arch/avr32/kernel/Makefile
+++ b/arch/avr32/kernel/Makefile
@@ -7,8 +7,8 @@ extra-y				:= head.o vmlinux.lds
 obj-$(CONFIG_SUBARCH_AVR32B)    += entry-avr32b.o
 obj-y                           += syscall_table.o syscall-stubs.o irq.o
 obj-y                           += setup.o traps.o ocd.o ptrace.o
-obj-y                           += signal.o process.o time.o
-obj-y                           += switch_to.o cpu.o
+obj-y                           += signal.o sys_avr32.o process.o time.o
+obj-y                           += init_task.o switch_to.o cpu.o
 obj-$(CONFIG_MODULES)           += module.o avr32_ksyms.o
 obj-$(CONFIG_KPROBES)           += kprobes.o
 obj-$(CONFIG_STACKTRACE)        += stacktrace.o
diff --git a/arch/avr32/kernel/cpu.c b/arch/avr32/kernel/cpu.c
index 2233be71e2e..e84faffbbec 100644
--- a/arch/avr32/kernel/cpu.c
+++ b/arch/avr32/kernel/cpu.c
@@ -6,7 +6,7 @@
  * published by the Free Software Foundation.
  */
 #include <linux/init.h>
-#include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/seq_file.h>
 #include <linux/cpu.h>
 #include <linux/module.h>
@@ -26,16 +26,16 @@ static DEFINE_PER_CPU(struct cpu, cpu_devices);
  * XXX: If/when a SMP-capable implementation of AVR32 will ever be
  * made, we must make sure that the code executes on the correct CPU.
  */
-static ssize_t show_pc0event(struct device *dev,
-                        struct device_attribute *attr, char *buf)
+static ssize_t show_pc0event(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         unsigned long pccr;
 
         pccr = sysreg_read(PCCR);
         return sprintf(buf, "0x%lx\n", (pccr >> 12) & 0x3f);
 }
-static ssize_t store_pc0event(struct device *dev,
-                        struct device_attribute *attr, const char *buf,
+static ssize_t store_pc0event(struct sys_device *dev,
+                        struct sysdev_attribute *attr, const char *buf,
                               size_t count)
 {
         unsigned long val;
@@ -48,16 +48,16 @@ static ssize_t store_pc0event(struct device *dev,
         sysreg_write(PCCR, val);
         return count;
 }
-static ssize_t show_pc0count(struct device *dev,
-                        struct device_attribute *attr, char *buf)
+static ssize_t show_pc0count(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         unsigned long pcnt0;
 
         pcnt0 = sysreg_read(PCNT0);
         return sprintf(buf, "%lu\n", pcnt0);
 }
-static ssize_t store_pc0count(struct device *dev,
-                                struct device_attribute *attr,
+static ssize_t store_pc0count(struct sys_device *dev,
+                                struct sysdev_attribute *attr,
                                 const char *buf, size_t count)
 {
         unsigned long val;
@@ -71,16 +71,16 @@ static ssize_t store_pc0count(struct device *dev,
         return count;
 }
 
-static ssize_t show_pc1event(struct device *dev,
-                                struct device_attribute *attr, char *buf)
+static ssize_t show_pc1event(struct sys_device *dev,
+                                struct sysdev_attribute *attr, char *buf)
 {
         unsigned long pccr;
 
         pccr = sysreg_read(PCCR);
         return sprintf(buf, "0x%lx\n", (pccr >> 18) & 0x3f);
 }
-static ssize_t store_pc1event(struct device *dev,
-                              struct device_attribute *attr, const char *buf,
+static ssize_t store_pc1event(struct sys_device *dev,
+                              struct sysdev_attribute *attr, const char *buf,
                               size_t count)
 {
         unsigned long val;
@@ -93,16 +93,16 @@ static ssize_t store_pc1event(struct device *dev,
         sysreg_write(PCCR, val);
         return count;
 }
-static ssize_t show_pc1count(struct device *dev,
-                                struct device_attribute *attr, char *buf)
+static ssize_t show_pc1count(struct sys_device *dev,
+                                struct sysdev_attribute *attr, char *buf)
 {
         unsigned long pcnt1;
 
         pcnt1 = sysreg_read(PCNT1);
         return sprintf(buf, "%lu\n", pcnt1);
 }
-static ssize_t store_pc1count(struct device *dev,
-                                struct device_attribute *attr, const char *buf,
+static ssize_t store_pc1count(struct sys_device *dev,
+                                struct sysdev_attribute *attr, const char *buf,
                               size_t count)
 {
         unsigned long val;
@@ -116,16 +116,16 @@ static ssize_t store_pc1count(struct device *dev,
         return count;
 }
 
-static ssize_t show_pccycles(struct device *dev,
-                                struct device_attribute *attr, char *buf)
+static ssize_t show_pccycles(struct sys_device *dev,
+                                struct sysdev_attribute *attr, char *buf)
 {
         unsigned long pccnt;
 
         pccnt = sysreg_read(PCCNT);
         return sprintf(buf, "%lu\n", pccnt);
 }
-static ssize_t store_pccycles(struct device *dev,
-                                struct device_attribute *attr, const char *buf,
+static ssize_t store_pccycles(struct sys_device *dev,
+                                struct sysdev_attribute *attr, const char *buf,
                               size_t count)
 {
         unsigned long val;
@@ -139,16 +139,16 @@ static ssize_t store_pccycles(struct device *dev,
         return count;
 }
 
-static ssize_t show_pcenable(struct device *dev,
-                        struct device_attribute *attr, char *buf)
+static ssize_t show_pcenable(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         unsigned long pccr;
 
         pccr = sysreg_read(PCCR);
         return sprintf(buf, "%c\n", (pccr & 1)?'1':'0');
 }
-static ssize_t store_pcenable(struct device *dev,
-                              struct device_attribute *attr, const char *buf,
+static ssize_t store_pcenable(struct sys_device *dev,
+                              struct sysdev_attribute *attr, const char *buf,
                               size_t count)
 {
         unsigned long pccr, val;
@@ -167,12 +167,12 @@ static ssize_t store_pcenable(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(pc0event, 0600, show_pc0event, store_pc0event);
-static DEVICE_ATTR(pc0count, 0600, show_pc0count, store_pc0count);
-static DEVICE_ATTR(pc1event, 0600, show_pc1event, store_pc1event);
-static DEVICE_ATTR(pc1count, 0600, show_pc1count, store_pc1count);
-static DEVICE_ATTR(pccycles, 0600, show_pccycles, store_pccycles);
-static DEVICE_ATTR(pcenable, 0600, show_pcenable, store_pcenable);
+static SYSDEV_ATTR(pc0event, 0600, show_pc0event, store_pc0event);
+static SYSDEV_ATTR(pc0count, 0600, show_pc0count, store_pc0count);
+static SYSDEV_ATTR(pc1event, 0600, show_pc1event, store_pc1event);
+static SYSDEV_ATTR(pc1count, 0600, show_pc1count, store_pc1count);
+static SYSDEV_ATTR(pccycles, 0600, show_pccycles, store_pccycles);
+static SYSDEV_ATTR(pcenable, 0600, show_pcenable, store_pcenable);
 
 #endif /* CONFIG_PERFORMANCE_COUNTERS */
 
@@ -186,12 +186,12 @@ static int __init topology_init(void)
                 register_cpu(c, cpu);
 
 #ifdef CONFIG_PERFORMANCE_COUNTERS
-                device_create_file(&c->dev, &dev_attr_pc0event);
-                device_create_file(&c->dev, &dev_attr_pc0count);
-                device_create_file(&c->dev, &dev_attr_pc1event);
-                device_create_file(&c->dev, &dev_attr_pc1count);
-                device_create_file(&c->dev, &dev_attr_pccycles);
-                device_create_file(&c->dev, &dev_attr_pcenable);
+                sysdev_create_file(&c->sysdev, &attr_pc0event);
+                sysdev_create_file(&c->sysdev, &attr_pc0count);
+                sysdev_create_file(&c->sysdev, &attr_pc1event);
+                sysdev_create_file(&c->sysdev, &attr_pc1count);
+                sysdev_create_file(&c->sysdev, &attr_pccycles);
+                sysdev_create_file(&c->sysdev, &attr_pcenable);
 #endif
         }
 
diff --git a/arch/avr32/kernel/entry-avr32b.S b/arch/avr32/kernel/entry-avr32b.S
index 9899d3cc6f0..169268c40ae 100644
--- a/arch/avr32/kernel/entry-avr32b.S
+++ b/arch/avr32/kernel/entry-avr32b.S
@@ -251,15 +251,13 @@ syscall_badsys:
         .global ret_from_fork
 ret_from_fork:
         call   schedule_tail
-        mov     r12, 0
-        rjmp    syscall_return
 
-        .global ret_from_kernel_thread
-ret_from_kernel_thread:
-        call   schedule_tail
-        mov     r12, r0
-        mov     lr, r2  /* syscall_return */
-        mov     pc, r1
+        /* check for syscall tracing */
+        get_thread_info r0
+        ld.w    r1, r0[TI_flags]
+        andl    r1, _TIF_ALLWORK_MASK, COH
+        brne    syscall_exit_work
+        rjmp    syscall_exit_cont
 
 syscall_trace_enter:
         pushm   r8-r12
@@ -283,7 +281,7 @@ syscall_exit_work:
         ld.w    r1, r0[TI_flags]
         rjmp    1b
 
-2:      mov     r2, _TIF_SIGPENDING | _TIF_NOTIFY_RESUME
+2:      mov     r2, _TIF_SIGPENDING | _TIF_RESTORE_SIGMASK | _TIF_NOTIFY_RESUME
         tst     r1, r2
         breq    3f
         unmask_interrupts
@@ -589,7 +587,7 @@ fault_exit_work:
         ld.w    r1, r0[TI_flags]
         rjmp    fault_exit_work
 
-1:      mov     r2, _TIF_SIGPENDING | _TIF_NOTIFY_RESUME
+1:      mov     r2, _TIF_SIGPENDING | _TIF_RESTORE_SIGMASK
         tst     r1, r2
         breq    2f
         unmask_interrupts
diff --git a/arch/avr32/kernel/irq.c b/arch/avr32/kernel/irq.c
index 900e49b2258..bc3aa18293d 100644
--- a/arch/avr32/kernel/irq.c
+++ b/arch/avr32/kernel/irq.c
@@ -14,7 +14,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
-#include <linux/device.h>
+#include <linux/sysdev.h>
 
 /* May be overridden by platform code */
 int __weak nmi_enable(void)
diff --git a/arch/avr32/kernel/process.c b/arch/avr32/kernel/process.c
index fd78f58ea79..ef5a2a08fcc 100644
--- a/arch/avr32/kernel/process.c
+++ b/arch/avr32/kernel/process.c
@@ -34,13 +34,13 @@ void cpu_idle(void)
 {
         /* endless idle loop with no priority at all */
         while (1) {
-                tick_nohz_idle_enter();
-                rcu_idle_enter();
+                tick_nohz_stop_sched_tick(1);
                 while (!need_resched())
                         cpu_idle_sleep();
-                rcu_idle_exit();
-                tick_nohz_idle_exit();
-                schedule_preempt_disabled();
+                tick_nohz_restart_sched_tick();
+                preempt_enable_no_resched();
+                schedule();
+                preempt_disable();
         }
 }
 
@@ -69,6 +69,44 @@ void machine_restart(char *cmd)
 }
 
 /*
+ * PC is actually discarded when returning from a system call -- the
+ * return address must be stored in LR. This function will make sure
+ * LR points to do_exit before starting the thread.
+ *
+ * Also, when returning from fork(), r12 is 0, so we must copy the
+ * argument as well.
+ *
+ *  r0 : The argument to the main thread function
+ *  r1 : The address of do_exit
+ *  r2 : The address of the main thread function
+ */
+asmlinkage extern void kernel_thread_helper(void);
+__asm__("       .type   kernel_thread_helper, @function\n"
+        "kernel_thread_helper:\n"
+        "       mov     r12, r0\n"
+        "       mov     lr, r2\n"
+        "       mov     pc, r1\n"
+        "       .size   kernel_thread_helper, . - kernel_thread_helper");
+
+int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+        struct pt_regs regs;
+
+        memset(&regs, 0, sizeof(regs));
+
+        regs.r0 = (unsigned long)arg;
+        regs.r1 = (unsigned long)fn;
+        regs.r2 = (unsigned long)do_exit;
+        regs.lr = (unsigned long)kernel_thread_helper;
+        regs.pc = (unsigned long)kernel_thread_helper;
+        regs.sr = MODE_SUPERVISOR;
+
+        return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
+                       0, &regs, 0, NULL, NULL);
+}
+EXPORT_SYMBOL(kernel_thread);
+
+/*
  * Free current thread data structures etc
  */
 void exit_thread(void)
@@ -294,32 +332,26 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 }
 
 asmlinkage void ret_from_fork(void);
-asmlinkage void ret_from_kernel_thread(void);
-asmlinkage void syscall_return(void);
 
 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 pt_regs *childregs = task_pt_regs(p);
-
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                memset(childregs, 0, sizeof(struct pt_regs));
-                p->thread.cpu_context.r0 = arg;
-                p->thread.cpu_context.r1 = usp; /* fn */
-                p->thread.cpu_context.r2 = syscall_return;
-                p->thread.cpu_context.pc = (unsigned long)ret_from_kernel_thread;
-                childregs->sr = MODE_SUPERVISOR;
-        } else {
-                *childregs = *current_pt_regs();
-                if (usp)
-                        childregs->sp = usp;
-                childregs->r12 = 0; /* Set return value for child */
-                p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
-        }
+        struct pt_regs *childregs;
+
+        childregs = ((struct pt_regs *)(THREAD_SIZE + (unsigned long)task_stack_page(p))) - 1;
+        *childregs = *regs;
+
+        if (user_mode(regs))
+                childregs->sp = usp;
+        else
+                childregs->sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;
+
+        childregs->r12 = 0; /* Set return value for child */
 
         p->thread.cpu_context.sr = MODE_SUPERVISOR | SR_GM;
         p->thread.cpu_context.ksp = (unsigned long)childregs;
+        p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
 
         clear_tsk_thread_flag(p, TIF_DEBUG);
         if ((clone_flags & CLONE_PTRACE) && test_thread_flag(TIF_DEBUG))
@@ -328,6 +360,49 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
         return 0;
 }
 
+/* r12-r8 are dummy parameters to force the compiler to use the stack */
+asmlinkage int sys_fork(struct pt_regs *regs)
+{
+        return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
+}
+
+asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
+                void __user *parent_tidptr, void __user *child_tidptr,
+                struct pt_regs *regs)
+{
+        if (!newsp)
+                newsp = regs->sp;
+        return do_fork(clone_flags, newsp, regs, 0, parent_tidptr,
+                        child_tidptr);
+}
+
+asmlinkage int sys_vfork(struct pt_regs *regs)
+{
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs,
+                       0, NULL, NULL);
+}
+
+asmlinkage int sys_execve(const char __user *ufilename,
+                          const char __user *const __user *uargv,
+                          const char __user *const __user *uenvp,
+                          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;
+}
+
+
 /*
  * This function is supposed to answer the question "who called
  * schedule()?"
diff --git a/arch/avr32/kernel/signal.c b/arch/avr32/kernel/signal.c
index 5e01c3a40ce..64f886fac2e 100644
--- a/arch/avr32/kernel/signal.c
+++ b/arch/avr32/kernel/signal.c
@@ -15,12 +15,15 @@
 #include <linux/errno.h>
 #include <linux/ptrace.h>
 #include <linux/unistd.h>
+#include <linux/freezer.h>
 #include <linux/tracehook.h>
 
 #include <asm/uaccess.h>
 #include <asm/ucontext.h>
 #include <asm/syscalls.h>
 
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 asmlinkage int sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
                                struct pt_regs *regs)
 {
@@ -74,9 +77,6 @@ asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
         struct rt_sigframe __user *frame;
         sigset_t set;
 
-        /* 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->sp;
         pr_debug("SIG return: frame = %p\n", frame);
 
@@ -86,7 +86,11 @@ asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
         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))
                 goto badframe;
@@ -220,14 +224,14 @@ static inline void setup_syscall_restart(struct pt_regs *regs)
 
 static inline void
 handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
-              struct pt_regs *regs, int syscall)
+              sigset_t *oldset, struct pt_regs *regs, int syscall)
 {
         int ret;
 
         /*
          * Set up the stack frame
          */
-        ret = setup_rt_frame(sig, ka, info, sigmask_to_save(), regs);
+        ret = setup_rt_frame(sig, ka, info, oldset, regs);
 
         /*
          * Check that the resulting registers are sane
@@ -235,12 +239,21 @@ handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
         ret |= !valid_user_regs(regs);
 
         /*
-         * Block the signal if we were successful.
+         * Block the signal if we were unsuccessful.
          */
-        if (ret != 0)
-                force_sigsegv(sig, current);
-        else
-                signal_delivered(sig, info, ka, regs, 0);
+        if (ret != 0 || !(ka->sa.sa_flags & SA_NODEFER)) {
+                spin_lock_irq(&current->sighand->siglock);
+                sigorsets(&current->blocked, &current->blocked,
+                          &ka->sa.sa_mask);
+                sigaddset(&current->blocked, sig);
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+        }
+
+        if (ret == 0)
+                return;
+
+        force_sigsegv(sig, current);
 }
 
 /*
@@ -248,7 +261,7 @@ handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
  * doesn't want to handle. Thus you cannot kill init even with a
  * SIGKILL even by mistake.
  */
-static void do_signal(struct pt_regs *regs, int syscall)
+int do_signal(struct pt_regs *regs, sigset_t *oldset, int syscall)
 {
         siginfo_t info;
         int signr;
@@ -260,7 +273,12 @@ static void do_signal(struct pt_regs *regs, int syscall)
          * without doing anything if so.
          */
         if (!user_mode(regs))
-                return;
+                return 0;
+
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else if (!oldset)
+                oldset = &current->blocked;
 
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
         if (syscall) {
@@ -285,11 +303,15 @@ static void do_signal(struct pt_regs *regs, int syscall)
 
         if (signr == 0) {
                 /* No signal to deliver -- put the saved sigmask back */
-                restore_saved_sigmask();
-                return;
+                if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                        sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+                }
+                return 0;
         }
 
-        handle_signal(signr, &ka, &info, regs, syscall);
+        handle_signal(signr, &ka, &info, oldset, regs, syscall);
+        return 1;
 }
 
 asmlinkage void do_notify_resume(struct pt_regs *regs, struct thread_info *ti)
@@ -299,11 +321,13 @@ asmlinkage void do_notify_resume(struct pt_regs *regs, struct thread_info *ti)
         if ((sysreg_read(SR) & MODE_MASK) == MODE_SUPERVISOR)
                 syscall = 1;
 
-        if (ti->flags & _TIF_SIGPENDING)
-                do_signal(regs, syscall);
+        if (ti->flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
+                do_signal(regs, &current->blocked, syscall);
 
         if (ti->flags & _TIF_NOTIFY_RESUME) {
                 clear_thread_flag(TIF_NOTIFY_RESUME);
                 tracehook_notify_resume(regs);
+                if (current->replacement_session_keyring)
+                        key_replace_session_keyring();
         }
 }
diff --git a/arch/avr32/kernel/syscall-stubs.S b/arch/avr32/kernel/syscall-stubs.S
index 275aab9731f..0447a3e2ba6 100644
--- a/arch/avr32/kernel/syscall-stubs.S
+++ b/arch/avr32/kernel/syscall-stubs.S
@@ -32,6 +32,30 @@ __sys_rt_sigreturn:
         mov     r12, sp
         rjmp    sys_rt_sigreturn
 
+        .global __sys_fork
+        .type   __sys_fork,@function
+__sys_fork:
+        mov     r12, sp
+        rjmp    sys_fork
+
+        .global __sys_clone
+        .type   __sys_clone,@function
+__sys_clone:
+        mov     r8, sp
+        rjmp    sys_clone
+
+        .global __sys_vfork
+        .type   __sys_vfork,@function
+__sys_vfork:
+        mov     r12, sp
+        rjmp    sys_vfork
+
+        .global __sys_execve
+        .type   __sys_execve,@function
+__sys_execve:
+        mov     r9, sp
+        rjmp    sys_execve
+
         .global __sys_mmap2
         .type   __sys_mmap2,@function
 __sys_mmap2:
diff --git a/arch/avr32/kernel/syscall_table.S b/arch/avr32/kernel/syscall_table.S
index f27bb878da6..6eba53530d1 100644
--- a/arch/avr32/kernel/syscall_table.S
+++ b/arch/avr32/kernel/syscall_table.S
@@ -15,7 +15,7 @@
 sys_call_table:
         .long   sys_restart_syscall
         .long   sys_exit
-        .long   sys_fork
+        .long   __sys_fork
         .long   sys_read
         .long   sys_write
         .long   sys_open                /* 5 */
@@ -24,7 +24,7 @@ sys_call_table:
         .long   sys_creat
         .long   sys_link
         .long   sys_unlink              /* 10 */
-        .long   sys_execve
+        .long   __sys_execve
         .long   sys_chdir
         .long   sys_time
         .long   sys_mknod
@@ -57,7 +57,7 @@ sys_call_table:
         .long   sys_dup
         .long   sys_pipe
         .long   sys_times
-        .long   sys_clone
+        .long   __sys_clone
         .long   sys_brk                 /* 45 */
         .long   sys_setgid
         .long   sys_getgid
@@ -127,7 +127,7 @@ sys_call_table:
         .long   sys_newuname
         .long   sys_adjtimex
         .long   sys_mprotect
-        .long   sys_vfork
+        .long   __sys_vfork
         .long   sys_init_module         /* 115 */
         .long   sys_delete_module
         .long   sys_quotactl
diff --git a/arch/avr32/kernel/traps.c b/arch/avr32/kernel/traps.c
index 3d760c06f02..7aa25756412 100644
--- a/arch/avr32/kernel/traps.c
+++ b/arch/avr32/kernel/traps.c
@@ -24,7 +24,7 @@
 
 static DEFINE_SPINLOCK(die_lock);
 
-void die(const char *str, struct pt_regs *regs, long err)
+void NORET_TYPE die(const char *str, struct pt_regs *regs, long err)
 {
         static int die_counter;