Patched in Tegra support.

26 files changed, 674 insertions, 187 deletions

diff --git a/arch/parisc/kernel/Makefile b/arch/parisc/kernel/Makefile
index 66ee3f12df5..67db0722e6c 100644
--- a/arch/parisc/kernel/Makefile
+++ b/arch/parisc/kernel/Makefile
@@ -2,7 +2,7 @@
 # Makefile for arch/parisc/kernel
 #
 
-extra-y                 := head.o vmlinux.lds
+extra-y                 := init_task.o head.o vmlinux.lds
 
 obj-y           := cache.o pacache.o setup.o traps.o time.o irq.o \
                    pa7300lc.o syscall.o entry.o sys_parisc.o firmware.o \
diff --git a/arch/parisc/kernel/cache.c b/arch/parisc/kernel/cache.c
index 48e16dc2010..83335f3da5f 100644
--- a/arch/parisc/kernel/cache.c
+++ b/arch/parisc/kernel/cache.c
@@ -22,6 +22,7 @@
 #include <asm/cache.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
+#include <asm/system.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
 #include <asm/processor.h>
@@ -276,6 +277,7 @@ void flush_dcache_page(struct page *page)
 {
         struct address_space *mapping = page_mapping(page);
         struct vm_area_struct *mpnt;
+        struct prio_tree_iter iter;
         unsigned long offset;
         unsigned long addr, old_addr = 0;
         pgoff_t pgoff;
@@ -298,7 +300,7 @@ void flush_dcache_page(struct page *page)
          * to flush one address here for them all to become coherent */
 
         flush_dcache_mmap_lock(mapping);
-        vma_interval_tree_foreach(mpnt, &mapping->i_mmap, pgoff, pgoff) {
+        vma_prio_tree_foreach(mpnt, &iter, &mapping->i_mmap, pgoff, pgoff) {
                 offset = (pgoff - mpnt->vm_pgoff) << PAGE_SHIFT;
                 addr = mpnt->vm_start + offset;
 
diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c
index 5709c5e59be..994bcd98090 100644
--- a/arch/parisc/kernel/drivers.c
+++ b/arch/parisc/kernel/drivers.c
@@ -33,7 +33,6 @@
 #include <linux/pci.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
-#include <linux/export.h>
 #include <asm/hardware.h>
 #include <asm/io.h>
 #include <asm/pdc.h>
diff --git a/arch/parisc/kernel/entry.S b/arch/parisc/kernel/entry.S
index bfb44247d7a..6f059443914 100644
--- a/arch/parisc/kernel/entry.S
+++ b/arch/parisc/kernel/entry.S
@@ -552,7 +552,7 @@
          * entry (identifying the physical page) and %r23 up with
          * the from tlb entry (or nothing if only a to entry---for
          * clear_user_page_asm) */
-        .macro          do_alias        spc,tmp,tmp1,va,pte,prot,fault,patype
+        .macro          do_alias        spc,tmp,tmp1,va,pte,prot,fault
         cmpib,COND(<>),n 0,\spc,\fault
         ldil            L%(TMPALIAS_MAP_START),\tmp
 #if defined(CONFIG_64BIT) && (TMPALIAS_MAP_START >= 0x80000000)
@@ -581,15 +581,7 @@
          */
         cmpiclr,=       0x01,\tmp,%r0
         ldi             (_PAGE_DIRTY|_PAGE_READ|_PAGE_WRITE),\prot
-.ifc \patype,20
         depd,z          \prot,8,7,\prot
-.else
-.ifc \patype,11
-        depw,z          \prot,8,7,\prot
-.else
-        .error "undefined PA type to do_alias"
-.endif
-.endif
         /*
          * OK, it is in the temp alias region, check whether "from" or "to".
          * Check "subtle" note in pacache.S re: r23/r26.
@@ -708,9 +700,59 @@ ENTRY(end_fault_vector)
         .import         do_cpu_irq_mask,code
 
         /*
+         * r26 = function to be called
+         * r25 = argument to pass in
+         * r24 = flags for do_fork()
+         *
+         * Kernel threads don't ever return, so they don't need
+         * a true register context. We just save away the arguments
+         * for copy_thread/ret_ to properly set up the child.
+         */
+
+#define CLONE_VM 0x100  /* Must agree with <linux/sched.h> */
+#define CLONE_UNTRACED 0x00800000
+
+        .import do_fork
+ENTRY(__kernel_thread)
+        STREG   %r2, -RP_OFFSET(%r30)
+
+        copy    %r30, %r1
+        ldo     PT_SZ_ALGN(%r30),%r30
+#ifdef CONFIG_64BIT
+        /* Yo, function pointers in wide mode are little structs... -PB */
+        ldd     24(%r26), %r2
+        STREG   %r2, PT_GR27(%r1)       /* Store childs %dp */
+        ldd     16(%r26), %r26
+
+        STREG   %r22, PT_GR22(%r1)      /* save r22 (arg5) */
+        copy    %r0, %r22               /* user_tid */
+#endif
+        STREG   %r26, PT_GR26(%r1)  /* Store function & argument for child */
+        STREG   %r25, PT_GR25(%r1)
+        ldil    L%CLONE_UNTRACED, %r26
+        ldo     CLONE_VM(%r26), %r26   /* Force CLONE_VM since only init_mm */
+        or      %r26, %r24, %r26      /* will have kernel mappings.      */
+        ldi     1, %r25                 /* stack_start, signals kernel thread */
+        stw     %r0, -52(%r30)          /* user_tid */
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+#endif
+        BL      do_fork, %r2
+        copy    %r1, %r24               /* pt_regs */
+
+        /* Parent Returns here */
+
+        LDREG   -PT_SZ_ALGN-RP_OFFSET(%r30), %r2
+        ldo     -PT_SZ_ALGN(%r30), %r30
+        bv      %r0(%r2)
+        nop
+ENDPROC(__kernel_thread)
+
+        /*
          * Child Returns here
          *
-         * copy_thread moved args into task save area.
+         * copy_thread moved args from temp save area set up above
+         * into task save area.
          */
 
 ENTRY(ret_from_kernel_thread)
@@ -719,18 +761,52 @@ ENTRY(ret_from_kernel_thread)
         BL      schedule_tail, %r2
         nop
 
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
+        LDREG   TI_TASK-THREAD_SZ_ALGN(%r30), %r1
         LDREG   TASK_PT_GR25(%r1), %r26
 #ifdef CONFIG_64BIT
         LDREG   TASK_PT_GR27(%r1), %r27
+        LDREG   TASK_PT_GR22(%r1), %r22
 #endif
         LDREG   TASK_PT_GR26(%r1), %r1
         ble     0(%sr7, %r1)
         copy    %r31, %r2
-        b       finish_child_return
-        nop
+
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+        loadgp                          /* Thread could have been in a module */
+#endif
+#ifndef CONFIG_64BIT
+        b       sys_exit
+#else
+        load32  sys_exit, %r1
+        bv      %r0(%r1)
+#endif
+        ldi     0, %r26
 ENDPROC(ret_from_kernel_thread)
 
+        .import sys_execve, code
+ENTRY(__execve)
+        copy    %r2, %r15
+        copy    %r30, %r16
+        ldo     PT_SZ_ALGN(%r30), %r30
+        STREG   %r26, PT_GR26(%r16)
+        STREG   %r25, PT_GR25(%r16)
+        STREG   %r24, PT_GR24(%r16)
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+#endif
+        BL      sys_execve, %r2
+        copy    %r16, %r26
+
+        cmpib,=,n 0,%r28,intr_return    /* forward */
+
+        /* yes, this will trap and die. */
+        copy    %r15, %r2
+        copy    %r16, %r30
+        bv      %r0(%r2)
+        nop
+ENDPROC(__execve)
+
 
         /*
          * struct task_struct *_switch_to(struct task_struct *prev,
@@ -840,7 +916,7 @@ intr_check_sig:
         /* As above */
         mfctl   %cr30,%r1
         LDREG   TI_FLAGS(%r1),%r19
-        ldi     (_TIF_SIGPENDING|_TIF_NOTIFY_RESUME), %r20
+        ldi     (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK|_TIF_NOTIFY_RESUME), %r20
         and,COND(<>)    %r19, %r20, %r0
         b,n     intr_restore    /* skip past if we've nothing to do */
 
@@ -1109,7 +1185,7 @@ dtlb_miss_20w:
         nop
 
 dtlb_check_alias_20w:
-        do_alias        spc,t0,t1,va,pte,prot,dtlb_fault,20
+        do_alias        spc,t0,t1,va,pte,prot,dtlb_fault
 
         idtlbt          pte,prot
 
@@ -1133,7 +1209,7 @@ nadtlb_miss_20w:
         nop
 
 nadtlb_check_alias_20w:
-        do_alias        spc,t0,t1,va,pte,prot,nadtlb_emulate,20
+        do_alias        spc,t0,t1,va,pte,prot,nadtlb_emulate
 
         idtlbt          pte,prot
 
@@ -1165,7 +1241,7 @@ dtlb_miss_11:
         nop
 
 dtlb_check_alias_11:
-        do_alias        spc,t0,t1,va,pte,prot,dtlb_fault,11
+        do_alias        spc,t0,t1,va,pte,prot,dtlb_fault
 
         idtlba          pte,(va)
         idtlbp          prot,(va)
@@ -1197,7 +1273,7 @@ nadtlb_miss_11:
         nop
 
 nadtlb_check_alias_11:
-        do_alias        spc,t0,t1,va,pte,prot,nadtlb_emulate,11
+        do_alias        spc,t0,t1,va,pte,prot,nadtlb_emulate
 
         idtlba          pte,(va)
         idtlbp          prot,(va)
@@ -1224,7 +1300,7 @@ dtlb_miss_20:
         nop
 
 dtlb_check_alias_20:
-        do_alias        spc,t0,t1,va,pte,prot,dtlb_fault,20
+        do_alias        spc,t0,t1,va,pte,prot,dtlb_fault
         
         idtlbt          pte,prot
 
@@ -1250,7 +1326,7 @@ nadtlb_miss_20:
         nop
 
 nadtlb_check_alias_20:
-        do_alias        spc,t0,t1,va,pte,prot,nadtlb_emulate,20
+        do_alias        spc,t0,t1,va,pte,prot,nadtlb_emulate
 
         idtlbt          pte,prot
 
@@ -1377,7 +1453,7 @@ naitlb_miss_20w:
         nop
 
 naitlb_check_alias_20w:
-        do_alias        spc,t0,t1,va,pte,prot,naitlb_fault,20
+        do_alias        spc,t0,t1,va,pte,prot,naitlb_fault
 
         iitlbt          pte,prot
 
@@ -1431,7 +1507,7 @@ naitlb_miss_11:
         nop
 
 naitlb_check_alias_11:
-        do_alias        spc,t0,t1,va,pte,prot,itlb_fault,11
+        do_alias        spc,t0,t1,va,pte,prot,itlb_fault
 
         iitlba          pte,(%sr0, va)
         iitlbp          prot,(%sr0, va)
@@ -1477,7 +1553,7 @@ naitlb_miss_20:
         nop
 
 naitlb_check_alias_20:
-        do_alias        spc,t0,t1,va,pte,prot,naitlb_fault,20
+        do_alias        spc,t0,t1,va,pte,prot,naitlb_fault
 
         iitlbt          pte,prot
 
@@ -1688,36 +1764,151 @@ dtlb_fault:
         LDREG   PT_GR18(\regs),%r18
         .endm
 
-        .macro  fork_like name
-ENTRY(sys_\name\()_wrapper)
+ENTRY(sys_fork_wrapper)
         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
         ldo     TASK_REGS(%r1),%r1
         reg_save %r1
-        mfctl   %cr27, %r28
-        b       sys_\name
-        STREG   %r28, PT_CR27(%r1)
-ENDPROC(sys_\name\()_wrapper)
-        .endm
+        mfctl   %cr27, %r3
+        STREG   %r3, PT_CR27(%r1)
 
-fork_like clone
-fork_like fork
-fork_like vfork
+        STREG   %r2,-RP_OFFSET(%r30)
+        ldo     FRAME_SIZE(%r30),%r30
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+#endif
 
-        /* Set the return value for the child */
-ENTRY(child_return)
-        BL      schedule_tail, %r2
-        nop
-finish_child_return:
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
+        /* These are call-clobbered registers and therefore
+           also syscall-clobbered (we hope). */
+        STREG   %r2,PT_GR19(%r1)        /* save for child */
+        STREG   %r30,PT_GR21(%r1)
+
+        LDREG   PT_GR30(%r1),%r25
+        copy    %r1,%r24
+        BL      sys_clone,%r2
+        ldi     SIGCHLD,%r26
+
+        LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
+wrapper_exit:
+        ldo     -FRAME_SIZE(%r30),%r30          /* get the stackframe */
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
         ldo     TASK_REGS(%r1),%r1       /* get pt regs */
 
         LDREG   PT_CR27(%r1), %r3
         mtctl   %r3, %cr27
         reg_restore %r1
-        b       syscall_exit
+
+        /* strace expects syscall # to be preserved in r20 */
+        ldi     __NR_fork,%r20
+        bv %r0(%r2)
+        STREG   %r20,PT_GR20(%r1)
+ENDPROC(sys_fork_wrapper)
+
+        /* Set the return value for the child */
+ENTRY(child_return)
+        BL      schedule_tail, %r2
+        nop
+
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE-FRAME_SIZE(%r30), %r1
+        LDREG   TASK_PT_GR19(%r1),%r2
+        b       wrapper_exit
         copy    %r0,%r28
 ENDPROC(child_return)
 
+
+ENTRY(sys_clone_wrapper)
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
+        ldo     TASK_REGS(%r1),%r1      /* get pt regs */
+        reg_save %r1
+        mfctl   %cr27, %r3
+        STREG   %r3, PT_CR27(%r1)
+
+        STREG   %r2,-RP_OFFSET(%r30)
+        ldo     FRAME_SIZE(%r30),%r30
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+#endif
+
+        /* WARNING - Clobbers r19 and r21, userspace must save these! */
+        STREG   %r2,PT_GR19(%r1)        /* save for child */
+        STREG   %r30,PT_GR21(%r1)
+        BL      sys_clone,%r2
+        copy    %r1,%r24
+
+        b       wrapper_exit
+        LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
+ENDPROC(sys_clone_wrapper)
+
+
+ENTRY(sys_vfork_wrapper)
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
+        ldo     TASK_REGS(%r1),%r1      /* get pt regs */
+        reg_save %r1
+        mfctl   %cr27, %r3
+        STREG   %r3, PT_CR27(%r1)
+
+        STREG   %r2,-RP_OFFSET(%r30)
+        ldo     FRAME_SIZE(%r30),%r30
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+#endif
+
+        STREG   %r2,PT_GR19(%r1)        /* save for child */
+        STREG   %r30,PT_GR21(%r1)
+
+        BL      sys_vfork,%r2
+        copy    %r1,%r26
+
+        b       wrapper_exit
+        LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
+ENDPROC(sys_vfork_wrapper)
+
+        
+        .macro  execve_wrapper execve
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
+        ldo     TASK_REGS(%r1),%r1      /* get pt regs */
+
+        /*
+         * Do we need to save/restore r3-r18 here?
+         * I don't think so. why would new thread need old
+         * threads registers?
+         */
+
+        /* %arg0 - %arg3 are already saved for us. */
+
+        STREG %r2,-RP_OFFSET(%r30)
+        ldo FRAME_SIZE(%r30),%r30
+#ifdef CONFIG_64BIT
+        ldo     -16(%r30),%r29          /* Reference param save area */
+#endif
+        BL \execve,%r2
+        copy %r1,%arg0
+
+        ldo -FRAME_SIZE(%r30),%r30
+        LDREG -RP_OFFSET(%r30),%r2
+
+        /* If exec succeeded we need to load the args */
+
+        ldo -1024(%r0),%r1
+        cmpb,>>= %r28,%r1,error_\execve
+        copy %r2,%r19
+
+error_\execve:
+        bv %r0(%r19)
+        nop
+        .endm
+
+        .import sys_execve
+ENTRY(sys_execve_wrapper)
+        execve_wrapper sys_execve
+ENDPROC(sys_execve_wrapper)
+
+#ifdef CONFIG_64BIT
+        .import sys32_execve
+ENTRY(sys32_execve_wrapper)
+        execve_wrapper sys32_execve
+ENDPROC(sys32_execve_wrapper)
+#endif
+
 ENTRY(sys_rt_sigreturn_wrapper)
         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r26
         ldo     TASK_REGS(%r26),%r26    /* get pt regs */
@@ -1833,7 +2024,7 @@ syscall_check_resched:
         .import do_signal,code
 syscall_check_sig:
         LDREG   TI_FLAGS-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r19
-        ldi     (_TIF_SIGPENDING|_TIF_NOTIFY_RESUME), %r26
+        ldi     (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK), %r26
         and,COND(<>)    %r19, %r26, %r0
         b,n     syscall_restore /* skip past if we've nothing to do */
 
diff --git a/arch/parisc/kernel/firmware.c b/arch/parisc/kernel/firmware.c
index f65fa480c90..4896ed09058 100644
--- a/arch/parisc/kernel/firmware.c
+++ b/arch/parisc/kernel/firmware.c
@@ -67,6 +67,7 @@
 #include <asm/page.h>
 #include <asm/pdc.h>
 #include <asm/pdcpat.h>
+#include <asm/system.h>
 #include <asm/processor.h>      /* for boot_cpu_data */
 
 static DEFINE_SPINLOCK(pdc_lock);
diff --git a/arch/parisc/kernel/hardware.c b/arch/parisc/kernel/hardware.c
index f7752f6af29..f48a640b55f 100644
--- a/arch/parisc/kernel/hardware.c
+++ b/arch/parisc/kernel/hardware.c
@@ -38,7 +38,7 @@
  *      so don't reference this table after starting the init process
  */
  
-static struct hp_hardware hp_hardware_list[] = {
+static struct hp_hardware hp_hardware_list[] __devinitdata = {
         {HPHW_NPROC,0x01,0x4,0x0,"Indigo (840, 930)"},
         {HPHW_NPROC,0x8,0x4,0x01,"Firefox(825,925)"},
         {HPHW_NPROC,0xA,0x4,0x01,"Top Gun (835,834,935,635)"},
@@ -1230,7 +1230,7 @@ static struct hp_cpu_type_mask {
         unsigned short model;
         unsigned short mask;
         enum cpu_type cpu;
-} hp_cpu_type_mask_list[] = {
+} hp_cpu_type_mask_list[] __devinitdata = {
 
         { 0x0000, 0x0ff0, pcx    },  /* 0x0000 - 0x000f */
         { 0x0048, 0x0ff0, pcxl   },  /* 0x0040 - 0x004f */
@@ -1327,7 +1327,8 @@ const char * const cpu_name_version[][2] = {
         [mako2] = { "PA8900 (Shortfin)",        "2.0" }
 };
 
-const char *parisc_hardware_description(struct parisc_device_id *id)
+const char * __devinit
+parisc_hardware_description(struct parisc_device_id *id)
 {
         struct hp_hardware *listptr;
         
diff --git a/arch/parisc/kernel/module.c b/arch/parisc/kernel/module.c
index 2a625fb063e..5e34ccf39a4 100644
--- a/arch/parisc/kernel/module.c
+++ b/arch/parisc/kernel/module.c
@@ -214,6 +214,8 @@ static inline int reassemble_22(int as22)
 
 void *module_alloc(unsigned long size)
 {
+        if (size == 0)
+                return NULL;
         /* using RWX means less protection for modules, but it's
          * easier than trying to map the text, data, init_text and
          * init_data correctly */
diff --git a/arch/parisc/kernel/pacache.S b/arch/parisc/kernel/pacache.S
index 5d7218ad885..93ff3d90edd 100644
--- a/arch/parisc/kernel/pacache.S
+++ b/arch/parisc/kernel/pacache.S
@@ -692,7 +692,7 @@ ENTRY(flush_icache_page_asm)
 
         /* Purge any old translation */
 
-        pitlb           (%sr4,%r28)
+        pitlb           (%sr0,%r28)
 
         ldil            L%icache_stride, %r1
         ldw             R%icache_stride(%r1), %r1
@@ -706,29 +706,27 @@ ENTRY(flush_icache_page_asm)
         sub             %r25, %r1, %r25
 
 
-        /* fic only has the type 26 form on PA1.1, requiring an
-         * explicit space specification, so use %sr4 */
-1:      fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
-        fic,m           %r1(%sr4,%r28)
+1:      fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
+        fic,m           %r1(%r28)
         cmpb,COND(<<)           %r28, %r25,1b
-        fic,m           %r1(%sr4,%r28)
+        fic,m           %r1(%r28)
 
         sync
         bv              %r0(%r2)
-        pitlb           (%sr4,%r25)
+        pitlb           (%sr0,%r25)
         .exit
 
         .procend
diff --git a/arch/parisc/kernel/parisc_ksyms.c b/arch/parisc/kernel/parisc_ksyms.c
index ceec85de629..a7bb757a549 100644
--- a/arch/parisc/kernel/parisc_ksyms.c
+++ b/arch/parisc/kernel/parisc_ksyms.c
@@ -44,6 +44,7 @@ EXPORT_SYMBOL(__cmpxchg_u64);
 #endif
 
 #include <asm/uaccess.h>
+EXPORT_SYMBOL(lstrncpy_from_user);
 EXPORT_SYMBOL(lclear_user);
 EXPORT_SYMBOL(lstrnlen_user);
 
diff --git a/arch/parisc/kernel/pci-dma.c b/arch/parisc/kernel/pci-dma.c
index d87d1c476d8..a029f74a3c5 100644
--- a/arch/parisc/kernel/pci-dma.c
+++ b/arch/parisc/kernel/pci-dma.c
@@ -2,7 +2,7 @@
 ** PARISC 1.1 Dynamic DMA mapping support.
 ** This implementation is for PA-RISC platforms that do not support
 ** I/O TLBs (aka DMA address translation hardware).
-** See Documentation/DMA-API-HOWTO.txt for interface definitions.
+** See Documentation/PCI/PCI-DMA-mapping.txt for interface definitions.
 **
 **      (c) Copyright 1999,2000 Hewlett-Packard Company
 **      (c) Copyright 2000 Grant Grundler
@@ -26,7 +26,6 @@
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/scatterlist.h>
-#include <linux/export.h>
 
 #include <asm/cacheflush.h>
 #include <asm/dma.h>    /* for DMA_CHUNK_SIZE */
diff --git a/arch/parisc/kernel/pci.c b/arch/parisc/kernel/pci.c
index 60309051875..9efd9740531 100644
--- a/arch/parisc/kernel/pci.c
+++ b/arch/parisc/kernel/pci.c
@@ -16,6 +16,7 @@
 #include <linux/types.h>
 
 #include <asm/io.h>
+#include <asm/system.h>
 #include <asm/superio.h>
 
 #define DEBUG_RESOURCES 0
@@ -139,6 +140,11 @@ void pcibios_fixup_bus(struct pci_bus *bus)
 }
 
 
+char *pcibios_setup(char *str)
+{
+        return str;
+}
+
 /*
  * Called by pci_set_master() - a driver interface.
  *
@@ -189,6 +195,58 @@ void __init pcibios_init_bus(struct pci_bus *bus)
         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bridge_ctl);
 }
 
+/* called by drivers/pci/setup-bus.c:pci_setup_bridge().  */
+void __devinit pcibios_resource_to_bus(struct pci_dev *dev,
+                struct pci_bus_region *region, struct resource *res)
+{
+#ifdef CONFIG_64BIT
+        struct pci_hba_data *hba = HBA_DATA(dev->bus->bridge->platform_data);
+#endif
+
+        if (res->flags & IORESOURCE_IO) {
+                /*
+                ** I/O space may see busnumbers here. Something
+                ** in the form of 0xbbxxxx where bb is the bus num
+                ** and xxxx is the I/O port space address.
+                ** Remaining address translation are done in the
+                ** PCI Host adapter specific code - ie dino_out8.
+                */
+                region->start = PCI_PORT_ADDR(res->start);
+                region->end   = PCI_PORT_ADDR(res->end);
+        } else if (res->flags & IORESOURCE_MEM) {
+                /* Convert MMIO addr to PCI addr (undo global virtualization) */
+                region->start = PCI_BUS_ADDR(hba, res->start);
+                region->end   = PCI_BUS_ADDR(hba, res->end);
+        }
+
+        DBG_RES("pcibios_resource_to_bus(%02x %s [%lx,%lx])\n",
+                dev->bus->number, res->flags & IORESOURCE_IO ? "IO" : "MEM",
+                region->start, region->end);
+}
+
+void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                              struct pci_bus_region *region)
+{
+#ifdef CONFIG_64BIT
+        struct pci_hba_data *hba = HBA_DATA(dev->bus->bridge->platform_data);
+#endif
+
+        if (res->flags & IORESOURCE_MEM) {
+                res->start = PCI_HOST_ADDR(hba, region->start);
+                res->end = PCI_HOST_ADDR(hba, region->end);
+        }
+
+        if (res->flags & IORESOURCE_IO) {
+                res->start = region->start;
+                res->end = region->end;
+        }
+}
+
+#ifdef CONFIG_HOTPLUG
+EXPORT_SYMBOL(pcibios_resource_to_bus);
+EXPORT_SYMBOL(pcibios_bus_to_resource);
+#endif
+
 /*
  * pcibios align resources() is called every time generic PCI code
  * wants to generate a new address. The process of looking for
diff --git a/arch/parisc/kernel/pdc_cons.c b/arch/parisc/kernel/pdc_cons.c
index efc5e7d3053..fc770be465f 100644
--- a/arch/parisc/kernel/pdc_cons.c
+++ b/arch/parisc/kernel/pdc_cons.c
@@ -50,7 +50,6 @@
 #include <linux/init.h>
 #include <linux/major.h>
 #include <linux/tty.h>
-#include <asm/page.h>           /* for PAGE0 */
 #include <asm/pdc.h>            /* for iodc_call() proto and friends */
 
 static DEFINE_SPINLOCK(pdc_console_lock);
@@ -91,13 +90,11 @@ static int pdc_console_setup(struct console *co, char *options)
 
 #define PDC_CONS_POLL_DELAY (30 * HZ / 1000)
 
-static void pdc_console_poll(unsigned long unused);
-static DEFINE_TIMER(pdc_console_timer, pdc_console_poll, 0, 0);
-static struct tty_port tty_port;
+static struct timer_list pdc_console_timer;
 
 static int pdc_console_tty_open(struct tty_struct *tty, struct file *filp)
 {
-        tty_port_tty_set(&tty_port, tty);
+
         mod_timer(&pdc_console_timer, jiffies + PDC_CONS_POLL_DELAY);
 
         return 0;
@@ -105,10 +102,8 @@ static int pdc_console_tty_open(struct tty_struct *tty, struct file *filp)
 
 static void pdc_console_tty_close(struct tty_struct *tty, struct file *filp)
 {
-        if (tty->count == 1) {
-                del_timer_sync(&pdc_console_timer);
-                tty_port_tty_set(&tty_port, NULL);
-        }
+        if (!tty->count)
+                del_timer(&pdc_console_timer);
 }
 
 static int pdc_console_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
@@ -127,6 +122,8 @@ static int pdc_console_tty_chars_in_buffer(struct tty_struct *tty)
         return 0; /* no buffer */
 }
 
+static struct tty_driver *pdc_console_tty_driver;
+
 static const struct tty_operations pdc_console_tty_ops = {
         .open = pdc_console_tty_open,
         .close = pdc_console_tty_close,
@@ -137,8 +134,10 @@ static const struct tty_operations pdc_console_tty_ops = {
 
 static void pdc_console_poll(unsigned long unused)
 {
+
         int data, count = 0;
-        struct tty_struct *tty = tty_port_tty_get(&tty_port);
+
+        struct tty_struct *tty = pdc_console_tty_driver->ttys[0];
 
         if (!tty)
                 return;
@@ -154,17 +153,15 @@ static void pdc_console_poll(unsigned long unused)
         if (count)
                 tty_flip_buffer_push(tty);
 
-        tty_kref_put(tty);
-
-        if (pdc_cons.flags & CON_ENABLED)
+        if (tty->count && (pdc_cons.flags & CON_ENABLED))
                 mod_timer(&pdc_console_timer, jiffies + PDC_CONS_POLL_DELAY);
 }
 
-static struct tty_driver *pdc_console_tty_driver;
-
 static int __init pdc_console_tty_driver_init(void)
 {
+
         int err;
+        struct tty_driver *drv;
 
         /* Check if the console driver is still registered.
          * It is unregistered if the pdc console was not selected as the
@@ -186,31 +183,32 @@ static int __init pdc_console_tty_driver_init(void)
         printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n");
         pdc_cons.flags &= ~CON_BOOT;
 
-        pdc_console_tty_driver = alloc_tty_driver(1);
+        drv = alloc_tty_driver(1);
 
-        if (!pdc_console_tty_driver)
+        if (!drv)
                 return -ENOMEM;
 
-        tty_port_init(&tty_port);
+        drv->driver_name = "pdc_cons";
+        drv->name = "ttyB";
+        drv->major = MUX_MAJOR;
+        drv->minor_start = 0;
+        drv->type = TTY_DRIVER_TYPE_SYSTEM;
+        drv->init_termios = tty_std_termios;
+        drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
+        tty_set_operations(drv, &pdc_console_tty_ops);
 
-        pdc_console_tty_driver->driver_name = "pdc_cons";
-        pdc_console_tty_driver->name = "ttyB";
-        pdc_console_tty_driver->major = MUX_MAJOR;
-        pdc_console_tty_driver->minor_start = 0;
-        pdc_console_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
-        pdc_console_tty_driver->init_termios = tty_std_termios;
-        pdc_console_tty_driver->flags = TTY_DRIVER_REAL_RAW |
-                TTY_DRIVER_RESET_TERMIOS;
-        tty_set_operations(pdc_console_tty_driver, &pdc_console_tty_ops);
-        tty_port_link_device(&tty_port, pdc_console_tty_driver, 0);
-
-        err = tty_register_driver(pdc_console_tty_driver);
+        err = tty_register_driver(drv);
         if (err) {
                 printk(KERN_ERR "Unable to register the PDC console TTY driver\n");
-                tty_port_destroy(&tty_port);
                 return err;
         }
 
+        pdc_console_tty_driver = drv;
+
+        /* No need to initialize the pdc_console_timer if tty isn't allocated */
+        init_timer(&pdc_console_timer);
+        pdc_console_timer.function = pdc_console_poll;
+
         return 0;
 }
 
diff --git a/arch/parisc/kernel/process.c b/arch/parisc/kernel/process.c
index d13507246c5..4b4b9181a1a 100644
--- a/arch/parisc/kernel/process.c
+++ b/arch/parisc/kernel/process.c
@@ -48,11 +48,9 @@
 #include <linux/unistd.h>
 #include <linux/kallsyms.h>
 #include <linux/uaccess.h>
-#include <linux/rcupdate.h>
 
 #include <asm/io.h>
 #include <asm/asm-offsets.h>
-#include <asm/assembly.h>
 #include <asm/pdc.h>
 #include <asm/pdc_chassis.h>
 #include <asm/pgalloc.h>
@@ -71,11 +69,11 @@ void 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();
                 check_pgt_cache();
         }
 }
@@ -166,6 +164,23 @@ void (*pm_power_off)(void) = machine_power_off;
 EXPORT_SYMBOL(pm_power_off);
 
 /*
+ * Create a kernel thread
+ */
+
+extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
+pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+
+        /*
+         * FIXME: Once we are sure we don't need any debug here,
+         *        kernel_thread can become a #define.
+         */
+
+        return __kernel_thread(fn, arg, flags);
+}
+EXPORT_SYMBOL(kernel_thread);
+
+/*
  * Free current thread data structures etc..
  */
 void exit_thread(void)
@@ -177,6 +192,7 @@ void flush_thread(void)
         /* Only needs to handle fpu stuff or perf monitors.
         ** REVISIT: several arches implement a "lazy fpu state".
         */
+        set_fs(USER_DS);
 }
 
 void release_thread(struct task_struct *dead_task)
@@ -202,11 +218,48 @@ int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
         return 1;
 }
 
+/* Note that "fork()" is implemented in terms of clone, with
+   parameters (SIGCHLD, regs->gr[30], regs). */
+int
+sys_clone(unsigned long clone_flags, unsigned long usp,
+          struct pt_regs *regs)
+{
+        /* Arugments from userspace are:
+           r26 = Clone flags.
+           r25 = Child stack.
+           r24 = parent_tidptr.
+           r23 = Is the TLS storage descriptor 
+           r22 = child_tidptr 
+           
+           However, these last 3 args are only examined
+           if the proper flags are set. */
+        int __user *parent_tidptr = (int __user *)regs->gr[24];
+        int __user *child_tidptr  = (int __user *)regs->gr[22];
+
+        /* usp must be word aligned.  This also prevents users from
+         * passing in the value 1 (which is the signal for a special
+         * return for a kernel thread) */
+        usp = ALIGN(usp, 4);
+
+        /* A zero value for usp means use the current stack */
+        if (usp == 0)
+          usp = regs->gr[30];
+
+        return do_fork(clone_flags, usp, regs, 0, parent_tidptr, child_tidptr);
+}
+
+int
+sys_vfork(struct pt_regs *regs)
+{
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
+}
+
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
-            unsigned long arg, struct task_struct *p)
+            unsigned long unused,       /* in ia64 this is "user_stack_size" */
+            struct task_struct * p, struct pt_regs * pregs)
 {
-        struct pt_regs *cregs = &(p->thread.regs);
+        struct pt_regs * cregs = &(p->thread.regs);
         void *stack = task_stack_page(p);
         
         /* We have to use void * instead of a function pointer, because
@@ -217,40 +270,49 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
 #ifdef CONFIG_HPUX
         extern void * const hpux_child_return;
 #endif
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                memset(cregs, 0, sizeof(struct pt_regs));
-                if (!usp) /* idle thread */
-                        return 0;
 
+        *cregs = *pregs;
+
+        /* Set the return value for the child.  Note that this is not
+           actually restored by the syscall exit path, but we put it
+           here for consistency in case of signals. */
+        cregs->gr[28] = 0; /* child */
+
+        /*
+         * We need to differentiate between a user fork and a
+         * kernel fork. We can't use user_mode, because the
+         * the syscall path doesn't save iaoq. Right now
+         * We rely on the fact that kernel_thread passes
+         * in zero for usp.
+         */
+        if (usp == 1) {
                 /* kernel thread */
+                cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN;
                 /* Must exit via ret_from_kernel_thread in order
                  * to call schedule_tail()
                  */
-                cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
                 cregs->kpc = (unsigned long) &ret_from_kernel_thread;
                 /*
                  * Copy function and argument to be called from
                  * ret_from_kernel_thread.
                  */
 #ifdef CONFIG_64BIT
-                cregs->gr[27] = ((unsigned long *)usp)[3];
-                cregs->gr[26] = ((unsigned long *)usp)[2];
-#else
-                cregs->gr[26] = usp;
+                cregs->gr[27] = pregs->gr[27];
 #endif
-                cregs->gr[25] = arg;
+                cregs->gr[26] = pregs->gr[26];
+                cregs->gr[25] = pregs->gr[25];
         } else {
                 /* user thread */
-                /* usp must be word aligned.  This also prevents users from
-                 * passing in the value 1 (which is the signal for a special
-                 * return for a kernel thread) */
-                if (usp) {
-                        usp = ALIGN(usp, 4);
-                        if (likely(usp))
-                                cregs->gr[30] = usp;
-                }
-                cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
-                if (personality(p->personality) == PER_HPUX) {
+                /*
+                 * Note that the fork wrappers are responsible
+                 * for setting gr[21].
+                 */
+
+                /* Use same stack depth as parent */
+                cregs->ksp = (unsigned long)stack
+                        + (pregs->gr[21] & (THREAD_SIZE - 1));
+                cregs->gr[30] = usp;
+                if (p->personality == PER_HPUX) {
 #ifdef CONFIG_HPUX
                         cregs->kpc = (unsigned long) &hpux_child_return;
 #else
@@ -261,7 +323,8 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
                 }
                 /* Setup thread TLS area from the 4th parameter in clone */
                 if (clone_flags & CLONE_SETTLS)
-                        cregs->cr27 = cregs->gr[23];
+                  cregs->cr27 = pregs->gr[23];
+        
         }
 
         return 0;
@@ -272,6 +335,39 @@ unsigned long thread_saved_pc(struct task_struct *t)
         return t->thread.regs.kpc;
 }
 
+/*
+ * sys_execve() executes a new program.
+ */
+
+asmlinkage int sys_execve(struct pt_regs *regs)
+{
+        int error;
+        char *filename;
+
+        filename = getname((const char __user *) regs->gr[26]);
+        error = PTR_ERR(filename);
+        if (IS_ERR(filename))
+                goto out;
+        error = do_execve(filename,
+                          (const char __user *const __user *) regs->gr[25],
+                          (const char __user *const __user *) regs->gr[24],
+                          regs);
+        putname(filename);
+out:
+
+        return error;
+}
+
+extern int __execve(const char *filename,
+                    const char *const argv[],
+                    const char *const envp[], struct task_struct *task);
+int kernel_execve(const char *filename,
+                  const char *const argv[],
+                  const char *const envp[])
+{
+        return __execve(filename, argv, envp, current);
+}
+
 unsigned long
 get_wchan(struct task_struct *p)
 {
diff --git a/arch/parisc/kernel/ptrace.c b/arch/parisc/kernel/ptrace.c
index 857c2f54547..2905b1f52d3 100644
--- a/arch/parisc/kernel/ptrace.c
+++ b/arch/parisc/kernel/ptrace.c
@@ -22,6 +22,7 @@
 
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
+#include <asm/system.h>
 #include <asm/processor.h>
 #include <asm/asm-offsets.h>
 
diff --git a/arch/parisc/kernel/setup.c b/arch/parisc/kernel/setup.c
index a3328c2616b..cb71f3dac99 100644
--- a/arch/parisc/kernel/setup.c
+++ b/arch/parisc/kernel/setup.c
@@ -35,7 +35,6 @@
 #include <linux/pci.h>
 #undef PCI_DEBUG
 #include <linux/proc_fs.h>
-#include <linux/export.h>
 
 #include <asm/processor.h>
 #include <asm/pdc.h>
diff --git a/arch/parisc/kernel/signal.c b/arch/parisc/kernel/signal.c
index 53799695599..12c1ed33dc1 100644
--- a/arch/parisc/kernel/signal.c
+++ b/arch/parisc/kernel/signal.c
@@ -48,6 +48,9 @@
 #define DBG(LEVEL, ...)
 #endif
         
+
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 /* gcc will complain if a pointer is cast to an integer of different
  * size.  If you really need to do this (and we do for an ELF32 user
  * application in an ELF64 kernel) then you have to do a cast to an
@@ -106,15 +109,12 @@ sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 #endif
 
-        current_thread_info()->restart_block.fn = do_no_restart_syscall;
 
         /* Unwind the user stack to get the rt_sigframe structure. */
         frame = (struct rt_sigframe __user *)
                 (usp - sigframe_size);
         DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
 
-        regs->orig_r28 = 1; /* no restarts for sigreturn */
-
 #ifdef CONFIG_64BIT
         compat_frame = (struct compat_rt_sigframe __user *)frame;
         
@@ -130,7 +130,11 @@ sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
                         goto give_sigsegv;
         }
                 
-        set_current_blocked(&set);
+        sigdelsetmask(&set, ~_BLOCKABLE);
+        spin_lock_irq(&current->sighand->siglock);
+        current->blocked = set;
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
 
         /* Good thing we saved the old gr[30], eh? */
 #ifdef CONFIG_64BIT
@@ -439,35 +443,39 @@ give_sigsegv:
  * OK, we're invoking a handler.
  */     
 
-static void
+static long
 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
-                struct pt_regs *regs, int in_syscall)
+                sigset_t *oldset, struct pt_regs *regs, int in_syscall)
 {
-        sigset_t *oldset = sigmask_to_save();
         DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
                sig, ka, info, oldset, regs);
         
         /* Set up the stack frame */
         if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
