Patched in Tegra support.

38 files changed, 728 insertions, 334 deletions

diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 335eb07480f..bfb4d01e0e5 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -50,6 +50,7 @@
 #include <asm/iosapic.h>
 #include <asm/machvec.h>
 #include <asm/page.h>
+#include <asm/system.h>
 #include <asm/numa.h>
 #include <asm/sal.h>
 #include <asm/cyclone.h>
@@ -348,11 +349,11 @@ acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
 
         iosapic_override_isa_irq(p->source_irq, p->global_irq,
                                  ((p->inti_flags & ACPI_MADT_POLARITY_MASK) ==
-                                  ACPI_MADT_POLARITY_ACTIVE_LOW) ?
-                                 IOSAPIC_POL_LOW : IOSAPIC_POL_HIGH,
+                                  ACPI_MADT_POLARITY_ACTIVE_HIGH) ?
+                                 IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
                                  ((p->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
-                                 ACPI_MADT_TRIGGER_LEVEL) ?
-                                 IOSAPIC_LEVEL : IOSAPIC_EDGE);
+                                 ACPI_MADT_TRIGGER_EDGE) ?
+                                 IOSAPIC_EDGE : IOSAPIC_LEVEL);
         return 0;
 }
 
@@ -422,30 +423,28 @@ static int __init acpi_parse_madt(struct acpi_table_header *table)
 #define PXM_FLAG_LEN ((MAX_PXM_DOMAINS + 1)/32)
 
 static int __initdata srat_num_cpus;    /* number of cpus */
-static u32 pxm_flag[PXM_FLAG_LEN];
+static u32 __devinitdata pxm_flag[PXM_FLAG_LEN];
 #define pxm_bit_set(bit)        (set_bit(bit,(void *)pxm_flag))
 #define pxm_bit_test(bit)       (test_bit(bit,(void *)pxm_flag))
 static struct acpi_table_slit __initdata *slit_table;
 cpumask_t early_cpu_possible_map = CPU_MASK_NONE;
 
-static int __init
-get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
+static int get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
 {
         int pxm;
 
         pxm = pa->proximity_domain_lo;
-        if (ia64_platform_is("sn2") || acpi_srat_revision >= 2)
+        if (ia64_platform_is("sn2"))
                 pxm += pa->proximity_domain_hi[0] << 8;
         return pxm;
 }
 
-static int __init
-get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
+static int get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
 {
         int pxm;
 
         pxm = ma->proximity_domain;
-        if (!ia64_platform_is("sn2") && acpi_srat_revision <= 1)
+        if (!ia64_platform_is("sn2"))
                 pxm &= 0xff;
 
         return pxm;
@@ -497,7 +496,7 @@ acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
         srat_num_cpus++;
 }
 
-int __init
+void __init
 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 {
         unsigned long paddr, size;
@@ -512,7 +511,7 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 
         /* Ignore disabled entries */
         if (!(ma->flags & ACPI_SRAT_MEM_ENABLED))
-                return -1;
+                return;
 
         /* record this node in proximity bitmap */
         pxm_bit_set(pxm);
@@ -531,7 +530,6 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
         p->size = size;
         p->nid = pxm;
         num_node_memblks++;
-        return 0;
 }
 
 void __init acpi_numa_arch_fixup(void)
@@ -633,7 +631,6 @@ int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
                                       ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
                                      IOSAPIC_LEVEL);
 }
-EXPORT_SYMBOL_GPL(acpi_register_gsi);
 
 void acpi_unregister_gsi(u32 gsi)
 {
@@ -645,7 +642,6 @@ void acpi_unregister_gsi(u32 gsi)
 
         iosapic_unregister_intr(gsi);
 }
-EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
 
 static int __init acpi_parse_fadt(struct acpi_table_header *table)
 {
@@ -842,11 +838,11 @@ static __init int setup_additional_cpus(char *s)
 early_param("additional_cpus", setup_additional_cpus);
 
 /*
- * cpu_possible_mask should be static, it cannot change as CPUs
+ * cpu_possible_map should be static, it cannot change as CPUs
  * are onlined, or offlined. The reason is per-cpu data-structures
  * are allocated by some modules at init time, and dont expect to
  * do this dynamically on cpu arrival/departure.
- * cpu_present_mask on the other hand can change dynamically.
+ * cpu_present_map on the other hand can change dynamically.
  * In case when cpu_hotplug is not compiled, then we resort to current
  * behaviour, which is cpu_possible == cpu_present.
  * - Ashok Raj
@@ -924,7 +920,7 @@ static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu)
 
         acpi_map_cpu2node(handle, cpu, physid);
 
-        set_cpu_present(cpu, true);
+        cpu_set(cpu, cpu_present_map);
         ia64_cpu_to_sapicid[cpu] = physid;
 
         acpi_processor_set_pdc(handle);
@@ -943,7 +939,7 @@ EXPORT_SYMBOL(acpi_map_lsapic);
 int acpi_unmap_lsapic(int cpu)
 {
         ia64_cpu_to_sapicid[cpu] = -1;
-        set_cpu_present(cpu, false);
+        cpu_clear(cpu, cpu_present_map);
 
 #ifdef CONFIG_ACPI_NUMA
         /* NUMA specific cleanup's */
@@ -956,8 +952,8 @@ EXPORT_SYMBOL(acpi_unmap_lsapic);
 #endif                          /* CONFIG_ACPI_HOTPLUG_CPU */
 
 #ifdef CONFIG_ACPI_NUMA
-static acpi_status acpi_map_iosapic(acpi_handle handle, u32 depth,
-                                    void *context, void **ret)
+static acpi_status __devinit
+acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *obj;
diff --git a/arch/ia64/kernel/asm-offsets.c b/arch/ia64/kernel/asm-offsets.c
index a48bd9a9927..af565016904 100644
--- a/arch/ia64/kernel/asm-offsets.c
+++ b/arch/ia64/kernel/asm-offsets.c
@@ -269,8 +269,8 @@ void foo(void)
         BLANK();
 
         /* used by fsys_gettimeofday in arch/ia64/kernel/fsys.S */
-        DEFINE(IA64_GTOD_SEQ_OFFSET,
-               offsetof (struct fsyscall_gtod_data_t, seq));
+        DEFINE(IA64_GTOD_LOCK_OFFSET,
+                offsetof (struct fsyscall_gtod_data_t, lock));
         DEFINE(IA64_GTOD_WALL_TIME_OFFSET,
                 offsetof (struct fsyscall_gtod_data_t, wall_time));
         DEFINE(IA64_GTOD_MONO_TIME_OFFSET,
diff --git a/arch/ia64/kernel/dma-mapping.c b/arch/ia64/kernel/dma-mapping.c
index 7f791623820..f2c1600da09 100644
--- a/arch/ia64/kernel/dma-mapping.c
+++ b/arch/ia64/kernel/dma-mapping.c
@@ -1,5 +1,4 @@
 #include <linux/dma-mapping.h>
-#include <linux/export.h>
 
 /* Set this to 1 if there is a HW IOMMU in the system */
 int iommu_detected __read_mostly;
diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index f034563aeae..c38d22e5e90 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -39,7 +39,6 @@
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/mca.h>
-#include <asm/setup.h>
 #include <asm/tlbflush.h>
 
 #define EFI_DEBUG       0
@@ -870,7 +869,7 @@ kern_mem_attribute (unsigned long phys_addr, unsigned long size)
 EXPORT_SYMBOL(kern_mem_attribute);
 
 int
-valid_phys_addr_range (phys_addr_t phys_addr, unsigned long size)
+valid_phys_addr_range (unsigned long phys_addr, unsigned long size)
 {
         u64 attr;
 
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index 6bfd8429ee0..198c753d100 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -61,13 +61,14 @@ ENTRY(ia64_execve)
          * Allocate 8 input registers since ptrace() may clobber them
          */
         .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
-        alloc loc1=ar.pfs,8,2,3,0
+        alloc loc1=ar.pfs,8,2,4,0
         mov loc0=rp
         .body
         mov out0=in0                    // filename
         ;;                              // stop bit between alloc and call
         mov out1=in1                    // argv
         mov out2=in2                    // envp
+        add out3=16,sp                  // regs
         br.call.sptk.many rp=sys_execve
 .ret0:
         cmp4.ge p6,p7=r8,r0
@@ -75,6 +76,7 @@ ENTRY(ia64_execve)
         sxt4 r8=r8                      // return 64-bit result
         ;;
         stf.spill [sp]=f0
+(p6)    cmp.ne pKStk,pUStk=r0,r0        // a successful execve() lands us in user-mode...
         mov rp=loc0
 (p6)    mov ar.pfs=r0                   // clear ar.pfs on success
 (p7)    br.ret.sptk.many rp
@@ -116,12 +118,13 @@ GLOBAL_ENTRY(sys_clone2)
         mov loc1=r16                            // save ar.pfs across do_fork
         .body
         mov out1=in1
-        mov out2=in2
+        mov out3=in2
         tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-        mov out3=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
+        mov out4=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
         ;;
 (p6)    st8 [r2]=in5                            // store TLS in r16 for copy_thread()
-        mov out4=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        mov out5=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
         mov out0=in0                            // out0 = clone_flags
         br.call.sptk.many rp=do_fork
 .ret1:  .restore sp
@@ -147,12 +150,13 @@ GLOBAL_ENTRY(sys_clone)
         mov loc1=r16                            // save ar.pfs across do_fork
         .body
         mov out1=in1
-        mov out2=16                             // stacksize (compensates for 16-byte scratch area)
+        mov out3=16                             // stacksize (compensates for 16-byte scratch area)
         tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-        mov out3=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
+        mov out4=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
         ;;
 (p6)    st8 [r2]=in4                            // store TLS in r13 (tp)
-        mov out4=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        mov out5=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
         mov out0=in0                            // out0 = clone_flags
         br.call.sptk.many rp=do_fork
 .ret2:  .restore sp
@@ -480,6 +484,19 @@ GLOBAL_ENTRY(prefetch_stack)
         br.ret.sptk.many rp
 END(prefetch_stack)
 
+GLOBAL_ENTRY(kernel_execve)
+        rum psr.ac
+        mov r15=__NR_execve                     // put syscall number in place
+        break __BREAK_SYSCALL
+        br.ret.sptk.many rp
+END(kernel_execve)
+
+GLOBAL_ENTRY(clone)
+        mov r15=__NR_clone                      // put syscall number in place
+        break __BREAK_SYSCALL
+        br.ret.sptk.many rp
+END(clone)
+
         /*
          * Invoke a system call, but do some tracing before and after the call.
          * We MUST preserve the current register frame throughout this routine
@@ -583,27 +600,6 @@ GLOBAL_ENTRY(ia64_strace_leave_kernel)
 .ret4:  br.cond.sptk ia64_leave_kernel
 END(ia64_strace_leave_kernel)
 
-ENTRY(call_payload)
-        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(0)
-        /* call the kernel_thread payload; fn is in r4, arg - in r5 */
-        alloc loc1=ar.pfs,0,3,1,0
-        mov loc0=rp
-        mov loc2=gp
-        mov out0=r5             // arg
-        ld8 r14 = [r4], 8       // fn.address
-        ;;
-        mov b6 = r14
-        ld8 gp = [r4]           // fn.gp
-        ;;
-        br.call.sptk.many rp=b6 // fn(arg)
-.ret12: mov gp=loc2
-        mov rp=loc0
-        mov ar.pfs=loc1
-        /* ... and if it has returned, we are going to userland */
-        cmp.ne pKStk,pUStk=r0,r0
-        br.ret.sptk.many rp
-END(call_payload)
-
 GLOBAL_ENTRY(ia64_ret_from_clone)
         PT_REGS_UNWIND_INFO(0)
 {       /*
@@ -620,7 +616,6 @@ GLOBAL_ENTRY(ia64_ret_from_clone)
         br.call.sptk.many rp=ia64_invoke_schedule_tail
 }
 .ret8:
-(pKStk) br.call.sptk.many rp=call_payload
         adds r2=TI_FLAGS+IA64_TASK_SIZE,r13
         ;;
         ld4 r2=[r2]
@@ -1782,10 +1777,6 @@ sys_call_table:
         data8 sys_syncfs
         data8 sys_setns                         // 1330
         data8 sys_sendmmsg
-        data8 sys_process_vm_readv
-        data8 sys_process_vm_writev
-        data8 sys_accept4
-        data8 sys_finit_module                  // 1335
 
         .org sys_call_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
 #endif /* __IA64_ASM_PARAVIRTUALIZED_NATIVE */
diff --git a/arch/ia64/kernel/err_inject.c b/arch/ia64/kernel/err_inject.c
index 2d67317a1ec..c539c689493 100644
--- a/arch/ia64/kernel/err_inject.c
+++ b/arch/ia64/kernel/err_inject.c
@@ -24,7 +24,7 @@
  * Copyright (C) 2006, Intel Corp.  All rights reserved.
  *
  */
-#include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>
@@ -35,10 +35,10 @@
 #define ERR_DATA_BUFFER_SIZE 3          // Three 8-byte;
 
 #define define_one_ro(name)                                             \
-static DEVICE_ATTR(name, 0444, show_##name, NULL)
+static SYSDEV_ATTR(name, 0444, show_##name, NULL)
 
 #define define_one_rw(name)                                             \
-static DEVICE_ATTR(name, 0644, show_##name, store_##name)
+static SYSDEV_ATTR(name, 0644, show_##name, store_##name)
 
 static u64 call_start[NR_CPUS];
 static u64 phys_addr[NR_CPUS];
@@ -55,7 +55,7 @@ static u64 resources[NR_CPUS];
 
 #define show(name)                                                      \
 static ssize_t                                                          \
-show_##name(struct device *dev, struct device_attribute *attr,  \
+show_##name(struct sys_device *dev, struct sysdev_attribute *attr,      \
                 char *buf)                                              \
 {                                                                       \
         u32 cpu=dev->id;                                                \
@@ -64,7 +64,7 @@ show_##name(struct device *dev, struct device_attribute *attr,	\
 
 #define store(name)                                                     \
 static ssize_t                                                          \
-store_##name(struct device *dev, struct device_attribute *attr, \
+store_##name(struct sys_device *dev, struct sysdev_attribute *attr,     \
                                         const char *buf, size_t size)   \
 {                                                                       \
         unsigned int cpu=dev->id;                                       \
@@ -78,7 +78,7 @@ show(call_start)
  * processor. The cpu number in driver is only used for storing data.
  */
 static ssize_t
-store_call_start(struct device *dev, struct device_attribute *attr,
+store_call_start(struct sys_device *dev, struct sysdev_attribute *attr,
                 const char *buf, size_t size)
 {
         unsigned int cpu=dev->id;
@@ -127,7 +127,7 @@ show(err_type_info)
 store(err_type_info)
 
 static ssize_t
-show_virtual_to_phys(struct device *dev, struct device_attribute *attr,
+show_virtual_to_phys(struct sys_device *dev, struct sysdev_attribute *attr,
                         char *buf)
 {
         unsigned int cpu=dev->id;
@@ -135,7 +135,7 @@ show_virtual_to_phys(struct device *dev, struct device_attribute *attr,
 }
 
 static ssize_t
-store_virtual_to_phys(struct device *dev, struct device_attribute *attr,
+store_virtual_to_phys(struct sys_device *dev, struct sysdev_attribute *attr,
                         const char *buf, size_t size)
 {
         unsigned int cpu=dev->id;
@@ -159,8 +159,8 @@ show(err_struct_info)
 store(err_struct_info)
 
 static ssize_t
-show_err_data_buffer(struct device *dev,
-                        struct device_attribute *attr, char *buf)
+show_err_data_buffer(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         unsigned int cpu=dev->id;
 
@@ -171,8 +171,8 @@ show_err_data_buffer(struct device *dev,
 }
 
 static ssize_t
-store_err_data_buffer(struct device *dev,
-                        struct device_attribute *attr,
+store_err_data_buffer(struct sys_device *dev,
+                        struct sysdev_attribute *attr,
                         const char *buf, size_t size)
 {
         unsigned int cpu=dev->id;
@@ -209,14 +209,14 @@ define_one_ro(capabilities);
 define_one_ro(resources);
 
 static struct attribute *default_attrs[] = {
-        &dev_attr_call_start.attr,
-        &dev_attr_virtual_to_phys.attr,
-        &dev_attr_err_type_info.attr,
-        &dev_attr_err_struct_info.attr,
-        &dev_attr_err_data_buffer.attr,
-        &dev_attr_status.attr,
-        &dev_attr_capabilities.attr,
-        &dev_attr_resources.attr,
+        &attr_call_start.attr,
+        &attr_virtual_to_phys.attr,
+        &attr_err_type_info.attr,
+        &attr_err_struct_info.attr,
+        &attr_err_data_buffer.attr,
+        &attr_status.attr,
+        &attr_capabilities.attr,
+        &attr_resources.attr,
         NULL
 };
 
@@ -225,12 +225,12 @@ static struct attribute_group err_inject_attr_group = {
         .name = "err_inject"
 };
 /* Add/Remove err_inject interface for CPU device */
-static int __cpuinit err_inject_add_dev(struct device * sys_dev)
+static int __cpuinit err_inject_add_dev(struct sys_device * sys_dev)
 {
         return sysfs_create_group(&sys_dev->kobj, &err_inject_attr_group);
 }
 
-static int __cpuinit err_inject_remove_dev(struct device * sys_dev)
+static int __cpuinit err_inject_remove_dev(struct sys_device * sys_dev)
 {
         sysfs_remove_group(&sys_dev->kobj, &err_inject_attr_group);
         return 0;
@@ -239,9 +239,9 @@ static int __cpuinit err_inject_cpu_callback(struct notifier_block *nfb,
                 unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
-        struct device *sys_dev;
+        struct sys_device *sys_dev;
 
-        sys_dev = get_cpu_device(cpu);
+        sys_dev = get_cpu_sysdev(cpu);
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
@@ -283,13 +283,13 @@ static void __exit
 err_inject_exit(void)
 {
         int i;
-        struct device *sys_dev;
+        struct sys_device *sys_dev;
 
 #ifdef ERR_INJ_DEBUG
         printk(KERN_INFO "Exit error injection driver.\n");
 #endif
         for_each_online_cpu(i) {
-                sys_dev = get_cpu_device(i);
+                sys_dev = get_cpu_sysdev(i);
                 sysfs_remove_group(&sys_dev->kobj, &err_inject_attr_group);
         }
         unregister_hotcpu_notifier(&err_inject_cpu_notifier);
diff --git a/arch/ia64/kernel/fsys.S b/arch/ia64/kernel/fsys.S
index e662f178b99..331d42bda77 100644
--- a/arch/ia64/kernel/fsys.S
+++ b/arch/ia64/kernel/fsys.S
@@ -21,6 +21,7 @@
 #include <asm/thread_info.h>
 #include <asm/sal.h>
 #include <asm/signal.h>
+#include <asm/system.h>
 #include <asm/unistd.h>
 
 #include "entry.h"
@@ -173,7 +174,7 @@ ENTRY(fsys_set_tid_address)
         FSYS_RETURN
 END(fsys_set_tid_address)
 
-#if IA64_GTOD_SEQ_OFFSET !=0
+#if IA64_GTOD_LOCK_OFFSET !=0
 #error fsys_gettimeofday incompatible with changes to struct fsyscall_gtod_data_t
 #endif
 #if IA64_ITC_JITTER_OFFSET !=0
@@ -372,6 +373,175 @@ ENTRY(fsys_clock_gettime)
 END(fsys_clock_gettime)
 
 /*
+ * long fsys_rt_sigprocmask (int how, sigset_t *set, sigset_t *oset, size_t sigsetsize).
+ */
+#if _NSIG_WORDS != 1
+# error Sorry, fsys_rt_sigprocmask() needs to be updated for _NSIG_WORDS != 1.
+#endif
+ENTRY(fsys_rt_sigprocmask)
+        .prologue
+        .altrp b6
+        .body
+
+        add r2=IA64_TASK_BLOCKED_OFFSET,r16
+        add r9=TI_FLAGS+IA64_TASK_SIZE,r16
+        cmp4.ltu p6,p0=SIG_SETMASK,r32
+
+        cmp.ne p15,p0=r0,r34                    // oset != NULL?
+        tnat.nz p8,p0=r34
+        add r31=IA64_TASK_SIGHAND_OFFSET,r16
+        ;;
+        ld8 r3=[r2]                             // read/prefetch current->blocked
+        ld4 r9=[r9]
+        tnat.nz.or p6,p0=r35
+
+        cmp.ne.or p6,p0=_NSIG_WORDS*8,r35
+        tnat.nz.or p6,p0=r32
+(p6)    br.spnt.few .fail_einval                // fail with EINVAL
+        ;;
+#ifdef CONFIG_SMP
+        ld8 r31=[r31]                           // r31 <- current->sighand
+#endif
+        and r9=TIF_ALLWORK_MASK,r9
+        tnat.nz.or p8,p0=r33
+        ;;
+        cmp.ne p7,p0=0,r9
+        cmp.eq p6,p0=r0,r33                     // set == NULL?
+        add r31=IA64_SIGHAND_SIGLOCK_OFFSET,r31 // r31 <- current->sighand->siglock
+(p8)    br.spnt.few .fail_efault                // fail with EFAULT
+(p7)    br.spnt.many fsys_fallback_syscall      // got pending kernel work...
+(p6)    br.dpnt.many .store_mask                // -> short-circuit to just reading the signal mask
+
+        /* Argh, we actually have to do some work and _update_ the signal mask: */
+
+EX(.fail_efault, probe.r.fault r33, 3)          // verify user has read-access to *set
+EX(.fail_efault, ld8 r14=[r33])                 // r14 <- *set
+        mov r17=(1 << (SIGKILL - 1)) | (1 << (SIGSTOP - 1))
+        ;;
+
+        RSM_PSR_I(p0, r18, r19)                 // mask interrupt delivery
+        andcm r14=r14,r17                       // filter out SIGKILL & SIGSTOP
+        mov r8=EINVAL                   // default to EINVAL
+
+#ifdef CONFIG_SMP
+        // __ticket_spin_trylock(r31)
+        ld4 r17=[r31]
+        ;;
+        mov.m ar.ccv=r17
+        extr.u r9=r17,17,15
+        adds r19=1,r17
+        extr.u r18=r17,0,15
+        ;;
+        cmp.eq p6,p7=r9,r18
+        ;;
+(p6)    cmpxchg4.acq r9=[r31],r19,ar.ccv
+(p6)    dep.z r20=r19,1,15              // next serving ticket for unlock
+(p7)    br.cond.spnt.many .lock_contention
+        ;;
+        cmp4.eq p0,p7=r9,r17
+        adds r31=2,r31
+(p7)    br.cond.spnt.many .lock_contention
+        ld8 r3=[r2]                     // re-read current->blocked now that we hold the lock
+        ;;
+#else
+        ld8 r3=[r2]                     // re-read current->blocked now that we hold the lock
+#endif
+        add r18=IA64_TASK_PENDING_OFFSET+IA64_SIGPENDING_SIGNAL_OFFSET,r16
+        add r19=IA64_TASK_SIGNAL_OFFSET,r16
+        cmp4.eq p6,p0=SIG_BLOCK,r32
+        ;;
+        ld8 r19=[r19]                   // r19 <- current->signal
+        cmp4.eq p7,p0=SIG_UNBLOCK,r32
+        cmp4.eq p8,p0=SIG_SETMASK,r32
+        ;;
+        ld8 r18=[r18]                   // r18 <- current->pending.signal
+        .pred.rel.mutex p6,p7,p8
+(p6)    or r14=r3,r14                   // SIG_BLOCK
+(p7)    andcm r14=r3,r14                // SIG_UNBLOCK
+
+(p8)    mov r14=r14                     // SIG_SETMASK
+(p6)    mov r8=0                        // clear error code
+        // recalc_sigpending()
+        add r17=IA64_SIGNAL_GROUP_STOP_COUNT_OFFSET,r19
+
+        add r19=IA64_SIGNAL_SHARED_PENDING_OFFSET+IA64_SIGPENDING_SIGNAL_OFFSET,r19
+        ;;
+        ld4 r17=[r17]           // r17 <- current->signal->group_stop_count
+(p7)    mov r8=0                // clear error code
+
+        ld8 r19=[r19]           // r19 <- current->signal->shared_pending
+        ;;
+        cmp4.gt p6,p7=r17,r0    // p6/p7 <- (current->signal->group_stop_count > 0)?
+(p8)    mov r8=0                // clear error code
+
+        or r18=r18,r19          // r18 <- current->pending | current->signal->shared_pending
+        ;;
+        // r18 <- (current->pending | current->signal->shared_pending) & ~current->blocked:
+        andcm r18=r18,r14
+        add r9=TI_FLAGS+IA64_TASK_SIZE,r16
+        ;;
+
+(p7)    cmp.ne.or.andcm p6,p7=r18,r0            // p6/p7 <- signal pending
+        mov r19=0                                       // i must not leak kernel bits...
+(p6)    br.cond.dpnt.many .sig_pending
+        ;;
+
+1:      ld4 r17=[r9]                            // r17 <- current->thread_info->flags
+        ;;
+        mov ar.ccv=r17
+        and r18=~_TIF_SIGPENDING,r17            // r18 <- r17 & ~(1 << TIF_SIGPENDING)
+        ;;
+
+        st8 [r2]=r14                            // update current->blocked with new mask
+        cmpxchg4.acq r8=[r9],r18,ar.ccv         // current->thread_info->flags <- r18
+        ;;
+        cmp.ne p6,p0=r17,r8                     // update failed?
+(p6)    br.cond.spnt.few 1b                     // yes -> retry
+
+#ifdef CONFIG_SMP
+        // __ticket_spin_unlock(r31)
+        st2.rel [r31]=r20
+        mov r20=0                                       // i must not leak kernel bits...
+#endif
+        SSM_PSR_I(p0, p9, r31)
+        ;;
+
+        srlz.d                                  // ensure psr.i is set again
+        mov r18=0                                       // i must not leak kernel bits...
+
+.store_mask:
+EX(.fail_efault, (p15) probe.w.fault r34, 3)    // verify user has write-access to *oset
+EX(.fail_efault, (p15) st8 [r34]=r3)
+        mov r2=0                                        // i must not leak kernel bits...
+        mov r3=0                                        // i must not leak kernel bits...
+        mov r8=0                                // return 0
+        mov r9=0                                        // i must not leak kernel bits...
+        mov r14=0                                       // i must not leak kernel bits...
+        mov r17=0                                       // i must not leak kernel bits...
+        mov r31=0                                       // i must not leak kernel bits...
+        FSYS_RETURN
+
+.sig_pending:
+#ifdef CONFIG_SMP
+        // __ticket_spin_unlock(r31)
+        st2.rel [r31]=r20                       // release the lock
+#endif
+        SSM_PSR_I(p0, p9, r17)
+        ;;
+        srlz.d
+        br.sptk.many fsys_fallback_syscall      // with signal pending, do the heavy-weight syscall
+
+#ifdef CONFIG_SMP
+.lock_contention:
+        /* Rather than spinning here, fall back on doing a heavy-weight syscall.  */
+        SSM_PSR_I(p0, p9, r17)
+        ;;
+        srlz.d
+        br.sptk.many fsys_fallback_syscall
+#endif
+END(fsys_rt_sigprocmask)
+
+/*
  * fsys_getcpu doesn't use the third parameter in this implementation. It reads
  * current_thread_info()->cpu and corresponding node in cpu_to_node_map.
  */
@@ -390,15 +560,11 @@ ENTRY(fsys_getcpu)
         ;;
         tnat.nz p7,p0 = r33                     // I guard against NaT argument
 (p7)    br.cond.spnt.few .fail_einval           // B
-        ;;
-        cmp.ne p6,p0=r32,r0
-        cmp.ne p7,p0=r33,r0
-        ;;
 #ifdef CONFIG_NUMA
         movl r17=cpu_to_node_map
         ;;
-EX(.fail_efault, (p6) probe.w.fault r32, 3)             // M This takes 5 cycles
-EX(.fail_efault, (p7) probe.w.fault r33, 3)             // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r32, 3)          // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r33, 3)          // M This takes 5 cycles
         shladd r18=r3,1,r17
         ;;
         ld2 r20=[r18]                           // r20 = cpu_to_node_map[cpu]
@@ -408,20 +574,20 @@ EX(.fail_efault, (p7) probe.w.fault r33, 3)		// M This takes 5 cycles
 (p8)    br.spnt.many fsys_fallback_syscall
         ;;
         ;;
-EX(.fail_efault, (p6) st4 [r32] = r3)
-EX(.fail_efault, (p7) st2 [r33] = r20)
+EX(.fail_efault, st4 [r32] = r3)
+EX(.fail_efault, st2 [r33] = r20)
         mov r8=0
         ;;
 #else
-EX(.fail_efault, (p6) probe.w.fault r32, 3)             // M This takes 5 cycles
-EX(.fail_efault, (p7) probe.w.fault r33, 3)             // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r32, 3)          // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r33, 3)          // M This takes 5 cycles
         and r2 = TIF_ALLWORK_MASK,r2
         ;;
         cmp.ne p8,p0=0,r2
 (p8)    br.spnt.many fsys_fallback_syscall
         ;;
-EX(.fail_efault, (p6) st4 [r32] = r3)
-EX(.fail_efault, (p7) st2 [r33] = r0)
+EX(.fail_efault, st4 [r32] = r3)
+EX(.fail_efault, st2 [r33] = r0)
         mov r8=0
         ;;
 #endif
@@ -751,7 +917,7 @@ paravirt_fsyscall_table:
         data8 0                         // sigaltstack
         data8 0                         // rt_sigaction
         data8 0                         // rt_sigpending
-        data8 0                         // rt_sigprocmask
+        data8 fsys_rt_sigprocmask       // rt_sigprocmask
         data8 0                         // rt_sigqueueinfo      // 1180
         data8 0                         // rt_sigreturn
         data8 0                         // rt_sigsuspend
diff --git a/arch/ia64/kernel/fsyscall_gtod_data.h b/arch/ia64/kernel/fsyscall_gtod_data.h
index 146b15b5fec..57d2ee6c83e 100644
--- a/arch/ia64/kernel/fsyscall_gtod_data.h
+++ b/arch/ia64/kernel/fsyscall_gtod_data.h
@@ -6,7 +6,7 @@
  */
 
 struct fsyscall_gtod_data_t {
-        seqcount_t      seq;
+        seqlock_t       lock;
         struct timespec wall_time;
         struct timespec monotonic_time;
         cycle_t         clk_mask;
diff --git a/arch/ia64/kernel/gate.S b/arch/ia64/kernel/gate.S
index b5f8bdd8618..245d3e1ec7e 100644
--- a/arch/ia64/kernel/gate.S
+++ b/arch/ia64/kernel/gate.S
@@ -11,9 +11,8 @@
 #include <asm/errno.h>
 #include <asm/asm-offsets.h>
 #include <asm/sigcontext.h>
+#include <asm/system.h>
 #include <asm/unistd.h>
-#include <asm/kregs.h>
-#include <asm/page.h>
 #include "paravirt_inst.h"
 
 /*
diff --git a/arch/ia64/kernel/gate.lds.S b/arch/ia64/kernel/gate.lds.S
index e518f7902af..d32b0855110 100644
--- a/arch/ia64/kernel/gate.lds.S
+++ b/arch/ia64/kernel/gate.lds.S
@@ -5,7 +5,8 @@
  * its layout.
  */
 
-#include <asm/page.h>
+
+#include <asm/system.h>
 #include "paravirt_patchlist.h"
 
 SECTIONS
diff --git a/arch/ia64/kernel/head.S b/arch/ia64/kernel/head.S
index 4738ff7bd66..17a9fba3893 100644
--- a/arch/ia64/kernel/head.S
+++ b/arch/ia64/kernel/head.S
@@ -30,6 +30,7 @@
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/mca_asm.h>
 #include <linux/init.h>
 #include <linux/linkage.h>
@@ -1093,6 +1094,19 @@ GLOBAL_ENTRY(cycle_to_cputime)
 END(cycle_to_cputime)
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
 
+GLOBAL_ENTRY(start_kernel_thread)
+        .prologue
+        .save rp, r0                            // this is the end of the call-chain
+        .body
+        alloc r2 = ar.pfs, 0, 0, 2, 0
+        mov out0 = r9
+        mov out1 = r11;;
+        br.call.sptk.many rp = kernel_thread_helper;;
+        mov out0 = r8
+        br.call.sptk.many rp = sys_exit;;
+1:      br.sptk.few 1b                          // not reached
+END(start_kernel_thread)
+
 #ifdef CONFIG_IA64_BRL_EMU
 
 /*
diff --git a/arch/ia64/kernel/ia64_ksyms.c b/arch/ia64/kernel/ia64_ksyms.c
index 5b7791dd396..7f4a0ed2415 100644
--- a/arch/ia64/kernel/ia64_ksyms.c
+++ b/arch/ia64/kernel/ia64_ksyms.c
@@ -12,7 +12,7 @@ EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(strlen);
 
-#include <asm/pgtable.h>
+#include<asm/pgtable.h>
 EXPORT_SYMBOL_GPL(empty_zero_page);
 
 #include <asm/checksum.h>
diff --git a/arch/ia64/kernel/iosapic.c b/arch/ia64/kernel/iosapic.c
index ee33c3aaa2f..b0f9afebb14 100644
--- a/arch/ia64/kernel/iosapic.c
+++ b/arch/ia64/kernel/iosapic.c
@@ -98,6 +98,7 @@
 #include <asm/machvec.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 
 #undef DEBUG_INTERRUPT_ROUTING
 
@@ -147,7 +148,7 @@ static struct iosapic_intr_info {
         unsigned char   trigger : 1;    /* trigger mode (see iosapic.h) */
 } iosapic_intr_info[NR_IRQS];
 
-static unsigned char pcat_compat;       /* 8259 compatibility flag */
+static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */
 
 static inline void
 iosapic_write(struct iosapic *iosapic, unsigned int reg, u32 val)
@@ -914,8 +915,10 @@ iosapic_register_platform_intr (u32 int_type, unsigned int gsi,
 /*
  * ACPI calls this when it finds an entry for a legacy ISA IRQ override.
  */
-void iosapic_override_isa_irq(unsigned int isa_irq, unsigned int gsi,
-                              unsigned long polarity, unsigned long trigger)
+void __devinit
+iosapic_override_isa_irq (unsigned int isa_irq, unsigned int gsi,
+                          unsigned long polarity,
+                          unsigned long trigger)
 {
         int vector, irq;
         unsigned int dest = cpu_physical_id(smp_processor_id());
@@ -1010,7 +1013,8 @@ iosapic_check_gsi_range (unsigned int gsi_base, unsigned int ver)
         return 0;
 }
 
-int iosapic_init(unsigned long phys_addr, unsigned int gsi_base)
+int __devinit
+iosapic_init (unsigned long phys_addr, unsigned int gsi_base)
 {
         int num_rte, err, index;
         unsigned int isa_irq, ver;
@@ -1067,7 +1071,9 @@ int iosapic_init(unsigned long phys_addr, unsigned int gsi_base)
         return 0;
 }
 
-int iosapic_remove(unsigned int gsi_base)
+#ifdef CONFIG_HOTPLUG
+int
+iosapic_remove (unsigned int gsi_base)
 {
         int index, err = 0;
         unsigned long flags;
@@ -1093,9 +1099,11 @@ int iosapic_remove(unsigned int gsi_base)
         spin_unlock_irqrestore(&iosapic_lock, flags);
         return err;
 }
+#endif /* CONFIG_HOTPLUG */
 
 #ifdef CONFIG_NUMA
-void map_iosapic_to_node(unsigned int gsi_base, int node)
+void __devinit
+map_iosapic_to_node(unsigned int gsi_base, int node)
 {
         int index;
 
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index 1034884b77d..782c3a357f2 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -23,6 +23,7 @@
 #include <linux/ioport.h>
 #include <linux/kernel_stat.h>
 #include <linux/ptrace.h>
+#include <linux/random.h>       /* for rand_initialize_irq() */
 #include <linux/signal.h>
 #include <linux/smp.h>
 #include <linux/threads.h>
@@ -38,6 +39,7 @@
 #include <asm/hw_irq.h>
 #include <asm/machvec.h>
 #include <asm/pgtable.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 
 #ifdef CONFIG_PERFMON
@@ -116,7 +118,7 @@ static inline int find_unassigned_vector(cpumask_t domain)
         cpumask_t mask;
         int pos, vector;
 
-        cpumask_and(&mask, &domain, cpu_online_mask);
+        cpus_and(mask, domain, cpu_online_map);
         if (cpus_empty(mask))
                 return -EINVAL;
 
@@ -139,7 +141,7 @@ static int __bind_irq_vector(int irq, int vector, cpumask_t domain)
         BUG_ON((unsigned)irq >= NR_IRQS);
         BUG_ON((unsigned)vector >= IA64_NUM_VECTORS);
 
-        cpumask_and(&mask, &domain, cpu_online_mask);
+        cpus_and(mask, domain, cpu_online_map);
         if (cpus_empty(mask))
                 return -EINVAL;
         if ((cfg->vector == vector) && cpus_equal(cfg->domain, domain))
@@ -177,7 +179,7 @@ static void __clear_irq_vector(int irq)
         BUG_ON(cfg->vector == IRQ_VECTOR_UNASSIGNED);
         vector = cfg->vector;
         domain = cfg->domain;
-        cpumask_and(&mask, &cfg->domain, cpu_online_mask);
+        cpus_and(mask, cfg->domain, cpu_online_map);
         for_each_cpu_mask(cpu, mask)
                 per_cpu(vector_irq, cpu)[vector] = -1;
         cfg->vector = IRQ_VECTOR_UNASSIGNED;
@@ -320,7 +322,7 @@ void irq_complete_move(unsigned irq)
         if (unlikely(cpu_isset(smp_processor_id(), cfg->old_domain)))
                 return;
 
-        cpumask_and(&cleanup_mask, &cfg->old_domain, cpu_online_mask);
+        cpus_and(cleanup_mask, cfg->old_domain, cpu_online_map);
         cfg->move_cleanup_count = cpus_weight(cleanup_mask);
         for_each_cpu_mask(i, cleanup_mask)
                 platform_send_ipi(i, IA64_IRQ_MOVE_VECTOR, IA64_IPI_DM_INT, 0);
diff --git a/arch/ia64/kernel/ivt.S b/arch/ia64/kernel/ivt.S
index fa25689fc45..d93e396bf59 100644
--- a/arch/ia64/kernel/ivt.S
+++ b/arch/ia64/kernel/ivt.S
@@ -54,6 +54,7 @@
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/thread_info.h>
 #include <asm/unistd.h>
 #include <asm/errno.h>
diff --git a/arch/ia64/kernel/machine_kexec.c b/arch/ia64/kernel/machine_kexec.c
index 5151a649c96..3d3aeef4694 100644
--- a/arch/ia64/kernel/machine_kexec.c
+++ b/arch/ia64/kernel/machine_kexec.c
@@ -27,11 +27,11 @@
 #include <asm/sal.h>
 #include <asm/mca.h>
 
-typedef void (*relocate_new_kernel_t)(
+typedef NORET_TYPE void (*relocate_new_kernel_t)(
                                         unsigned long indirection_page,
                                         unsigned long start_address,
                                         struct ia64_boot_param *boot_param,
-                                        unsigned long pal_addr) __noreturn;
+                                        unsigned long pal_addr) ATTRIB_NORET;
 
 struct kimage *ia64_kimage;
 
@@ -85,13 +85,12 @@ static void ia64_machine_kexec(struct unw_frame_info *info, void *arg)
         struct kimage *image = arg;
         relocate_new_kernel_t rnk;
         void *pal_addr = efi_get_pal_addr();
-        unsigned long code_addr;
+        unsigned long code_addr = (unsigned long)page_address(image->control_code_page);
         int ii;
         u64 fp, gp;
         ia64_fptr_t *init_handler = (ia64_fptr_t *)ia64_os_init_on_kdump;
 
         BUG_ON(!image);
-        code_addr = (unsigned long)page_address(image->control_code_page);
         if (image->type == KEXEC_TYPE_CRASH) {
                 crash_save_this_cpu();
                 current->thread.ksp = (__u64)info->sw - 16;
@@ -158,7 +157,7 @@ void arch_crash_save_vmcoreinfo(void)
 #endif
 #ifdef CONFIG_PGTABLE_3
         VMCOREINFO_CONFIG(PGTABLE_3);
-#elif defined(CONFIG_PGTABLE_4)
+#elif  CONFIG_PGTABLE_4
         VMCOREINFO_CONFIG(PGTABLE_4);
 #endif
 }
diff --git a/arch/ia64/kernel/machvec.c b/arch/ia64/kernel/machvec.c
index f5a1e5246b3..d41a40ef80c 100644
--- a/arch/ia64/kernel/machvec.c
+++ b/arch/ia64/kernel/machvec.c
@@ -1,6 +1,7 @@
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
 #include <asm/machvec.h>
+#include <asm/system.h>
 
 #ifdef CONFIG_IA64_GENERIC
 
diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
index 65bf9cd3904..84fb405eee8 100644
--- a/arch/ia64/kernel/mca.c
+++ b/arch/ia64/kernel/mca.c
@@ -92,6 +92,7 @@
 #include <asm/meminit.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/sal.h>
 #include <asm/mca.h>
 #include <asm/kexec.h>
@@ -1446,8 +1447,6 @@ out:
         /* Get the CMC error record and log it */
         ia64_mca_log_sal_error_record(SAL_INFO_TYPE_CMC);
 
-        local_irq_disable();
-
         return IRQ_HANDLED;
 }
 
@@ -1514,8 +1513,7 @@ static void
 ia64_mca_cmc_poll (unsigned long dummy)
 {
         /* Trigger a CMC interrupt cascade  */
-        platform_send_ipi(cpumask_first(cpu_online_mask), IA64_CMCP_VECTOR,
-                                                        IA64_IPI_DM_INT, 0);
+        platform_send_ipi(first_cpu(cpu_online_map), IA64_CMCP_VECTOR, IA64_IPI_DM_INT, 0);
 }
 
 /*
@@ -1591,8 +1589,7 @@ static void
 ia64_mca_cpe_poll (unsigned long dummy)
 {
         /* Trigger a CPE interrupt cascade  */
-        platform_send_ipi(cpumask_first(cpu_online_mask), IA64_CPEP_VECTOR,
-                                                        IA64_IPI_DM_INT, 0);
+        platform_send_ipi(first_cpu(cpu_online_map), IA64_CPEP_VECTOR, IA64_IPI_DM_INT, 0);
 }
 
 #endif /* CONFIG_ACPI */
diff --git a/arch/ia64/kernel/mca_drv.c b/arch/ia64/kernel/mca_drv.c
index 9392e021c93..09b4d6828c4 100644
--- a/arch/ia64/kernel/mca_drv.c
+++ b/arch/ia64/kernel/mca_drv.c
@@ -28,6 +28,7 @@
 #include <asm/machvec.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/sal.h>
 #include <asm/mca.h>
 
@@ -158,8 +159,7 @@ mca_handler_bh(unsigned long paddr, void *iip, unsigned long ipsr)
         ia64_mlogbuf_dump();
         printk(KERN_ERR "OS_MCA: process [cpu %d, pid: %d, uid: %d, "
                 "iip: %p, psr: 0x%lx,paddr: 0x%lx](%s) encounters MCA.\n",
-               raw_smp_processor_id(), current->pid,
-                from_kuid(&init_user_ns, current_uid()),
+               raw_smp_processor_id(), current->pid, current_uid(),
                 iip, ipsr, paddr, current->comm);
 
         spin_lock(&mca_bh_lock);
diff --git a/arch/ia64/kernel/msi_ia64.c b/arch/ia64/kernel/msi_ia64.c
index fb2f1e62287..94e0db72d4a 100644
--- a/arch/ia64/kernel/msi_ia64.c
+++ b/arch/ia64/kernel/msi_ia64.c
@@ -57,7 +57,7 @@ int ia64_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
                 return irq;
 
         irq_set_msi_desc(irq, desc);
-        cpumask_and(&mask, &(irq_to_domain(irq)), cpu_online_mask);
+        cpus_and(mask, irq_to_domain(irq), cpu_online_map);
         dest_phys_id = cpu_physical_id(first_cpu(mask));
         vector = irq_to_vector(irq);
 
@@ -179,7 +179,7 @@ msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_msg *msg)
         unsigned dest;
         cpumask_t mask;
 
-        cpumask_and(&mask, &(irq_to_domain(irq)), cpu_online_mask);
+        cpus_and(mask, irq_to_domain(irq), cpu_online_map);
         dest = cpu_physical_id(first_cpu(mask));
 
         msg->address_hi = 0;
diff --git a/arch/ia64/kernel/paravirt.c b/arch/ia64/kernel/paravirt.c
index 1b22f6de293..100868216c5 100644
--- a/arch/ia64/kernel/paravirt.c
+++ b/arch/ia64/kernel/paravirt.c
@@ -634,8 +634,8 @@ struct pv_irq_ops pv_irq_ops = {
  * pv_time_ops
  * time operations
  */
-struct static_key paravirt_steal_enabled;
-struct static_key paravirt_steal_rq_enabled;
+struct jump_label_key paravirt_steal_enabled;
+struct jump_label_key paravirt_steal_rq_enabled;
 
 static int
 ia64_native_do_steal_accounting(unsigned long *new_itm)
diff --git a/arch/ia64/kernel/patch.c b/arch/ia64/kernel/patch.c
index 1cf09179371..68a1311db80 100644
--- a/arch/ia64/kernel/patch.c
+++ b/arch/ia64/kernel/patch.c
@@ -11,6 +11,7 @@
 #include <asm/patch.h>
 #include <asm/processor.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 #include <asm/unistd.h>
 
 /*
diff --git a/arch/ia64/kernel/pci-dma.c b/arch/ia64/kernel/pci-dma.c
index 1ddcfe5ef35..eb117572005 100644
--- a/arch/ia64/kernel/pci-dma.c
+++ b/arch/ia64/kernel/pci-dma.c
@@ -12,6 +12,7 @@
 #include <asm/machvec.h>
 #include <linux/dma-mapping.h>
 
+#include <asm/system.h>
 
 #ifdef CONFIG_INTEL_IOMMU
 
@@ -32,6 +33,7 @@ int force_iommu __read_mostly;
 #endif
 
 int iommu_pass_through;
+int iommu_group_mf;
 
 /* Dummy device used for NULL arguments (normally ISA). Better would
    be probably a smaller DMA mask, but this is bug-to-bug compatible
diff --git a/arch/ia64/kernel/pci-swiotlb.c b/arch/ia64/kernel/pci-swiotlb.c
index 939260aeac9..d9485d952ed 100644
--- a/arch/ia64/kernel/pci-swiotlb.c
+++ b/arch/ia64/kernel/pci-swiotlb.c
@@ -15,24 +15,16 @@ int swiotlb __read_mostly;
 EXPORT_SYMBOL(swiotlb);
 
 static void *ia64_swiotlb_alloc_coherent(struct device *dev, size_t size,
-                                         dma_addr_t *dma_handle, gfp_t gfp,
-                                         struct dma_attrs *attrs)
+                                         dma_addr_t *dma_handle, gfp_t gfp)
 {
         if (dev->coherent_dma_mask != DMA_BIT_MASK(64))
                 gfp |= GFP_DMA;
         return swiotlb_alloc_coherent(dev, size, dma_handle, gfp);
 }
 
-static void ia64_swiotlb_free_coherent(struct device *dev, size_t size,
-                                       void *vaddr, dma_addr_t dma_addr,
-                                       struct dma_attrs *attrs)
-{
-        swiotlb_free_coherent(dev, size, vaddr, dma_addr);
-}
-
 struct dma_map_ops swiotlb_dma_ops = {
-        .alloc = ia64_swiotlb_alloc_coherent,
-        .free = ia64_swiotlb_free_coherent,
+        .alloc_coherent = ia64_swiotlb_alloc_coherent,
+        .free_coherent = swiotlb_free_coherent,
         .map_page = swiotlb_map_page,
         .unmap_page = swiotlb_unmap_page,
         .map_sg = swiotlb_map_sg_attrs,
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index ea39eba61ef..89accc626b8 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -49,6 +49,7 @@
 #include <asm/perfmon.h>
 #include <asm/processor.h>
 #include <asm/signal.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/delay.h>
 
@@ -604,6 +605,18 @@ pfm_unprotect_ctx_ctxsw(pfm_context_t *x, unsigned long f)
         spin_unlock(&(x)->ctx_lock);
 }
 
+static inline unsigned int
+pfm_do_munmap(struct mm_struct *mm, unsigned long addr, size_t len, int acct)
+{
+        return do_munmap(mm, addr, len);
+}
+
+static inline unsigned long 
+pfm_get_unmapped_area(struct file *file, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags, unsigned long exec)
+{
+        return get_unmapped_area(file, addr, len, pgoff, flags);
+}
+
 /* forward declaration */
 static const struct dentry_operations pfmfs_dentry_operations;
 
@@ -1446,9 +1459,8 @@ pfm_unreserve_session(pfm_context_t *ctx, int is_syswide, unsigned int cpu)
  * a PROTECT_CTX() section.
  */
 static int
-pfm_remove_smpl_mapping(void *vaddr, unsigned long size)
+pfm_remove_smpl_mapping(struct task_struct *task, void *vaddr, unsigned long size)
 {
-        struct task_struct *task = current;
         int r;
 
         /* sanity checks */
@@ -1462,8 +1474,13 @@ pfm_remove_smpl_mapping(void *vaddr, unsigned long size)
         /*
          * does the actual unmapping
          */
-        r = vm_munmap((unsigned long)vaddr, size);
+        down_write(&task->mm->mmap_sem);
+
+        DPRINT(("down_write done smpl_vaddr=%p size=%lu\n", vaddr, size));
+
+        r = pfm_do_munmap(task->mm, (unsigned long)vaddr, size, 0);
 
+        up_write(&task->mm->mmap_sem);
         if (r !=0) {
                 printk(KERN_ERR "perfmon: [%d] unable to unmap sampling buffer @%p size=%lu\n", task_pid_nr(task), vaddr, size);
         }
@@ -1929,7 +1946,7 @@ pfm_flush(struct file *filp, fl_owner_t id)
          * because some VM function reenables interrupts.
          *
          */
-        if (smpl_buf_vaddr) pfm_remove_smpl_mapping(smpl_buf_vaddr, smpl_buf_size);
+        if (smpl_buf_vaddr) pfm_remove_smpl_mapping(current, smpl_buf_vaddr, smpl_buf_size);
 
         return 0;
 }
@@ -2211,7 +2228,7 @@ pfm_alloc_file(pfm_context_t *ctx)
         /*
          * allocate a new dcache entry
          */
-        path.dentry = d_alloc(pfmfs_mnt->mnt_root, &this);
+        path.dentry = d_alloc(pfmfs_mnt->mnt_sb->s_root, &this);
         if (!path.dentry) {
                 iput(inode);
                 return ERR_PTR(-ENOMEM);
@@ -2306,8 +2323,8 @@ pfm_smpl_buffer_alloc(struct task_struct *task, struct file *filp, pfm_context_t
          * partially initialize the vma for the sampling buffer
          */
         vma->vm_mm           = mm;
-        vma->vm_file         = get_file(filp);
-        vma->vm_flags        = VM_READ|VM_MAYREAD|VM_DONTEXPAND|VM_DONTDUMP;
+        vma->vm_file         = filp;
+        vma->vm_flags        = VM_READ| VM_MAYREAD |VM_RESERVED;
         vma->vm_page_prot    = PAGE_READONLY; /* XXX may need to change */
 
         /*
@@ -2327,8 +2344,8 @@ pfm_smpl_buffer_alloc(struct task_struct *task, struct file *filp, pfm_context_t
         down_write(&task->mm->mmap_sem);
 
         /* find some free area in address space, must have mmap sem held */
-        vma->vm_start = get_unmapped_area(NULL, 0, size, 0, MAP_PRIVATE|MAP_ANONYMOUS);
-        if (IS_ERR_VALUE(vma->vm_start)) {
+        vma->vm_start = pfm_get_unmapped_area(NULL, 0, size, 0, MAP_PRIVATE|MAP_ANONYMOUS, 0);
+        if (vma->vm_start == 0UL) {
                 DPRINT(("Cannot find unmapped area for size %ld\n", size));
                 up_write(&task->mm->mmap_sem);
                 goto error;
@@ -2345,12 +2362,15 @@ pfm_smpl_buffer_alloc(struct task_struct *task, struct file *filp, pfm_context_t
                 goto error;
         }
 
+        get_file(filp);
+
         /*
          * now insert the vma in the vm list for the process, must be
          * done with mmap lock held
          */
         insert_vm_struct(mm, vma);
 
+        mm->total_vm  += size >> PAGE_SHIFT;
         vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
                                                         vma_pages(vma));
         up_write(&task->mm->mmap_sem);
@@ -2378,8 +2398,8 @@ static int
 pfm_bad_permissions(struct task_struct *task)
 {
         const struct cred *tcred;
-        kuid_t uid = current_uid();
-        kgid_t gid = current_gid();
+        uid_t uid = current_uid();
+        gid_t gid = current_gid();
         int ret;
 
         rcu_read_lock();
@@ -2387,20 +2407,20 @@ pfm_bad_permissions(struct task_struct *task)
 
         /* inspired by ptrace_attach() */
         DPRINT(("cur: uid=%d gid=%d task: euid=%d suid=%d uid=%d egid=%d sgid=%d\n",
-                from_kuid(&init_user_ns, uid),
-                from_kgid(&init_user_ns, gid),
-                from_kuid(&init_user_ns, tcred->euid),
-                from_kuid(&init_user_ns, tcred->suid),
-                from_kuid(&init_user_ns, tcred->uid),
-                from_kgid(&init_user_ns, tcred->egid),
-                from_kgid(&init_user_ns, tcred->sgid)));
-
-        ret = ((!uid_eq(uid, tcred->euid))
-               || (!uid_eq(uid, tcred->suid))
-               || (!uid_eq(uid, tcred->uid))
-               || (!gid_eq(gid, tcred->egid))
-               || (!gid_eq(gid, tcred->sgid))
-               || (!gid_eq(gid, tcred->gid))) && !capable(CAP_SYS_PTRACE);
+                uid,
+                gid,
+                tcred->euid,
+                tcred->suid,
+                tcred->uid,
+                tcred->egid,
+                tcred->sgid));
+
+        ret = ((uid != tcred->euid)
+               || (uid != tcred->suid)
+               || (uid != tcred->uid)
+               || (gid != tcred->egid)
+               || (gid != tcred->sgid)
+               || (gid != tcred->gid)) && !capable(CAP_SYS_PTRACE);
 
         rcu_read_unlock();
         return ret;
@@ -4780,7 +4800,7 @@ recheck:
 asmlinkage long
 sys_perfmonctl (int fd, int cmd, void __user *arg, int count)
 {
-        struct fd f = {NULL, 0};
+        struct file *file = NULL;
         pfm_context_t *ctx = NULL;
         unsigned long flags = 0UL;
         void *args_k = NULL;
@@ -4877,17 +4897,17 @@ restart_args:
 
         ret = -EBADF;
 
-        f = fdget(fd);
-        if (unlikely(f.file == NULL)) {
+        file = fget(fd);
+        if (unlikely(file == NULL)) {
                 DPRINT(("invalid fd %d\n", fd));
                 goto error_args;
         }
-        if (unlikely(PFM_IS_FILE(f.file) == 0)) {
+        if (unlikely(PFM_IS_FILE(file) == 0)) {
                 DPRINT(("fd %d not related to perfmon\n", fd));
                 goto error_args;
         }
 
-        ctx = f.file->private_data;
+        ctx = file->private_data;
         if (unlikely(ctx == NULL)) {
                 DPRINT(("no context for fd %d\n", fd));
                 goto error_args;
@@ -4917,8 +4937,8 @@ abort_locked:
         if (call_made && PFM_CMD_RW_ARG(cmd) && copy_to_user(arg, args_k, base_sz*count)) ret = -EFAULT;
 
 error_args:
-        if (f.file)
-                fdput(f);
+        if (file)
+                fput(file);
 
         kfree(args_k);
 
diff --git a/arch/ia64/kernel/process.c b/arch/ia64/kernel/process.c
index 31360cbbd5f..6d33c5cc94f 100644
--- a/arch/ia64/kernel/process.c
+++ b/arch/ia64/kernel/process.c
@@ -29,7 +29,6 @@
 #include <linux/kdebug.h>
 #include <linux/utsname.h>
 #include <linux/tracehook.h>
-#include <linux/rcupdate.h>
 
 #include <asm/cpu.h>
 #include <asm/delay.h>
@@ -39,7 +38,6 @@
 #include <asm/pgalloc.h>
 #include <asm/processor.h>
 #include <asm/sal.h>
-#include <asm/switch_to.h>
 #include <asm/tlbflush.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
@@ -197,9 +195,11 @@ do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
                 ia64_do_signal(scr, in_syscall);
         }
 
-        if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME)) {
-                local_irq_enable();     /* force interrupt enable */
+        if (test_thread_flag(TIF_NOTIFY_RESUME)) {
+                clear_thread_flag(TIF_NOTIFY_RESUME);
                 tracehook_notify_resume(&scr->pt);
+                if (current->replacement_session_keyring)
+                        key_replace_session_keyring();
         }
 
         /* copy user rbs to kernel rbs */
@@ -272,6 +272,26 @@ static inline void play_dead(void)
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 
+static void do_nothing(void *unused)
+{
+}
+
+/*
+ * cpu_idle_wait - Used to ensure that all the CPUs discard old value of
+ * pm_idle and update to new pm_idle value. Required while changing pm_idle
+ * handler on SMP systems.
+ *
+ * Caller must have changed pm_idle to the new value before the call. Old
+ * pm_idle value will not be used by any CPU after the return of this function.
+ */
+void cpu_idle_wait(void)
+{
+        smp_mb();
+        /* kick all the CPUs so that they exit out of pm_idle */
+        smp_call_function(do_nothing, NULL, 1);
+}
+EXPORT_SYMBOL_GPL(cpu_idle_wait);
+
 void __attribute__((noreturn))
 cpu_idle (void)
 {
@@ -280,7 +300,6 @@ cpu_idle (void)
 
         /* endless idle loop with no priority at all */
         while (1) {
-                rcu_idle_enter();
                 if (can_do_pal_halt) {
                         current_thread_info()->status &= ~TS_POLLING;
                         /*
@@ -311,8 +330,9 @@ cpu_idle (void)
                         normal_xtp();
 #endif
                 }
-                rcu_idle_exit();
-                schedule_preempt_disabled();
+                preempt_enable_no_resched();
+                schedule();
+                preempt_disable();
                 check_pgt_cache();
                 if (cpu_is_offline(cpu))
                         play_dead();
@@ -393,24 +413,72 @@ ia64_load_extra (struct task_struct *task)
 int
 copy_thread(unsigned long clone_flags,
              unsigned long user_stack_base, unsigned long user_stack_size,
-             struct task_struct *p)
+             struct task_struct *p, struct pt_regs *regs)
 {
         extern char ia64_ret_from_clone;
         struct switch_stack *child_stack, *stack;
         unsigned long rbs, child_rbs, rbs_size;
         struct pt_regs *child_ptregs;
-        struct pt_regs *regs = current_pt_regs();
         int retval = 0;
 
+#ifdef CONFIG_SMP
+        /*
+         * For SMP idle threads, fork_by_hand() calls do_fork with
+         * NULL regs.
+         */
+        if (!regs)
+                return 0;
+#endif
+
+        stack = ((struct switch_stack *) regs) - 1;
+
         child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
         child_stack = (struct switch_stack *) child_ptregs - 1;
 
+        /* copy parent's switch_stack & pt_regs to child: */
+        memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
+
         rbs = (unsigned long) current + IA64_RBS_OFFSET;
         child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
+        rbs_size = stack->ar_bspstore - rbs;
+
+        /* copy the parent's register backing store to the child: */
+        memcpy((void *) child_rbs, (void *) rbs, rbs_size);
+
+        if (likely(user_mode(child_ptregs))) {
+                if (clone_flags & CLONE_SETTLS)
+                        child_ptregs->r13 = regs->r16;  /* see sys_clone2() in entry.S */
+                if (user_stack_base) {
+                        child_ptregs->r12 = user_stack_base + user_stack_size - 16;
+                        child_ptregs->ar_bspstore = user_stack_base;
+                        child_ptregs->ar_rnat = 0;
+                        child_ptregs->loadrs = 0;
+                }
+        } else {
+                /*
+                 * Note: we simply preserve the relative position of
+                 * the stack pointer here.  There is no need to
+                 * allocate a scratch area here, since that will have
+                 * been taken care of by the caller of sys_clone()
+                 * already.
+                 */
+                child_ptregs->r12 = (unsigned long) child_ptregs - 16; /* kernel sp */
+                child_ptregs->r13 = (unsigned long) p;          /* set `current' pointer */
+        }
+        child_stack->ar_bspstore = child_rbs + rbs_size;
+        child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
 
         /* copy parts of thread_struct: */
         p->thread.ksp = (unsigned long) child_stack - 16;
 
+        /* stop some PSR bits from being inherited.
+         * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
+         * therefore we must specify them explicitly here and not include them in
+         * IA64_PSR_BITS_TO_CLEAR.
+         */
+        child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
+                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
+
         /*
          * NOTE: The calling convention considers all floating point
          * registers in the high partition (fph) to be scratch.  Since
@@ -432,66 +500,8 @@ copy_thread(unsigned long clone_flags,
 #       define THREAD_FLAGS_TO_SET      0
         p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
                            | THREAD_FLAGS_TO_SET);
-
         ia64_drop_fpu(p);       /* don't pick up stale state from a CPU's fph */
 
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                if (unlikely(!user_stack_base)) {
-                        /* fork_idle() called us */
-                        return 0;
-                }
-                memset(child_stack, 0, sizeof(*child_ptregs) + sizeof(*child_stack));
-                child_stack->r4 = user_stack_base;      /* payload */
-                child_stack->r5 = user_stack_size;      /* argument */
-                /*
-                 * Preserve PSR bits, except for bits 32-34 and 37-45,
-                 * which we can't read.
-                 */
-                child_ptregs->cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
-                /* mark as valid, empty frame */
-                child_ptregs->cr_ifs = 1UL << 63;
-                child_stack->ar_fpsr = child_ptregs->ar_fpsr
-                        = ia64_getreg(_IA64_REG_AR_FPSR);
-                child_stack->pr = (1 << PRED_KERNEL_STACK);
-                child_stack->ar_bspstore = child_rbs;
-                child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
-
-                /* stop some PSR bits from being inherited.
-                 * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
-                 * therefore we must specify them explicitly here and not include them in
-                 * IA64_PSR_BITS_TO_CLEAR.
-                 */
-                child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
-                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
-
-                return 0;
-        }
-        stack = ((struct switch_stack *) regs) - 1;
-        /* copy parent's switch_stack & pt_regs to child: */
-        memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
-
-        /* copy the parent's register backing store to the child: */
-        rbs_size = stack->ar_bspstore - rbs;
-        memcpy((void *) child_rbs, (void *) rbs, rbs_size);
-        if (clone_flags & CLONE_SETTLS)
-                child_ptregs->r13 = regs->r16;  /* see sys_clone2() in entry.S */
-        if (user_stack_base) {
-                child_ptregs->r12 = user_stack_base + user_stack_size - 16;
-                child_ptregs->ar_bspstore = user_stack_base;
-                child_ptregs->ar_rnat = 0;
-                child_ptregs->loadrs = 0;
-        }
-        child_stack->ar_bspstore = child_rbs + rbs_size;
-        child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
-
-        /* stop some PSR bits from being inherited.
-         * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
-         * therefore we must specify them explicitly here and not include them in
-         * IA64_PSR_BITS_TO_CLEAR.
-         */
-        child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
-                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
-
 #ifdef CONFIG_PERFMON
         if (current->thread.pfm_context)
                 pfm_inherit(p, child_ptregs);
@@ -618,6 +628,57 @@ dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
         return 1;       /* f0-f31 are always valid so we always return 1 */
 }
 
+long
+sys_execve (const char __user *filename,
+            const char __user *const __user *argv,
+            const char __user *const __user *envp,
+            struct pt_regs *regs)
+{
+        char *fname;
+        int error;
+
+        fname = getname(filename);
+        error = PTR_ERR(fname);
+        if (IS_ERR(fname))
+                goto out;
+        error = do_execve(fname, argv, envp, regs);
+        putname(fname);
+out:
+        return error;
+}
+
+pid_t
+kernel_thread (int (*fn)(void *), void *arg, unsigned long flags)
+{
+        extern void start_kernel_thread (void);
+        unsigned long *helper_fptr = (unsigned long *) &start_kernel_thread;
+        struct {
+                struct switch_stack sw;
+                struct pt_regs pt;
+        } regs;
+
+        memset(&regs, 0, sizeof(regs));
+        regs.pt.cr_iip = helper_fptr[0];        /* set entry point (IP) */
+        regs.pt.r1 = helper_fptr[1];            /* set GP */
+        regs.pt.r9 = (unsigned long) fn;        /* 1st argument */
+        regs.pt.r11 = (unsigned long) arg;      /* 2nd argument */
+        /* Preserve PSR bits, except for bits 32-34 and 37-45, which we can't read.  */
+        regs.pt.cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
+        regs.pt.cr_ifs = 1UL << 63;             /* mark as valid, empty frame */
+        regs.sw.ar_fpsr = regs.pt.ar_fpsr = ia64_getreg(_IA64_REG_AR_FPSR);
+        regs.sw.ar_bspstore = (unsigned long) current + IA64_RBS_OFFSET;
+        regs.sw.pr = (1 << PRED_KERNEL_STACK);
+        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs.pt, 0, NULL, NULL);
+}
+EXPORT_SYMBOL(kernel_thread);
+
+/* This gets called from kernel_thread() via ia64_invoke_thread_helper().  */
+int
+kernel_thread_helper (int (*fn)(void *), void *arg)
+{
+        return (*fn)(arg);
+}
+
 /*
  * Flush thread state.  This is called when a thread does an execve().
  */
diff --git a/arch/ia64/kernel/ptrace.c b/arch/ia64/kernel/ptrace.c
index 4265ff64219..8848f43d819 100644
--- a/arch/ia64/kernel/ptrace.c
+++ b/arch/ia64/kernel/ptrace.c
@@ -26,6 +26,7 @@
 #include <asm/processor.h>
 #include <asm/ptrace_offsets.h>
 #include <asm/rse.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
 #ifdef CONFIG_PERFMON
@@ -1245,8 +1246,15 @@ syscall_trace_enter (long arg0, long arg1, long arg2, long arg3,
         if (test_thread_flag(TIF_RESTORE_RSE))
                 ia64_sync_krbs();
 
+        if (unlikely(current->audit_context)) {
+                long syscall;
+                int arch;
 
-        audit_syscall_entry(AUDIT_ARCH_IA64, regs.r15, arg0, arg1, arg2, arg3);
+                syscall = regs.r15;
+                arch = AUDIT_ARCH_IA64;
+
+                audit_syscall_entry(arch, syscall, arg0, arg1, arg2, arg3);
+        }
 
         return 0;
 }
@@ -1260,7 +1268,14 @@ syscall_trace_leave (long arg0, long arg1, long arg2, long arg3,
 {
         int step;
 
-        audit_syscall_exit(&regs);
+        if (unlikely(current->audit_context)) {
+                int success = AUDITSC_RESULT(regs.r10);
+                long result = regs.r8;
+
+                if (success != AUDITSC_SUCCESS)
+                        result = -result;
+                audit_syscall_exit(success, result);
+        }
 
         step = test_thread_flag(TIF_SINGLESTEP);
         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
index aaefd9b94f2..5e2c72498c5 100644
--- a/arch/ia64/kernel/setup.c
+++ b/arch/ia64/kernel/setup.c
@@ -59,6 +59,7 @@
 #include <asm/sections.h>
 #include <asm/setup.h>
 #include <asm/smp.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/unistd.h>
 #include <asm/hpsim.h>
@@ -219,23 +220,6 @@ sort_regions (struct rsvd_region *rsvd_region, int max)
         }
 }
 
-/* merge overlaps */
-static int __init
-merge_regions (struct rsvd_region *rsvd_region, int max)
-{
-        int i;
-        for (i = 1; i < max; ++i) {
-                if (rsvd_region[i].start >= rsvd_region[i-1].end)
-                        continue;
-                if (rsvd_region[i].end > rsvd_region[i-1].end)
-                        rsvd_region[i-1].end = rsvd_region[i].end;
-                --max;
-                memmove(&rsvd_region[i], &rsvd_region[i+1],
-                        (max - i) * sizeof(struct rsvd_region));
-        }
-        return max;
-}
-
 /*
  * Request address space for all standard resources
  */
@@ -286,7 +270,6 @@ static void __init setup_crashkernel(unsigned long total, int *n)
         if (ret == 0 && size > 0) {
                 if (!base) {
                         sort_regions(rsvd_region, *n);
-                        *n = merge_regions(rsvd_region, *n);
                         base = kdump_find_rsvd_region(size,
                                         rsvd_region, *n);
                 }
@@ -390,7 +373,6 @@ reserve_memory (void)
         BUG_ON(IA64_MAX_RSVD_REGIONS + 1 < n);
 
         sort_regions(rsvd_region, num_rsvd_regions);
-        num_rsvd_regions = merge_regions(rsvd_region, num_rsvd_regions);
 }
 
 
@@ -485,7 +467,7 @@ mark_bsp_online (void)
 {
 #ifdef CONFIG_SMP
         /* If we register an early console, allow CPU 0 to printk */
-        set_cpu_online(smp_processor_id(), true);
+        cpu_set(smp_processor_id(), cpu_online_map);
 #endif
 }
 
diff --git a/arch/ia64/kernel/signal.c b/arch/ia64/kernel/signal.c
index 680b73786be..7bdafc8788b 100644
--- a/arch/ia64/kernel/signal.c
+++ b/arch/ia64/kernel/signal.c
@@ -30,6 +30,7 @@
 
 #define DEBUG_SIG       0
 #define STACK_ALIGN     16              /* minimal alignment for stack pointer */
+#define _BLOCKABLE      (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
 #if _NSIG_WORDS > 1
 # define PUT_SIGSET(k,u)        __copy_to_user((u)->sig, (k)->sig, sizeof(sigset_t))
@@ -199,7 +200,14 @@ ia64_rt_sigreturn (struct sigscratch *scr)
         if (GET_SIGSET(&set, &sc->sc_mask))
                 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);
 
         if (restore_sigcontext(sc, scr))
                 goto give_sigsegv;
@@ -220,7 +228,7 @@ ia64_rt_sigreturn (struct sigscratch *scr)
         si.si_errno = 0;
         si.si_code = SI_KERNEL;
         si.si_pid = task_pid_vnr(current);
-        si.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+        si.si_uid = current_uid();
         si.si_addr = sc;
         force_sig_info(SIGSEGV, &si, current);
         return retval;
@@ -317,7 +325,7 @@ force_sigsegv_info (int sig, void __user *addr)
         si.si_errno = 0;
         si.si_code = SI_KERNEL;
         si.si_pid = task_pid_vnr(current);
-        si.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+        si.si_uid = current_uid();
         si.si_addr = addr;
         force_sig_info(SIGSEGV, &si, current);
         return 0;
@@ -413,13 +421,23 @@ setup_frame (int sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *set,
 }
 
 static long
-handle_signal (unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+handle_signal (unsigned long sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *oldset,
                struct sigscratch *scr)
 {
-        if (!setup_frame(sig, ka, info, sigmask_to_save(), scr))
+        if (!setup_frame(sig, ka, info, oldset, scr))
                 return 0;
 
-        signal_delivered(sig, info, ka, &scr->pt,
+        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);
+
+        /*
+         * Let tracing know that we've done the handler setup.
+         */
+        tracehook_signal_handler(sig, info, ka, &scr->pt,
                                  test_thread_flag(TIF_SINGLESTEP));
 
         return 1;
@@ -433,11 +451,25 @@ void
 ia64_do_signal (struct sigscratch *scr, long in_syscall)
 {
         struct k_sigaction ka;
+        sigset_t *oldset;
         siginfo_t info;
         long restart = in_syscall;
         long errno = scr->pt.r8;
 
         /*
+         * In the ia64_leave_kernel code path, we want the common case to go fast, which
+         * is why we may in certain cases get here from kernel mode. Just return without
+         * doing anything if so.
+         */
+        if (!user_mode(&scr->pt))
+                return;
+
+        if (current_thread_info()->status & TS_RESTORE_SIGMASK)
+                oldset = &current->saved_sigmask;
+        else
+                oldset = &current->blocked;
+
+        /*
          * This only loops in the rare cases of handle_signal() failing, in which case we
          * need to push through a forced SIGSEGV.
          */
@@ -486,8 +518,16 @@ ia64_do_signal (struct sigscratch *scr, long in_syscall)
                  * 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, &ka, &info, scr))
+                if (handle_signal(signr, &ka, &info, oldset, scr)) {
+                        /*
+                         * 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 TS_RESTORE_SIGMASK flag.
+                         */
+                        current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
                         return;
+                }
         }
 
         /* Did we come from a system call? */
@@ -509,5 +549,8 @@ ia64_do_signal (struct sigscratch *scr, long in_syscall)
 
         /* if there's no signal to deliver, we just put the saved sigmask
          * back */
-        restore_saved_sigmask();
+        if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
+                current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
diff --git a/arch/ia64/kernel/smp.c b/arch/ia64/kernel/smp.c
index 9fcd4e63048..0bd537b4ea6 100644
--- a/arch/ia64/kernel/smp.c
+++ b/arch/ia64/kernel/smp.c
@@ -44,6 +44,7 @@
 #include <asm/processor.h>
 #include <asm/ptrace.h>
 #include <asm/sal.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/unistd.h>
 #include <asm/mca.h>
@@ -76,7 +77,7 @@ stop_this_cpu(void)
         /*
          * Remove this CPU:
          */
-        set_cpu_online(smp_processor_id(), false);
+        cpu_clear(smp_processor_id(), cpu_online_map);
         max_xtp();
         local_irq_disable();
         cpu_halt();
diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
index 500f1e4d9f9..55909798667 100644
--- a/arch/ia64/kernel/smpboot.c
+++ b/arch/ia64/kernel/smpboot.c
@@ -55,6 +55,7 @@
 #include <asm/processor.h>
 #include <asm/ptrace.h>
 #include <asm/sal.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/unistd.h>
 #include <asm/sn/arch.h>
@@ -75,6 +76,13 @@
 #endif
 
 /*
+ * Store all idle threads, this can be reused instead of creating
+ * a new thread. Also avoids complicated thread destroy functionality
+ * for idle threads.
+ */
+struct task_struct *idle_thread_array[NR_CPUS];
+
+/*
  * Global array allocated for NR_CPUS at boot time
  */
 struct sal_to_os_boot sal_boot_rendez_state[NR_CPUS];
@@ -87,7 +95,13 @@ struct sal_to_os_boot *sal_state_for_booting_cpu = &sal_boot_rendez_state[0];
 
 #define set_brendez_area(x) (sal_state_for_booting_cpu = &sal_boot_rendez_state[(x)]);
 
+#define get_idle_for_cpu(x)             (idle_thread_array[(x)])
+#define set_idle_for_cpu(x,p)   (idle_thread_array[(x)] = (p))
+
 #else
+
+#define get_idle_for_cpu(x)             (NULL)
+#define set_idle_for_cpu(x,p)
 #define set_brendez_area(x)
 #endif
 
@@ -347,7 +361,8 @@ ia64_sync_itc (unsigned int master)
 /*
  * Ideally sets up per-cpu profiling hooks.  Doesn't do much now...
  */
-static inline void smp_setup_percpu_timer(void)
+static inline void __devinit
+smp_setup_percpu_timer (void)
 {
 }
 
@@ -381,13 +396,15 @@ smp_callin (void)
         set_numa_node(cpu_to_node_map[cpuid]);
         set_numa_mem(local_memory_node(cpu_to_node_map[cpuid]));
 
+        ipi_call_lock_irq();
         spin_lock(&vector_lock);
         /* Setup the per cpu irq handling data structures */
         __setup_vector_irq(cpuid);
         notify_cpu_starting(cpuid);
-        set_cpu_online(cpuid, true);
+        cpu_set(cpuid, cpu_online_map);
         per_cpu(cpu_state, cpuid) = CPU_ONLINE;
         spin_unlock(&vector_lock);
+        ipi_call_unlock_irq();
 
         smp_setup_percpu_timer();
 
@@ -459,12 +476,59 @@ start_secondary (void *unused)
         return 0;
 }
 
+struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
+{
+        return NULL;
+}
+
+struct create_idle {
+        struct work_struct work;
+        struct task_struct *idle;
+        struct completion done;
+        int cpu;
+};
+
+void __cpuinit
+do_fork_idle(struct work_struct *work)
+{
+        struct create_idle *c_idle =
+                container_of(work, struct create_idle, work);
+
+        c_idle->idle = fork_idle(c_idle->cpu);
+        complete(&c_idle->done);
+}
+
 static int __cpuinit
-do_boot_cpu (int sapicid, int cpu, struct task_struct *idle)
+do_boot_cpu (int sapicid, int cpu)
 {
         int timeout;
+        struct create_idle c_idle = {
+                .work = __WORK_INITIALIZER(c_idle.work, do_fork_idle),
+                .cpu    = cpu,
+                .done   = COMPLETION_INITIALIZER(c_idle.done),
+        };
+
+        /*
+         * We can't use kernel_thread since we must avoid to
+         * reschedule the child.
+         */
+        c_idle.idle = get_idle_for_cpu(cpu);
+        if (c_idle.idle) {
+                init_idle(c_idle.idle, cpu);
+                goto do_rest;
+        }
+
+        schedule_work(&c_idle.work);
+        wait_for_completion(&c_idle.done);
+
+        if (IS_ERR(c_idle.idle))
+                panic("failed fork for CPU %d", cpu);
+
+        set_idle_for_cpu(cpu, c_idle.idle);
+
+do_rest:
+        task_for_booting_cpu = c_idle.idle;
 
-        task_for_booting_cpu = idle;
         Dprintk("Sending wakeup vector %lu to AP 0x%x/0x%x.\n", ap_wakeup_vector, cpu, sapicid);
 
         set_brendez_area(cpu);
@@ -484,7 +548,7 @@ do_boot_cpu (int sapicid, int cpu, struct task_struct *idle)
         if (!cpu_isset(cpu, cpu_callin_map)) {
                 printk(KERN_ERR "Processor 0x%x/0x%x is stuck.\n", cpu, sapicid);
                 ia64_cpu_to_sapicid[cpu] = -1;
-                set_cpu_online(cpu, false);  /* was set in smp_callin() */
+                cpu_clear(cpu, cpu_online_map);  /* was set in smp_callin() */
                 return -EINVAL;
         }
         return 0;
@@ -514,7 +578,8 @@ smp_build_cpu_map (void)
         }
 
         ia64_cpu_to_sapicid[0] = boot_cpu_id;
-        init_cpu_present(cpumask_of(0));
+        cpus_clear(cpu_present_map);
+        set_cpu_present(0, true);
         set_cpu_possible(0, true);
         for (cpu = 1, i = 0; i < smp_boot_data.cpu_count; i++) {
                 sapicid = smp_boot_data.cpu_phys_id[i];
@@ -541,6 +606,10 @@ smp_prepare_cpus (unsigned int max_cpus)
 
         smp_setup_percpu_timer();
 
+        /*
+         * We have the boot CPU online for sure.
+         */
+        cpu_set(0, cpu_online_map);
         cpu_set(0, cpu_callin_map);
 
         local_cpu_data->loops_per_jiffy = loops_per_jiffy;
@@ -562,9 +631,9 @@ smp_prepare_cpus (unsigned int max_cpus)
         }
 }
 
-void smp_prepare_boot_cpu(void)
+void __devinit smp_prepare_boot_cpu(void)
 {
-        set_cpu_online(smp_processor_id(), true);
+        cpu_set(smp_processor_id(), cpu_online_map);
         cpu_set(smp_processor_id(), cpu_callin_map);
         set_numa_node(cpu_to_node_map[smp_processor_id()]);
         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
@@ -621,7 +690,7 @@ int migrate_platform_irqs(unsigned int cpu)
                         /*
                          * Now re-target the CPEI to a different processor
                          */
-                        new_cpei_cpu = cpumask_any(cpu_online_mask);
+                        new_cpei_cpu = any_online_cpu(cpu_online_map);
                         mask = cpumask_of(new_cpei_cpu);
                         set_cpei_target_cpu(new_cpei_cpu);
                         data = irq_get_irq_data(ia64_cpe_irq);
@@ -663,10 +732,10 @@ int __cpu_disable(void)
                         return -EBUSY;
         }
 
-        set_cpu_online(cpu, false);
+        cpu_clear(cpu, cpu_online_map);
 
         if (migrate_platform_irqs(cpu)) {
-                set_cpu_online(cpu, true);
+                cpu_set(cpu, cpu_online_map);
                 return -EBUSY;
         }
 
@@ -712,7 +781,8 @@ smp_cpus_done (unsigned int dummy)
                (int)num_online_cpus(), bogosum/(500000/HZ), (bogosum/(5000/HZ))%100);
 }
 
-static inline void set_cpu_sibling_map(int cpu)
+static inline void __devinit
+set_cpu_sibling_map(int cpu)
 {
         int i;
 
@@ -729,7 +799,7 @@ static inline void set_cpu_sibling_map(int cpu)
 }
 
 int __cpuinit
-__cpu_up(unsigned int cpu, struct task_struct *tidle)
+__cpu_up (unsigned int cpu)
 {
         int ret;
         int sapicid;
@@ -747,7 +817,7 @@ __cpu_up(unsigned int cpu, struct task_struct *tidle)
 
         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
         /* Processor goes to start_secondary(), sets online flag */
-        ret = do_boot_cpu(sapicid, cpu, tidle);
+        ret = do_boot_cpu(sapicid, cpu);
         if (ret < 0)
                 return ret;
 
@@ -791,7 +861,8 @@ init_smp_config(void)
  * identify_siblings(cpu) gets called from identify_cpu. This populates the 
  * information related to logical execution units in per_cpu_data structure.
  */
-void identify_siblings(struct cpuinfo_ia64 *c)
+void __devinit
+identify_siblings(struct cpuinfo_ia64 *c)
 {
         long status;
         u16 pltid;
diff --git a/arch/ia64/kernel/sys_ia64.c b/arch/ia64/kernel/sys_ia64.c
index d9439ef2f66..609d50056a6 100644
--- a/arch/ia64/kernel/sys_ia64.c
+++ b/arch/ia64/kernel/sys_ia64.c
@@ -171,9 +171,22 @@ asmlinkage unsigned long
 ia64_mremap (unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags,
              unsigned long new_addr)
 {
-        addr = sys_mremap(addr, old_len, new_len, flags, new_addr);
-        if (!IS_ERR((void *) addr))
-                force_successful_syscall_return();
+        extern unsigned long do_mremap (unsigned long addr,
+                                        unsigned long old_len,
+                                        unsigned long new_len,
+                                        unsigned long flags,
+                                        unsigned long new_addr);
+
+        down_write(&current->mm->mmap_sem);
+        {
+                addr = do_mremap(addr, old_len, new_len, flags, new_addr);
+        }
+        up_write(&current->mm->mmap_sem);
+
+        if (IS_ERR((void *) addr))
+                return addr;
+
+        force_successful_syscall_return();
         return addr;
 }
 
diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index 88a794536bc..43920de425f 100644
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -19,7 +19,7 @@
 #include <linux/interrupt.h>
 #include <linux/efi.h>
 #include <linux/timex.h>
-#include <linux/timekeeper_internal.h>
+#include <linux/clocksource.h>
 #include <linux/platform_device.h>
 
 #include <asm/machvec.h>
@@ -29,12 +29,15 @@
 #include <asm/ptrace.h>
 #include <asm/sal.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 
 #include "fsyscall_gtod_data.h"
 
 static cycle_t itc_get_cycles(struct clocksource *cs);
 
-struct fsyscall_gtod_data_t fsyscall_gtod_data;
+struct fsyscall_gtod_data_t fsyscall_gtod_data = {
+        .lock = __SEQLOCK_UNLOCKED(fsyscall_gtod_data.lock),
+};
 
 struct itc_jitter_data_t itc_jitter_data;
 
@@ -83,29 +86,32 @@ static struct clocksource *itc_clocksource;
 
 extern cputime_t cycle_to_cputime(u64 cyc);
 
-void vtime_account_user(struct task_struct *tsk)
-{
-        cputime_t delta_utime;
-        struct thread_info *ti = task_thread_info(tsk);
-
-        if (ti->ac_utime) {
-                delta_utime = cycle_to_cputime(ti->ac_utime);
-                account_user_time(tsk, delta_utime, delta_utime);
-                ti->ac_utime = 0;
-        }
-}
-
 /*
  * Called from the context switch with interrupts disabled, to charge all
  * accumulated times to the current process, and to prepare accounting on
  * the next process.
  */
-void arch_vtime_task_switch(struct task_struct *prev)
+void ia64_account_on_switch(struct task_struct *prev, struct task_struct *next)
 {
         struct thread_info *pi = task_thread_info(prev);
-        struct thread_info *ni = task_thread_info(current);
+        struct thread_info *ni = task_thread_info(next);
+        cputime_t delta_stime, delta_utime;
+        __u64 now;
+
+        now = ia64_get_itc();
+
+        delta_stime = cycle_to_cputime(pi->ac_stime + (now - pi->ac_stamp));
+        if (idle_task(smp_processor_id()) != prev)
+                account_system_time(prev, 0, delta_stime, delta_stime);
+        else
+                account_idle_time(delta_stime);
 
-        pi->ac_stamp = ni->ac_stamp;
+        if (pi->ac_utime) {
+                delta_utime = cycle_to_cputime(pi->ac_utime);
+                account_user_time(prev, delta_utime, delta_utime);
+        }
+
+        pi->ac_stamp = ni->ac_stamp = now;
         ni->ac_stime = ni->ac_utime = 0;
 }
 
@@ -113,33 +119,44 @@ void arch_vtime_task_switch(struct task_struct *prev)
  * Account time for a transition between system, hard irq or soft irq state.
  * Note that this function is called with interrupts enabled.
  */
-static cputime_t vtime_delta(struct task_struct *tsk)
+void account_system_vtime(struct task_struct *tsk)
 {
         struct thread_info *ti = task_thread_info(tsk);
+        unsigned long flags;
         cputime_t delta_stime;
         __u64 now;
 
-        WARN_ON_ONCE(!irqs_disabled());
+        local_irq_save(flags);
 
         now = ia64_get_itc();
 
         delta_stime = cycle_to_cputime(ti->ac_stime + (now - ti->ac_stamp));
+        if (irq_count() || idle_task(smp_processor_id()) != tsk)
+                account_system_time(tsk, 0, delta_stime, delta_stime);
+        else
+                account_idle_time(delta_stime);
         ti->ac_stime = 0;
+
         ti->ac_stamp = now;
 
-        return delta_stime;
+        local_irq_restore(flags);
 }
+EXPORT_SYMBOL_GPL(account_system_vtime);
 
-void vtime_account_system(struct task_struct *tsk)
+/*
+ * Called from the timer interrupt handler to charge accumulated user time
+ * to the current process.  Must be called with interrupts disabled.
+ */
+void account_process_tick(struct task_struct *p, int user_tick)
 {
-        cputime_t delta = vtime_delta(tsk);
-
-        account_system_time(tsk, 0, delta, delta);
-}
+        struct thread_info *ti = task_thread_info(p);
+        cputime_t delta_utime;
 
-void vtime_account_idle(struct task_struct *tsk)
-{
-        account_idle_time(vtime_delta(tsk));
+        if (ti->ac_utime) {
+                delta_utime = cycle_to_cputime(ti->ac_utime);
+                account_user_time(p, delta_utime, delta_utime);
+                ti->ac_utime = 0;
+        }
 }
 
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
@@ -243,7 +260,8 @@ static int __init nojitter_setup(char *str)
 __setup("nojitter", nojitter_setup);
 
 
-void ia64_init_itm(void)
+void __devinit
+ia64_init_itm (void)
 {
         unsigned long platform_base_freq, itc_freq;
         struct pal_freq_ratio itc_ratio, proc_ratio;
@@ -439,10 +457,12 @@ void update_vsyscall_tz(void)
 {
 }
 
-void update_vsyscall_old(struct timespec *wall, struct timespec *wtm,
+void update_vsyscall(struct timespec *wall, struct timespec *wtm,
                         struct clocksource *c, u32 mult)
 {
-        write_seqcount_begin(&fsyscall_gtod_data.seq);
+        unsigned long flags;
+
+        write_seqlock_irqsave(&fsyscall_gtod_data.lock, flags);
 
         /* copy fsyscall clock data */
         fsyscall_gtod_data.clk_mask = c->mask;
@@ -465,6 +485,6 @@ void update_vsyscall_old(struct timespec *wall, struct timespec *wtm,
                 fsyscall_gtod_data.monotonic_time.tv_sec++;
         }
 
-        write_seqcount_end(&fsyscall_gtod_data.seq);
+        write_sequnlock_irqrestore(&fsyscall_gtod_data.lock, flags);
 }
 
diff --git a/arch/ia64/kernel/topology.c b/arch/ia64/kernel/topology.c
index dc00b2c1b42..0e0e0cc9e39 100644
--- a/arch/ia64/kernel/topology.c
+++ b/arch/ia64/kernel/topology.c
@@ -22,7 +22,6 @@
 #include <linux/bootmem.h>
 #include <linux/nodemask.h>
 #include <linux/notifier.h>
-#include <linux/export.h>
 #include <asm/mmzone.h>
 #include <asm/numa.h>
 #include <asm/cpu.h>
@@ -220,8 +219,7 @@ static ssize_t show_shared_cpu_map(struct cache_info *this_leaf, char *buf)
         ssize_t len;
         cpumask_t shared_cpu_map;
 
-        cpumask_and(&shared_cpu_map,
-                                &this_leaf->shared_cpu_map, cpu_online_mask);
+        cpus_and(shared_cpu_map, this_leaf->shared_cpu_map, cpu_online_map);
         len = cpumask_scnprintf(buf, NR_CPUS+1, &shared_cpu_map);
         len += sprintf(buf+len, "\n");
         return len;
@@ -275,7 +273,7 @@ static struct attribute * cache_default_attrs[] = {
 #define to_object(k) container_of(k, struct cache_info, kobj)
 #define to_attr(a) container_of(a, struct cache_attr, attr)
 
-static ssize_t ia64_cache_show(struct kobject * kobj, struct attribute * attr, char * buf)
+static ssize_t cache_show(struct kobject * kobj, struct attribute * attr, char * buf)
 {
         struct cache_attr *fattr = to_attr(attr);
         struct cache_info *this_leaf = to_object(kobj);
@@ -286,7 +284,7 @@ static ssize_t ia64_cache_show(struct kobject * kobj, struct attribute * attr, c
 }
 
 static const struct sysfs_ops cache_sysfs_ops = {
-        .show   = ia64_cache_show
+        .show   = cache_show
 };
 
 static struct kobj_type cache_ktype = {
@@ -351,7 +349,7 @@ static int __cpuinit cpu_cache_sysfs_init(unsigned int cpu)
 }
 
 /* Add cache interface for CPU device */
-static int __cpuinit cache_add_dev(struct device * sys_dev)
+static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
 {
         unsigned int cpu = sys_dev->id;
         unsigned long i, j;
@@ -401,7 +399,7 @@ static int __cpuinit cache_add_dev(struct device * sys_dev)
 }
 
 /* Remove cache interface for CPU device */
-static int __cpuinit cache_remove_dev(struct device * sys_dev)
+static int __cpuinit cache_remove_dev(struct sys_device * sys_dev)
 {
         unsigned int cpu = sys_dev->id;
         unsigned long i;
@@ -429,9 +427,9 @@ static int __cpuinit cache_cpu_callback(struct notifier_block *nfb,
                 unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
-        struct device *sys_dev;
+        struct sys_device *sys_dev;
 
-        sys_dev = get_cpu_device(cpu);
+        sys_dev = get_cpu_sysdev(cpu);
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
@@ -455,7 +453,7 @@ static int __init cache_sysfs_init(void)
         int i;
 
         for_each_online_cpu(i) {
-                struct device *sys_dev = get_cpu_device((unsigned int)i);
+                struct sys_device *sys_dev = get_cpu_sysdev((unsigned int)i);
                 cache_add_dev(sys_dev);
         }
 
diff --git a/arch/ia64/kernel/traps.c b/arch/ia64/kernel/traps.c
index bd42b76000d..fd80e70018a 100644
--- a/arch/ia64/kernel/traps.c
+++ b/arch/ia64/kernel/traps.c
@@ -22,7 +22,6 @@
 #include <asm/intrinsics.h>
 #include <asm/processor.h>
 #include <asm/uaccess.h>
-#include <asm/setup.h>
 
 fpswa_interface_t *fpswa_interface;
 EXPORT_SYMBOL(fpswa_interface);
diff --git a/arch/ia64/kernel/uncached.c b/arch/ia64/kernel/uncached.c
index a96bcf83a73..6a867dc45c0 100644
--- a/arch/ia64/kernel/uncached.c
+++ b/arch/ia64/kernel/uncached.c
@@ -23,6 +23,7 @@
 #include <linux/gfp.h>
 #include <asm/page.h>
 #include <asm/pal.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 #include <linux/atomic.h>
 #include <asm/tlbflush.h>
diff --git a/arch/ia64/kernel/unwind.c b/arch/ia64/kernel/unwind.c
index 8f66195999e..fed6afa2e8a 100644
--- a/arch/ia64/kernel/unwind.c
+++ b/arch/ia64/kernel/unwind.c
@@ -41,6 +41,7 @@
 #include <asm/ptrace_offsets.h>
 #include <asm/rse.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 
 #include "entry.h"
diff --git a/arch/ia64/kernel/vmlinux.lds.S b/arch/ia64/kernel/vmlinux.lds.S
index 0ccb28fab27..53c0ba004e9 100644
--- a/arch/ia64/kernel/vmlinux.lds.S
+++ b/arch/ia64/kernel/vmlinux.lds.S
@@ -1,6 +1,7 @@
 
 #include <asm/cache.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 
 #include <asm-generic/vmlinux.lds.h>