-                return;
+                return 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);
 
-        signal_delivered(sig, info, ka, regs, 
+        tracehook_signal_handler(sig, info, ka, regs, 
                 test_thread_flag(TIF_SINGLESTEP) ||
                 test_thread_flag(TIF_BLOCKSTEP));
 
-        DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
-                regs->gr[28]);
+        return 1;
 }
 
 static inline void
 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 {
-        if (regs->orig_r28)
-                return;
-        regs->orig_r28 = 1; /* no more restarts */
         /* Check the return code */
         switch (regs->gr[28]) {
         case -ERESTART_RESTARTBLOCK:
+                current_thread_info()->restart_block.fn =
+                        do_no_restart_syscall;
         case -ERESTARTNOHAND:
                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
                 regs->gr[28] = -EINTR;
@@ -485,6 +493,8 @@ syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
                  * we have to do is fiddle the return pointer.
                  */
                 regs->gr[31] -= 8; /* delayed branching */
+                /* Preserve original r28. */
+                regs->gr[28] = regs->orig_r28;
                 break;
         }
 }
@@ -492,9 +502,6 @@ syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 static inline void
 insert_restart_trampoline(struct pt_regs *regs)
 {
-        if (regs->orig_r28)
-                return;
-        regs->orig_r28 = 1; /* no more restarts */
         switch(regs->gr[28]) {
         case -ERESTART_RESTARTBLOCK: {
                 /* Restart the system call - no handlers present */
@@ -529,6 +536,9 @@ insert_restart_trampoline(struct pt_regs *regs)
                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
 
                 regs->gr[31] = regs->gr[30] + 8;
+                /* Preserve original r28. */
+                regs->gr[28] = regs->orig_r28;
+
                 return;
         }
         case -ERESTARTNOHAND:
@@ -540,6 +550,9 @@ insert_restart_trampoline(struct pt_regs *regs)
                  * slot of the branch external instruction.
                  */
                 regs->gr[31] -= 8;
+                /* Preserve original r28. */
+                regs->gr[28] = regs->orig_r28;
+
                 return;
         }
         default:
@@ -564,21 +577,51 @@ do_signal(struct pt_regs *regs, long in_syscall)
         siginfo_t info;
         struct k_sigaction ka;
         int signr;
+        sigset_t *oldset;
+
+        DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
+               oldset, regs, regs->sr[7], in_syscall);
+
+        /* Everyone else checks to see if they are in kernel mode at
+           this point and exits if that's the case.  I'm not sure why
+           we would be called in that case, but for some reason we
+           are. */
 
-        DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
-               regs, regs->sr[7], in_syscall);
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
+                oldset = &current->blocked;
 
-        signr = get_signal_to_deliver(&info, &ka, regs, NULL);
-        DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
+        DBG(1,"do_signal: oldset %08lx / %08lx\n", 
+                oldset->sig[0], oldset->sig[1]);
+
+
+        /* May need to force signal if handle_signal failed to deliver */
+        while (1) {
+          
+                signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+                DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
         
-        if (signr > 0) {
+                if (signr <= 0)
+                  break;
+                
                 /* Restart a system call if necessary. */
                 if (in_syscall)
                         syscall_restart(regs, &ka);
 
-                handle_signal(signr, &info, &ka, regs, in_syscall);
-                return;
+                /* Whee!  Actually deliver the signal.  If the
+                   delivery failed, we need to continue to iterate in
+                   this loop so we can deliver the SIGSEGV... */
+                if (handle_signal(signr, &info, &ka, oldset,
+                                  regs, in_syscall)) {
+                        DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
+                                regs->gr[28]);
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                        return;
+                }
         }
+        /* end of while(1) looping forever if we can't force a signal */
 
         /* Did we come from a system call? */
         if (in_syscall)
@@ -587,16 +630,24 @@ do_signal(struct pt_regs *regs, long in_syscall)
         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
                 regs->gr[28]);
 
-        restore_saved_sigmask();
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
+
+        return;
 }
 
 void do_notify_resume(struct pt_regs *regs, long in_syscall)
 {
-        if (test_thread_flag(TIF_SIGPENDING))
+        if (test_thread_flag(TIF_SIGPENDING) ||
+            test_thread_flag(TIF_RESTORE_SIGMASK))
                 do_signal(regs, in_syscall);
 
         if (test_thread_flag(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/parisc/kernel/signal32.c b/arch/parisc/kernel/signal32.c
index 5dede04f2f3..e1413243076 100644
--- a/arch/parisc/kernel/signal32.c
+++ b/arch/parisc/kernel/signal32.c
@@ -47,6 +47,8 @@
 #define DBG(LEVEL, ...)
 #endif
 
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 inline void
 sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
 {
@@ -65,8 +67,7 @@ put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
 {
         compat_sigset_t s;
 
-        if (sz != sizeof *set)
-                return -EINVAL;
+        if (sz != sizeof *set) panic("put_sigset32()");
         sigset_64to32(&s, set);
 
         return copy_to_user(up, &s, sizeof s);
@@ -78,8 +79,7 @@ get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
         compat_sigset_t s;
         int r;
 
-        if (sz != sizeof *set)
-                return -EINVAL;
+        if (sz != sizeof *set) panic("put_sigset32()");
 
         if ((r = copy_from_user(&s, up, sz)) == 0) {
                 sigset_32to64(set, &s);
diff --git a/arch/parisc/kernel/signal32.h b/arch/parisc/kernel/signal32.h
index 08a88b5349a..c7800846422 100644
--- a/arch/parisc/kernel/signal32.h
+++ b/arch/parisc/kernel/signal32.h
@@ -55,6 +55,58 @@ struct k_sigaction32 {
         struct compat_sigaction sa;
 };
 
+typedef struct compat_siginfo {
+        int si_signo;
+        int si_errno;
+        int si_code;
+
+        union {
+                int _pad[((128/sizeof(int)) - 3)];
+
+                /* kill() */
+                struct {
+                        unsigned int _pid;      /* sender's pid */
+                        unsigned int _uid;      /* sender's uid */
+                } _kill;
+
+                /* POSIX.1b timers */
+                struct {
+                        compat_timer_t _tid;            /* timer id */
+                        int _overrun;           /* overrun count */
+                        char _pad[sizeof(unsigned int) - sizeof(int)];
+                        compat_sigval_t _sigval;        /* same as below */
+                        int _sys_private;       /* not to be passed to user */
+                } _timer;
+
+                /* POSIX.1b signals */
+                struct {
+                        unsigned int _pid;      /* sender's pid */
+                        unsigned int _uid;      /* sender's uid */
+                        compat_sigval_t _sigval;
+                } _rt;
+
+                /* SIGCHLD */
+                struct {
+                        unsigned int _pid;      /* which child */
+                        unsigned int _uid;      /* sender's uid */
+                        int _status;            /* exit code */
+                        compat_clock_t _utime;
+                        compat_clock_t _stime;
+                } _sigchld;
+
+                /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+                struct {
+                        unsigned int _addr;     /* faulting insn/memory ref. */
+                } _sigfault;
+
+                /* SIGPOLL */
+                struct {
+                        int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
+                        int _fd;
+                } _sigpoll;
+        } _sifields;
+} compat_siginfo_t;
+
 int copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from);
 int copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from);
 
diff --git a/arch/parisc/kernel/smp.c b/arch/parisc/kernel/smp.c
index 6266730efd6..32d588488f0 100644
--- a/arch/parisc/kernel/smp.c
+++ b/arch/parisc/kernel/smp.c
@@ -31,8 +31,8 @@
 #include <linux/delay.h>
 #include <linux/bitops.h>
 #include <linux/ftrace.h>
-#include <linux/cpu.h>
 
+#include <asm/system.h>
 #include <linux/atomic.h>
 #include <asm/current.h>
 #include <asm/delay.h>
@@ -291,15 +291,13 @@ smp_cpu_init(int cpunum)
         mb();
 
         /* Well, support 2.4 linux scheme as well. */
-        if (cpu_online(cpunum)) {
+        if (cpu_isset(cpunum, cpu_online_map))
+        {
                 extern void machine_halt(void); /* arch/parisc.../process.c */
 
                 printk(KERN_CRIT "CPU#%d already initialized!\n", cpunum);
                 machine_halt();
-        }
-
-        notify_cpu_starting(cpunum);
-
+        }  
         set_cpu_online(cpunum, true);
 
         /* Initialise the idle task for this CPU */
@@ -338,11 +336,26 @@ void __init smp_callin(void)
 /*
  * Bring one cpu online.
  */
-int __cpuinit smp_boot_one_cpu(int cpuid, struct task_struct *idle)
+int __cpuinit smp_boot_one_cpu(int cpuid)
 {
         const struct cpuinfo_parisc *p = &per_cpu(cpu_data, cpuid);
+        struct task_struct *idle;
         long timeout;
 
+        /* 
+         * Create an idle task for this CPU.  Note the address wed* give 
+         * to kernel_thread is irrelevant -- it's going to start
+         * where OS_BOOT_RENDEVZ vector in SAL says to start.  But
+         * this gets all the other task-y sort of data structures set
+         * up like we wish.   We need to pull the just created idle task 
+         * off the run queue and stuff it into the init_tasks[] array.  
+         * Sheesh . . .
+         */
+
+        idle = fork_idle(cpuid);
+        if (IS_ERR(idle))
+                panic("SMP: fork failed for CPU:%d", cpuid);
+
         task_thread_info(idle)->cpu = cpuid;
 
         /* Let _start know what logical CPU we're booting
@@ -386,6 +399,10 @@ int __cpuinit smp_boot_one_cpu(int cpuid, struct task_struct *idle)
                 udelay(100);
                 barrier();
         }
+
+        put_task_struct(idle);
+        idle = NULL;
+
         printk(KERN_CRIT "SMP: CPU:%d is stuck.\n", cpuid);
         return -1;
 
@@ -434,10 +451,10 @@ void smp_cpus_done(unsigned int cpu_max)
 }
 
 
-int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *tidle)
+int __cpuinit __cpu_up(unsigned int cpu)
 {
         if (cpu != 0 && cpu < parisc_max_cpus)
-                smp_boot_one_cpu(cpu, tidle);
+                smp_boot_one_cpu(cpu);
 
         return cpu_online(cpu) ? 0 : -ENOSYS;
 }
diff --git a/arch/parisc/kernel/sys_parisc.c b/arch/parisc/kernel/sys_parisc.c
index f76c10863c6..c9b932260f4 100644
--- a/arch/parisc/kernel/sys_parisc.c
+++ b/arch/parisc/kernel/sys_parisc.c
@@ -73,8 +73,6 @@ static unsigned long get_shared_area(struct address_space *mapping,
         struct vm_area_struct *vma;
         int offset = mapping ? get_offset(mapping) : 0;
 
-        offset = (offset + (pgoff << PAGE_SHIFT)) & 0x3FF000;
-
         addr = DCACHE_ALIGN(addr - offset) + offset;
 
         for (vma = find_vma(current->mm, addr); ; vma = vma->vm_next) {
@@ -227,12 +225,12 @@ long parisc_personality(unsigned long personality)
         long err;
 
         if (personality(current->personality) == PER_LINUX32
-            && personality(personality) == PER_LINUX)
-                personality = (personality & ~PER_MASK) | PER_LINUX32;
+            && personality == PER_LINUX)
+                personality = PER_LINUX32;
 
         err = sys_personality(personality);
-        if (personality(err) == PER_LINUX32)
-                err = (err & ~PER_MASK) | PER_LINUX;
+        if (err == PER_LINUX32)
+                err = PER_LINUX;
 
         return err;
 }
diff --git a/arch/parisc/kernel/sys_parisc32.c b/arch/parisc/kernel/sys_parisc32.c
index 9cfdaa19ab6..dc9a6246232 100644
--- a/arch/parisc/kernel/sys_parisc32.c
+++ b/arch/parisc/kernel/sys_parisc32.c
@@ -53,6 +53,28 @@
 #define DBG(x)
 #endif
 
+/*
+ * sys32_execve() executes a new program.
+ */
+
+asmlinkage int sys32_execve(struct pt_regs *regs)
+{
+        int error;
+        char *filename;
+
+        DBG(("sys32_execve(%p) r26 = 0x%lx\n", regs, regs->gr[26]));
+        filename = getname((const char __user *) regs->gr[26]);
+        error = PTR_ERR(filename);
+        if (IS_ERR(filename))
+                goto out;
+        error = compat_do_execve(filename, compat_ptr(regs->gr[25]),
+                                 compat_ptr(regs->gr[24]), regs);
+        putname(filename);
+out:
+
+        return error;
+}
+
 asmlinkage long sys32_unimplemented(int r26, int r25, int r24, int r23,
         int r22, int r21, int r20)
 {
diff --git a/arch/parisc/kernel/syscall.S b/arch/parisc/kernel/syscall.S
index 86742df0b19..82a52b2fb13 100644
--- a/arch/parisc/kernel/syscall.S
+++ b/arch/parisc/kernel/syscall.S
@@ -156,7 +156,7 @@ linux_gateway_entry:
         STREG   %r26, TASK_PT_GR26(%r1)         /* 1st argument */
         STREG   %r27, TASK_PT_GR27(%r1)         /* user dp */
         STREG   %r28, TASK_PT_GR28(%r1)         /* return value 0 */
-        STREG   %r0, TASK_PT_ORIG_R28(%r1)      /* don't prohibit restarts */
+        STREG   %r28, TASK_PT_ORIG_R28(%r1)     /* return value 0 (saved for signals) */
         STREG   %r29, TASK_PT_GR29(%r1)         /* return value 1 */
         STREG   %r31, TASK_PT_GR31(%r1)         /* preserve syscall return ptr */
         
@@ -180,10 +180,9 @@ linux_gateway_entry:
 
         /* Are we being ptraced? */
         mfctl   %cr30, %r1
-        LDREG   TI_FLAGS(%r1),%r1
-        ldi     _TIF_SYSCALL_TRACE_MASK, %r19
-        and,COND(=) %r1, %r19, %r0
-        b,n     .Ltracesys
+        LDREG   TI_TASK(%r1),%r1
+        ldw     TASK_PTRACE(%r1), %r1
+        bb,<,n  %r1,31,.Ltracesys
         
         /* Note!  We cannot use the syscall table that is mapped
         nearby since the gateway page is mapped execute-only. */
diff --git a/arch/parisc/kernel/syscall_table.S b/arch/parisc/kernel/syscall_table.S
index 54d950b067b..3735abd7f8f 100644
--- a/arch/parisc/kernel/syscall_table.S
+++ b/arch/parisc/kernel/syscall_table.S
@@ -60,13 +60,13 @@
         ENTRY_SAME(fork_wrapper)
         ENTRY_SAME(read)
         ENTRY_SAME(write)
-        ENTRY_COMP(open)                /* 5 */
+        ENTRY_SAME(open)                /* 5 */
         ENTRY_SAME(close)
         ENTRY_SAME(waitpid)
         ENTRY_SAME(creat)
         ENTRY_SAME(link)
         ENTRY_SAME(unlink)              /* 10 */
-        ENTRY_COMP(execve)
+        ENTRY_DIFF(execve_wrapper)
         ENTRY_SAME(chdir)
         /* See comments in kernel/time.c!!! Maybe we don't need this? */
         ENTRY_COMP(time)
diff --git a/arch/parisc/kernel/time.c b/arch/parisc/kernel/time.c
index 70e105d6242..45b7389d77a 100644
--- a/arch/parisc/kernel/time.c
+++ b/arch/parisc/kernel/time.c
@@ -29,7 +29,6 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/page.h>
 #include <asm/param.h>
 #include <asm/pdc.h>
 #include <asm/led.h>
@@ -199,6 +198,8 @@ static struct clocksource clocksource_cr16 = {
         .rating                 = 300,
         .read                   = read_cr16,
         .mask                   = CLOCKSOURCE_MASK(BITS_PER_LONG),
+        .mult                   = 0, /* to be set */
+        .shift                  = 22,
         .flags                  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
@@ -269,5 +270,7 @@ void __init time_init(void)
 
         /* register at clocksource framework */
         current_cr16_khz = PAGE0->mem_10msec/10;  /* kHz */
-        clocksource_register_khz(&clocksource_cr16, current_cr16_khz);
+        clocksource_cr16.mult = clocksource_khz2mult(current_cr16_khz,
+                                                clocksource_cr16.shift);
+        clocksource_register(&clocksource_cr16);
 }
diff --git a/arch/parisc/kernel/traps.c b/arch/parisc/kernel/traps.c
index 45ba99f5080..f19e6604026 100644
--- a/arch/parisc/kernel/traps.c
+++ b/arch/parisc/kernel/traps.c
@@ -27,6 +27,7 @@
 #include <linux/bug.h>
 
 #include <asm/assembly.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/irq.h>
diff --git a/arch/parisc/kernel/vmlinux.lds.S b/arch/parisc/kernel/vmlinux.lds.S
index 64a999882e4..fa6f2b8163e 100644
--- a/arch/parisc/kernel/vmlinux.lds.S
+++ b/arch/parisc/kernel/vmlinux.lds.S
@@ -50,10 +50,8 @@ SECTIONS
         . = KERNEL_BINARY_TEXT_START;
 
         _text = .;              /* Text and read-only data */
-        .head ALIGN(16) : {
-                HEAD_TEXT
-        } = 0
         .text ALIGN(16) : {
+                HEAD_TEXT
                 TEXT_TEXT
                 SCHED_TEXT
                 LOCK_TEXT
@@ -67,7 +65,7 @@ SECTIONS
                 *(.fixup)
                 *(.lock.text)           /* out-of-line lock text */
                 *(.gnu.warning)
-        }
+        } = 0
         /* End of text section */
         _etext = .;