Merge branch 'tip/perf/jump-label-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace into perf/urgent

14 files changed, 992 insertions, 65 deletions

diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 4ed076a4db24..36c30f31ec93 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -129,6 +129,8 @@ ifneq ($(CONFIG_XMON)$(CONFIG_KEXEC),)
 obj-y                           += ppc_save_regs.o
 endif
 
+obj-$(CONFIG_KVM_GUEST)         += kvm.o kvm_emul.o
+
 # Disable GCOV in odd or sensitive code
 GCOV_PROFILE_prom_init.o := n
 GCOV_PROFILE_ftrace.o := n
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index c3e01945ad4f..bd0df2e6aa8f 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -48,11 +48,11 @@
 #ifdef CONFIG_PPC_ISERIES
 #include <asm/iseries/alpaca.h>
 #endif
-#ifdef CONFIG_KVM
+#if defined(CONFIG_KVM) || defined(CONFIG_KVM_GUEST)
 #include <linux/kvm_host.h>
-#ifndef CONFIG_BOOKE
-#include <asm/kvm_book3s.h>
 #endif
+#if defined(CONFIG_KVM) && defined(CONFIG_PPC_BOOK3S)
+#include <asm/kvm_book3s.h>
 #endif
 
 #ifdef CONFIG_PPC32
@@ -396,12 +396,13 @@ int main(void)
         DEFINE(VCPU_HOST_STACK, offsetof(struct kvm_vcpu, arch.host_stack));
         DEFINE(VCPU_HOST_PID, offsetof(struct kvm_vcpu, arch.host_pid));
         DEFINE(VCPU_GPRS, offsetof(struct kvm_vcpu, arch.gpr));
-        DEFINE(VCPU_MSR, offsetof(struct kvm_vcpu, arch.msr));
         DEFINE(VCPU_SPRG4, offsetof(struct kvm_vcpu, arch.sprg4));
         DEFINE(VCPU_SPRG5, offsetof(struct kvm_vcpu, arch.sprg5));
         DEFINE(VCPU_SPRG6, offsetof(struct kvm_vcpu, arch.sprg6));
         DEFINE(VCPU_SPRG7, offsetof(struct kvm_vcpu, arch.sprg7));
         DEFINE(VCPU_SHADOW_PID, offsetof(struct kvm_vcpu, arch.shadow_pid));
+        DEFINE(VCPU_SHARED, offsetof(struct kvm_vcpu, arch.shared));
+        DEFINE(VCPU_SHARED_MSR, offsetof(struct kvm_vcpu_arch_shared, msr));
 
         /* book3s */
 #ifdef CONFIG_PPC_BOOK3S
@@ -466,6 +467,22 @@ int main(void)
         DEFINE(VCPU_FAULT_ESR, offsetof(struct kvm_vcpu, arch.fault_esr));
 #endif /* CONFIG_PPC_BOOK3S */
 #endif
+
+#ifdef CONFIG_KVM_GUEST
+        DEFINE(KVM_MAGIC_SCRATCH1, offsetof(struct kvm_vcpu_arch_shared,
+                                            scratch1));
+        DEFINE(KVM_MAGIC_SCRATCH2, offsetof(struct kvm_vcpu_arch_shared,
+                                            scratch2));
+        DEFINE(KVM_MAGIC_SCRATCH3, offsetof(struct kvm_vcpu_arch_shared,
+                                            scratch3));
+        DEFINE(KVM_MAGIC_INT, offsetof(struct kvm_vcpu_arch_shared,
+                                       int_pending));
+        DEFINE(KVM_MAGIC_MSR, offsetof(struct kvm_vcpu_arch_shared, msr));
+        DEFINE(KVM_MAGIC_CRITICAL, offsetof(struct kvm_vcpu_arch_shared,
+                                            critical));
+        DEFINE(KVM_MAGIC_SR, offsetof(struct kvm_vcpu_arch_shared, sr));
+#endif
+
 #ifdef CONFIG_44x
         DEFINE(PGD_T_LOG2, PGD_T_LOG2);
         DEFINE(PTE_T_LOG2, PTE_T_LOG2);
diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S
index 39b0c48872d2..9f8b01d6466f 100644
--- a/arch/powerpc/kernel/exceptions-64s.S
+++ b/arch/powerpc/kernel/exceptions-64s.S
@@ -299,6 +299,12 @@ slb_miss_user_pseries:
         b       .                               /* prevent spec. execution */
 #endif /* __DISABLED__ */
 
+/* KVM's trampoline code needs to be close to the interrupt handlers */
+
+#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
+#include "../kvm/book3s_rmhandlers.S"
+#endif
+
         .align  7
         .globl  __end_interrupts
 __end_interrupts:
diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S
index c571cd3c1453..f0dd577e4a5b 100644
--- a/arch/powerpc/kernel/head_64.S
+++ b/arch/powerpc/kernel/head_64.S
@@ -166,12 +166,6 @@ exception_marker:
 #include "exceptions-64s.S"
 #endif
 
-/* KVM trampoline code needs to be close to the interrupt handlers */
-
-#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
-#include "../kvm/book3s_rmhandlers.S"
-#endif
-
 _GLOBAL(generic_secondary_thread_init)
         mr      r24,r3
 
diff --git a/arch/powerpc/kernel/ibmebus.c b/arch/powerpc/kernel/ibmebus.c
index 9b626cfffce1..f62efdfd1769 100644
--- a/arch/powerpc/kernel/ibmebus.c
+++ b/arch/powerpc/kernel/ibmebus.c
@@ -162,13 +162,10 @@ static int ibmebus_create_device(struct device_node *dn)
         dev->dev.bus = &ibmebus_bus_type;
         dev->dev.archdata.dma_ops = &ibmebus_dma_ops;
 
-        ret = of_device_register(dev);
-        if (ret) {
-                of_device_free(dev);
-                return ret;
-        }
-
-        return 0;
+        ret = of_device_add(dev);
+        if (ret)
+                platform_device_put(dev);
+        return ret;
 }
 
 static int ibmebus_create_devices(const struct of_device_id *matches)
diff --git a/arch/powerpc/kernel/kvm.c b/arch/powerpc/kernel/kvm.c
new file mode 100644
index 000000000000..428d0e538aec
--- /dev/null
+++ b/arch/powerpc/kernel/kvm.c
@@ -0,0 +1,596 @@
+/*
+ * Copyright (C) 2010 SUSE Linux Products GmbH. All rights reserved.
+ *
+ * Authors:
+ *     Alexander Graf <agraf@suse.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <linux/kvm_host.h>
+#include <linux/init.h>
+#include <linux/kvm_para.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+
+#include <asm/reg.h>
+#include <asm/sections.h>
+#include <asm/cacheflush.h>
+#include <asm/disassemble.h>
+
+#define KVM_MAGIC_PAGE          (-4096L)
+#define magic_var(x) KVM_MAGIC_PAGE + offsetof(struct kvm_vcpu_arch_shared, x)
+
+#define KVM_INST_LWZ            0x80000000
+#define KVM_INST_STW            0x90000000
+#define KVM_INST_LD             0xe8000000
+#define KVM_INST_STD            0xf8000000
+#define KVM_INST_NOP            0x60000000
+#define KVM_INST_B              0x48000000
+#define KVM_INST_B_MASK         0x03ffffff
+#define KVM_INST_B_MAX          0x01ffffff
+
+#define KVM_MASK_RT             0x03e00000
+#define KVM_RT_30               0x03c00000
+#define KVM_MASK_RB             0x0000f800
+#define KVM_INST_MFMSR          0x7c0000a6
+#define KVM_INST_MFSPR_SPRG0    0x7c1042a6
+#define KVM_INST_MFSPR_SPRG1    0x7c1142a6
+#define KVM_INST_MFSPR_SPRG2    0x7c1242a6
+#define KVM_INST_MFSPR_SPRG3    0x7c1342a6
+#define KVM_INST_MFSPR_SRR0     0x7c1a02a6
+#define KVM_INST_MFSPR_SRR1     0x7c1b02a6
+#define KVM_INST_MFSPR_DAR      0x7c1302a6
+#define KVM_INST_MFSPR_DSISR    0x7c1202a6
+
+#define KVM_INST_MTSPR_SPRG0    0x7c1043a6
+#define KVM_INST_MTSPR_SPRG1    0x7c1143a6
+#define KVM_INST_MTSPR_SPRG2    0x7c1243a6
+#define KVM_INST_MTSPR_SPRG3    0x7c1343a6
+#define KVM_INST_MTSPR_SRR0     0x7c1a03a6
+#define KVM_INST_MTSPR_SRR1     0x7c1b03a6
+#define KVM_INST_MTSPR_DAR      0x7c1303a6
+#define KVM_INST_MTSPR_DSISR    0x7c1203a6
+
+#define KVM_INST_TLBSYNC        0x7c00046c
+#define KVM_INST_MTMSRD_L0      0x7c000164
+#define KVM_INST_MTMSRD_L1      0x7c010164
+#define KVM_INST_MTMSR          0x7c000124
+
+#define KVM_INST_WRTEEI_0       0x7c000146
+#define KVM_INST_WRTEEI_1       0x7c008146
+
+#define KVM_INST_MTSRIN         0x7c0001e4
+
+static bool kvm_patching_worked = true;
+static char kvm_tmp[1024 * 1024];
+static int kvm_tmp_index;
+
+static inline void kvm_patch_ins(u32 *inst, u32 new_inst)
+{
+        *inst = new_inst;
+        flush_icache_range((ulong)inst, (ulong)inst + 4);
+}
+
+static void kvm_patch_ins_ll(u32 *inst, long addr, u32 rt)
+{
+#ifdef CONFIG_64BIT
+        kvm_patch_ins(inst, KVM_INST_LD | rt | (addr & 0x0000fffc));
+#else
+        kvm_patch_ins(inst, KVM_INST_LWZ | rt | (addr & 0x0000fffc));
+#endif
+}
+
+static void kvm_patch_ins_ld(u32 *inst, long addr, u32 rt)
+{
+#ifdef CONFIG_64BIT
+        kvm_patch_ins(inst, KVM_INST_LD | rt | (addr & 0x0000fffc));
+#else
+        kvm_patch_ins(inst, KVM_INST_LWZ | rt | ((addr + 4) & 0x0000fffc));
+#endif
+}
+
+static void kvm_patch_ins_lwz(u32 *inst, long addr, u32 rt)
+{
+        kvm_patch_ins(inst, KVM_INST_LWZ | rt | (addr & 0x0000ffff));
+}
+
+static void kvm_patch_ins_std(u32 *inst, long addr, u32 rt)
+{
+#ifdef CONFIG_64BIT
+        kvm_patch_ins(inst, KVM_INST_STD | rt | (addr & 0x0000fffc));
+#else
+        kvm_patch_ins(inst, KVM_INST_STW | rt | ((addr + 4) & 0x0000fffc));
+#endif
+}
+
+static void kvm_patch_ins_stw(u32 *inst, long addr, u32 rt)
+{
+        kvm_patch_ins(inst, KVM_INST_STW | rt | (addr & 0x0000fffc));
+}
+
+static void kvm_patch_ins_nop(u32 *inst)
+{
+        kvm_patch_ins(inst, KVM_INST_NOP);
+}
+
+static void kvm_patch_ins_b(u32 *inst, int addr)
+{
+#ifdef CONFIG_RELOCATABLE
+        /* On relocatable kernels interrupts handlers and our code
+           can be in different regions, so we don't patch them */
+
+        extern u32 __end_interrupts;
+        if ((ulong)inst < (ulong)&__end_interrupts)
+                return;
+#endif
+
+        kvm_patch_ins(inst, KVM_INST_B | (addr & KVM_INST_B_MASK));
+}
+
+static u32 *kvm_alloc(int len)
+{
+        u32 *p;
+
+        if ((kvm_tmp_index + len) > ARRAY_SIZE(kvm_tmp)) {
+                printk(KERN_ERR "KVM: No more space (%d + %d)\n",
+                                kvm_tmp_index, len);
+                kvm_patching_worked = false;
+                return NULL;
+        }
+
+        p = (void*)&kvm_tmp[kvm_tmp_index];
+        kvm_tmp_index += len;
+
+        return p;
+}
+
+extern u32 kvm_emulate_mtmsrd_branch_offs;
+extern u32 kvm_emulate_mtmsrd_reg_offs;
+extern u32 kvm_emulate_mtmsrd_orig_ins_offs;
+extern u32 kvm_emulate_mtmsrd_len;
+extern u32 kvm_emulate_mtmsrd[];
+
+static void kvm_patch_ins_mtmsrd(u32 *inst, u32 rt)
+{
+        u32 *p;
+        int distance_start;
+        int distance_end;
+        ulong next_inst;
+
+        p = kvm_alloc(kvm_emulate_mtmsrd_len * 4);
+        if (!p)
+                return;
+
+        /* Find out where we are and put everything there */
+        distance_start = (ulong)p - (ulong)inst;
+        next_inst = ((ulong)inst + 4);
+        distance_end = next_inst - (ulong)&p[kvm_emulate_mtmsrd_branch_offs];
+
+        /* Make sure we only write valid b instructions */
+        if (distance_start > KVM_INST_B_MAX) {
+                kvm_patching_worked = false;
+                return;
+        }
+
+        /* Modify the chunk to fit the invocation */
+        memcpy(p, kvm_emulate_mtmsrd, kvm_emulate_mtmsrd_len * 4);
+        p[kvm_emulate_mtmsrd_branch_offs] |= distance_end & KVM_INST_B_MASK;
+        switch (get_rt(rt)) {
+        case 30:
+                kvm_patch_ins_ll(&p[kvm_emulate_mtmsrd_reg_offs],
+                                 magic_var(scratch2), KVM_RT_30);
+                break;
+        case 31:
+                kvm_patch_ins_ll(&p[kvm_emulate_mtmsrd_reg_offs],
+                                 magic_var(scratch1), KVM_RT_30);
+                break;
+        default:
+                p[kvm_emulate_mtmsrd_reg_offs] |= rt;
+                break;
+        }
+
+        p[kvm_emulate_mtmsrd_orig_ins_offs] = *inst;
+        flush_icache_range((ulong)p, (ulong)p + kvm_emulate_mtmsrd_len * 4);
+
+        /* Patch the invocation */
+        kvm_patch_ins_b(inst, distance_start);
+}
+
+extern u32 kvm_emulate_mtmsr_branch_offs;
+extern u32 kvm_emulate_mtmsr_reg1_offs;
+extern u32 kvm_emulate_mtmsr_reg2_offs;
+extern u32 kvm_emulate_mtmsr_orig_ins_offs;
+extern u32 kvm_emulate_mtmsr_len;
+extern u32 kvm_emulate_mtmsr[];
+
+static void kvm_patch_ins_mtmsr(u32 *inst, u32 rt)
+{
+        u32 *p;
+        int distance_start;
+        int distance_end;
+        ulong next_inst;
+
+        p = kvm_alloc(kvm_emulate_mtmsr_len * 4);
+        if (!p)
+                return;
+
+        /* Find out where we are and put everything there */
+        distance_start = (ulong)p - (ulong)inst;
+        next_inst = ((ulong)inst + 4);
+        distance_end = next_inst - (ulong)&p[kvm_emulate_mtmsr_branch_offs];
+
+        /* Make sure we only write valid b instructions */
+        if (distance_start > KVM_INST_B_MAX) {
+                kvm_patching_worked = false;
+                return;
+        }
+
+        /* Modify the chunk to fit the invocation */
+        memcpy(p, kvm_emulate_mtmsr, kvm_emulate_mtmsr_len * 4);
+        p[kvm_emulate_mtmsr_branch_offs] |= distance_end & KVM_INST_B_MASK;
+
+        /* Make clobbered registers work too */
+        switch (get_rt(rt)) {
+        case 30:
+                kvm_patch_ins_ll(&p[kvm_emulate_mtmsr_reg1_offs],
+                                 magic_var(scratch2), KVM_RT_30);
+                kvm_patch_ins_ll(&p[kvm_emulate_mtmsr_reg2_offs],
+                                 magic_var(scratch2), KVM_RT_30);
+                break;
+        case 31:
+                kvm_patch_ins_ll(&p[kvm_emulate_mtmsr_reg1_offs],
+                                 magic_var(scratch1), KVM_RT_30);
+                kvm_patch_ins_ll(&p[kvm_emulate_mtmsr_reg2_offs],
+                                 magic_var(scratch1), KVM_RT_30);
+                break;
+        default:
+                p[kvm_emulate_mtmsr_reg1_offs] |= rt;
+                p[kvm_emulate_mtmsr_reg2_offs] |= rt;
+                break;
+        }
+
+        p[kvm_emulate_mtmsr_orig_ins_offs] = *inst;
+        flush_icache_range((ulong)p, (ulong)p + kvm_emulate_mtmsr_len * 4);
+
+        /* Patch the invocation */
+        kvm_patch_ins_b(inst, distance_start);
+}
+
+#ifdef CONFIG_BOOKE
+
+extern u32 kvm_emulate_wrteei_branch_offs;
+extern u32 kvm_emulate_wrteei_ee_offs;
+extern u32 kvm_emulate_wrteei_len;
+extern u32 kvm_emulate_wrteei[];
+
+static void kvm_patch_ins_wrteei(u32 *inst)
+{
+        u32 *p;
+        int distance_start;
+        int distance_end;
+        ulong next_inst;
+
+        p = kvm_alloc(kvm_emulate_wrteei_len * 4);
+        if (!p)
+                return;
+
+        /* Find out where we are and put everything there */
+        distance_start = (ulong)p - (ulong)inst;
+        next_inst = ((ulong)inst + 4);
+        distance_end = next_inst - (ulong)&p[kvm_emulate_wrteei_branch_offs];
+
+        /* Make sure we only write valid b instructions */
+        if (distance_start > KVM_INST_B_MAX) {
+                kvm_patching_worked = false;
+                return;
+        }
+
+        /* Modify the chunk to fit the invocation */
+        memcpy(p, kvm_emulate_wrteei, kvm_emulate_wrteei_len * 4);
+        p[kvm_emulate_wrteei_branch_offs] |= distance_end & KVM_INST_B_MASK;
+        p[kvm_emulate_wrteei_ee_offs] |= (*inst & MSR_EE);
+        flush_icache_range((ulong)p, (ulong)p + kvm_emulate_wrteei_len * 4);
+
+        /* Patch the invocation */
+        kvm_patch_ins_b(inst, distance_start);
+}
+
+#endif
+
+#ifdef CONFIG_PPC_BOOK3S_32
+
+extern u32 kvm_emulate_mtsrin_branch_offs;
+extern u32 kvm_emulate_mtsrin_reg1_offs;
+extern u32 kvm_emulate_mtsrin_reg2_offs;
+extern u32 kvm_emulate_mtsrin_orig_ins_offs;
+extern u32 kvm_emulate_mtsrin_len;
+extern u32 kvm_emulate_mtsrin[];
+
+static void kvm_patch_ins_mtsrin(u32 *inst, u32 rt, u32 rb)
+{
+        u32 *p;
+        int distance_start;
+        int distance_end;
+        ulong next_inst;
+
+        p = kvm_alloc(kvm_emulate_mtsrin_len * 4);
+        if (!p)
+                return;
+
+        /* Find out where we are and put everything there */
+        distance_start = (ulong)p - (ulong)inst;
+        next_inst = ((ulong)inst + 4);
+        distance_end = next_inst - (ulong)&p[kvm_emulate_mtsrin_branch_offs];
+
+        /* Make sure we only write valid b instructions */
+        if (distance_start > KVM_INST_B_MAX) {
+                kvm_patching_worked = false;
+                return;
+        }
+
+        /* Modify the chunk to fit the invocation */
+        memcpy(p, kvm_emulate_mtsrin, kvm_emulate_mtsrin_len * 4);
+        p[kvm_emulate_mtsrin_branch_offs] |= distance_end & KVM_INST_B_MASK;
+        p[kvm_emulate_mtsrin_reg1_offs] |= (rb << 10);
+        p[kvm_emulate_mtsrin_reg2_offs] |= rt;
+        p[kvm_emulate_mtsrin_orig_ins_offs] = *inst;
+        flush_icache_range((ulong)p, (ulong)p + kvm_emulate_mtsrin_len * 4);
+
+        /* Patch the invocation */
+        kvm_patch_ins_b(inst, distance_start);
+}
+
+#endif
+
+static void kvm_map_magic_page(void *data)
+{
+        u32 *features = data;
+
+        ulong in[8];
+        ulong out[8];
+
+        in[0] = KVM_MAGIC_PAGE;
+        in[1] = KVM_MAGIC_PAGE;
+
+        kvm_hypercall(in, out, HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE);
+
+        *features = out[0];
+}
+
+static void kvm_check_ins(u32 *inst, u32 features)
+{
+        u32 _inst = *inst;
+        u32 inst_no_rt = _inst & ~KVM_MASK_RT;
+        u32 inst_rt = _inst & KVM_MASK_RT;
+
+        switch (inst_no_rt) {
+        /* Loads */
+        case KVM_INST_MFMSR:
+                kvm_patch_ins_ld(inst, magic_var(msr), inst_rt);
+                break;
+        case KVM_INST_MFSPR_SPRG0:
+                kvm_patch_ins_ld(inst, magic_var(sprg0), inst_rt);
+                break;
+        case KVM_INST_MFSPR_SPRG1:
+                kvm_patch_ins_ld(inst, magic_var(sprg1), inst_rt);
+                break;
+        case KVM_INST_MFSPR_SPRG2:
+                kvm_patch_ins_ld(inst, magic_var(sprg2), inst_rt);
+                break;
+        case KVM_INST_MFSPR_SPRG3:
+                kvm_patch_ins_ld(inst, magic_var(sprg3), inst_rt);
+                break;
+        case KVM_INST_MFSPR_SRR0:
+                kvm_patch_ins_ld(inst, magic_var(srr0), inst_rt);
+                break;
+        case KVM_INST_MFSPR_SRR1:
+                kvm_patch_ins_ld(inst, magic_var(srr1), inst_rt);
+                break;
+        case KVM_INST_MFSPR_DAR:
+                kvm_patch_ins_ld(inst, magic_var(dar), inst_rt);
+                break;
+        case KVM_INST_MFSPR_DSISR:
+                kvm_patch_ins_lwz(inst, magic_var(dsisr), inst_rt);
+                break;
+
+        /* Stores */
+        case KVM_INST_MTSPR_SPRG0:
+                kvm_patch_ins_std(inst, magic_var(sprg0), inst_rt);
+                break;
+        case KVM_INST_MTSPR_SPRG1:
+                kvm_patch_ins_std(inst, magic_var(sprg1), inst_rt);
+                break;
+        case KVM_INST_MTSPR_SPRG2:
+                kvm_patch_ins_std(inst, magic_var(sprg2), inst_rt);
+                break;
+        case KVM_INST_MTSPR_SPRG3:
+                kvm_patch_ins_std(inst, magic_var(sprg3), inst_rt);
+                break;
+        case KVM_INST_MTSPR_SRR0:
+                kvm_patch_ins_std(inst, magic_var(srr0), inst_rt);
+                break;
+        case KVM_INST_MTSPR_SRR1:
+                kvm_patch_ins_std(inst, magic_var(srr1), inst_rt);
+                break;
+        case KVM_INST_MTSPR_DAR:
+                kvm_patch_ins_std(inst, magic_var(dar), inst_rt);
+                break;
+        case KVM_INST_MTSPR_DSISR:
+                kvm_patch_ins_stw(inst, magic_var(dsisr), inst_rt);
+                break;
+
+        /* Nops */
+        case KVM_INST_TLBSYNC:
+                kvm_patch_ins_nop(inst);
+                break;
+
+        /* Rewrites */
+        case KVM_INST_MTMSRD_L1:
+                kvm_patch_ins_mtmsrd(inst, inst_rt);
+                break;
+        case KVM_INST_MTMSR:
+        case KVM_INST_MTMSRD_L0:
+                kvm_patch_ins_mtmsr(inst, inst_rt);
+                break;
+        }
+
+        switch (inst_no_rt & ~KVM_MASK_RB) {
+#ifdef CONFIG_PPC_BOOK3S_32
+        case KVM_INST_MTSRIN:
+                if (features & KVM_MAGIC_FEAT_SR) {
+                        u32 inst_rb = _inst & KVM_MASK_RB;
+                        kvm_patch_ins_mtsrin(inst, inst_rt, inst_rb);
+                }
+                break;
+                break;
+#endif
+        }
+
+        switch (_inst) {
+#ifdef CONFIG_BOOKE
+        case KVM_INST_WRTEEI_0:
+        case KVM_INST_WRTEEI_1:
+                kvm_patch_ins_wrteei(inst);
+                break;
+#endif
+        }
+}
+
+static void kvm_use_magic_page(void)
+{
+        u32 *p;
+        u32 *start, *end;
+        u32 tmp;
+        u32 features;
+
+        /* Tell the host to map the magic page to -4096 on all CPUs */
+        on_each_cpu(kvm_map_magic_page, &features, 1);
+
+        /* Quick self-test to see if the mapping works */
+        if (__get_user(tmp, (u32*)KVM_MAGIC_PAGE)) {
+                kvm_patching_worked = false;
+                return;
+        }
+
+        /* Now loop through all code and find instructions */
+        start = (void*)_stext;
+        end = (void*)_etext;
+
+        for (p = start; p < end; p++)
+                kvm_check_ins(p, features);
+
+        printk(KERN_INFO "KVM: Live patching for a fast VM %s\n",
+                         kvm_patching_worked ? "worked" : "failed");
+}
+
+unsigned long kvm_hypercall(unsigned long *in,
+                            unsigned long *out,
+                            unsigned long nr)
+{
+        unsigned long register r0 asm("r0");
+        unsigned long register r3 asm("r3") = in[0];
+        unsigned long register r4 asm("r4") = in[1];
+        unsigned long register r5 asm("r5") = in[2];
+        unsigned long register r6 asm("r6") = in[3];
+        unsigned long register r7 asm("r7") = in[4];
+        unsigned long register r8 asm("r8") = in[5];
+        unsigned long register r9 asm("r9") = in[6];
+        unsigned long register r10 asm("r10") = in[7];
+        unsigned long register r11 asm("r11") = nr;
+        unsigned long register r12 asm("r12");
+
+        asm volatile("bl        kvm_hypercall_start"
+                     : "=r"(r0), "=r"(r3), "=r"(r4), "=r"(r5), "=r"(r6),
+                       "=r"(r7), "=r"(r8), "=r"(r9), "=r"(r10), "=r"(r11),
+                       "=r"(r12)
+                     : "r"(r3), "r"(r4), "r"(r5), "r"(r6), "r"(r7), "r"(r8),
+                       "r"(r9), "r"(r10), "r"(r11)
+                     : "memory", "cc", "xer", "ctr", "lr");
+
+        out[0] = r4;
+        out[1] = r5;
+        out[2] = r6;
+        out[3] = r7;
+        out[4] = r8;
+        out[5] = r9;
+        out[6] = r10;
+        out[7] = r11;
+
+        return r3;
+}
+EXPORT_SYMBOL_GPL(kvm_hypercall);
+
+static int kvm_para_setup(void)
+{
+        extern u32 kvm_hypercall_start;
+        struct device_node *hyper_node;
+        u32 *insts;
+        int len, i;
+
+        hyper_node = of_find_node_by_path("/hypervisor");
+        if (!hyper_node)
+                return -1;
+
+        insts = (u32*)of_get_property(hyper_node, "hcall-instructions", &len);
+        if (len % 4)
+                return -1;
+        if (len > (4 * 4))
+                return -1;
+
+        for (i = 0; i < (len / 4); i++)
+                kvm_patch_ins(&(&kvm_hypercall_start)[i], insts[i]);
+
+        return 0;
+}
+
+static __init void kvm_free_tmp(void)
+{
+        unsigned long start, end;
+
+        start = (ulong)&kvm_tmp[kvm_tmp_index + (PAGE_SIZE - 1)] & PAGE_MASK;
+        end = (ulong)&kvm_tmp[ARRAY_SIZE(kvm_tmp)] & PAGE_MASK;
+
+        /* Free the tmp space we don't need */
+        for (; start < end; start += PAGE_SIZE) {
+                ClearPageReserved(virt_to_page(start));
+                init_page_count(virt_to_page(start));
+                free_page(start);
+                totalram_pages++;
+        }
+}
+
+static int __init kvm_guest_init(void)
+{
+        if (!kvm_para_available())
+                goto free_tmp;
+
+        if (kvm_para_setup())
+                goto free_tmp;
+
+        if (kvm_para_has_feature(KVM_FEATURE_MAGIC_PAGE))
+                kvm_use_magic_page();
+
+#ifdef CONFIG_PPC_BOOK3S_64
+        /* Enable napping */
+        powersave_nap = 1;
+#endif
+
+free_tmp:
+        kvm_free_tmp();
+
+        return 0;
+}
+
+postcore_initcall(kvm_guest_init);
diff --git a/arch/powerpc/kernel/kvm_emul.S b/arch/powerpc/kernel/kvm_emul.S
new file mode 100644
index 000000000000..f2b1b2523e61
--- /dev/null
+++ b/arch/powerpc/kernel/kvm_emul.S
@@ -0,0 +1,302 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Copyright SUSE Linux Products GmbH 2010
+ *
+ * Authors: Alexander Graf <agraf@suse.de>
+ */
+
+#include <asm/ppc_asm.h>
+#include <asm/kvm_asm.h>
+#include <asm/reg.h>
+#include <asm/page.h>
+#include <asm/asm-offsets.h>
+
+/* Hypercall entry point. Will be patched with device tree instructions. */
+
+.global kvm_hypercall_start
+kvm_hypercall_start:
+        li      r3, -1
+        nop
+        nop
+        nop
+        blr
+
+#define KVM_MAGIC_PAGE          (-4096)
+
+#ifdef CONFIG_64BIT
+#define LL64(reg, offs, reg2)   ld      reg, (offs)(reg2)
+#define STL64(reg, offs, reg2)  std     reg, (offs)(reg2)
+#else
+#define LL64(reg, offs, reg2)   lwz     reg, (offs + 4)(reg2)
+#define STL64(reg, offs, reg2)  stw     reg, (offs + 4)(reg2)
+#endif
+
+#define SCRATCH_SAVE                                                    \
+        /* Enable critical section. We are critical if                  \
+           shared->critical == r1 */                                    \
+        STL64(r1, KVM_MAGIC_PAGE + KVM_MAGIC_CRITICAL, 0);              \
+                                                                        \
+        /* Save state */                                                \
+        PPC_STL r31, (KVM_MAGIC_PAGE + KVM_MAGIC_SCRATCH1)(0);          \
+        PPC_STL r30, (KVM_MAGIC_PAGE + KVM_MAGIC_SCRATCH2)(0);          \
+        mfcr    r31;                                                    \
+        stw     r31, (KVM_MAGIC_PAGE + KVM_MAGIC_SCRATCH3)(0);
+
+#define SCRATCH_RESTORE                                                 \
+        /* Restore state */                                             \
+        PPC_LL  r31, (KVM_MAGIC_PAGE + KVM_MAGIC_SCRATCH1)(0);          \
+        lwz     r30, (KVM_MAGIC_PAGE + KVM_MAGIC_SCRATCH3)(0);          \
+        mtcr    r30;                                                    \
+        PPC_LL  r30, (KVM_MAGIC_PAGE + KVM_MAGIC_SCRATCH2)(0);          \
+                                                                        \
+        /* Disable critical section. We are critical if                 \
+           shared->critical == r1 and r2 is always != r1 */             \
+        STL64(r2, KVM_MAGIC_PAGE + KVM_MAGIC_CRITICAL, 0);
+
+.global kvm_emulate_mtmsrd
+kvm_emulate_mtmsrd:
+
+        SCRATCH_SAVE
+
+        /* Put MSR & ~(MSR_EE|MSR_RI) in r31 */
+        LL64(r31, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+        lis     r30, (~(MSR_EE | MSR_RI))@h
+        ori     r30, r30, (~(MSR_EE | MSR_RI))@l
+        and     r31, r31, r30
+
+        /* OR the register's (MSR_EE|MSR_RI) on MSR */
+kvm_emulate_mtmsrd_reg:
+        ori     r30, r0, 0
+        andi.   r30, r30, (MSR_EE|MSR_RI)
+        or      r31, r31, r30
+
+        /* Put MSR back into magic page */
+        STL64(r31, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+
+        /* Check if we have to fetch an interrupt */
+        lwz     r31, (KVM_MAGIC_PAGE + KVM_MAGIC_INT)(0)
+        cmpwi   r31, 0
+        beq+    no_check
+
+        /* Check if we may trigger an interrupt */
+        andi.   r30, r30, MSR_EE
+        beq     no_check
+
+        SCRATCH_RESTORE
+
+        /* Nag hypervisor */
+kvm_emulate_mtmsrd_orig_ins:
+        tlbsync
+
+        b       kvm_emulate_mtmsrd_branch
+
+no_check:
+
+        SCRATCH_RESTORE
+
+        /* Go back to caller */
+kvm_emulate_mtmsrd_branch:
+        b       .
+kvm_emulate_mtmsrd_end:
+
+.global kvm_emulate_mtmsrd_branch_offs
+kvm_emulate_mtmsrd_branch_offs:
+        .long (kvm_emulate_mtmsrd_branch - kvm_emulate_mtmsrd) / 4
+
+.global kvm_emulate_mtmsrd_reg_offs
+kvm_emulate_mtmsrd_reg_offs:
+        .long (kvm_emulate_mtmsrd_reg - kvm_emulate_mtmsrd) / 4
+
+.global kvm_emulate_mtmsrd_orig_ins_offs
+kvm_emulate_mtmsrd_orig_ins_offs:
+        .long (kvm_emulate_mtmsrd_orig_ins - kvm_emulate_mtmsrd) / 4
+
+.global kvm_emulate_mtmsrd_len
+kvm_emulate_mtmsrd_len:
+        .long (kvm_emulate_mtmsrd_end - kvm_emulate_mtmsrd) / 4
+
+
+#define MSR_SAFE_BITS (MSR_EE | MSR_CE | MSR_ME | MSR_RI)
+#define MSR_CRITICAL_BITS ~MSR_SAFE_BITS
+
+.global kvm_emulate_mtmsr
+kvm_emulate_mtmsr:
+
+        SCRATCH_SAVE
+
+        /* Fetch old MSR in r31 */
+        LL64(r31, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+
+        /* Find the changed bits between old and new MSR */
+kvm_emulate_mtmsr_reg1:
+        ori     r30, r0, 0
+        xor     r31, r30, r31
+
+        /* Check if we need to really do mtmsr */
+        LOAD_REG_IMMEDIATE(r30, MSR_CRITICAL_BITS)
+        and.    r31, r31, r30
+
+        /* No critical bits changed? Maybe we can stay in the guest. */
+        beq     maybe_stay_in_guest
+
+do_mtmsr:
+
+        SCRATCH_RESTORE
+
+        /* Just fire off the mtmsr if it's critical */
+kvm_emulate_mtmsr_orig_ins:
+        mtmsr   r0
+
+        b       kvm_emulate_mtmsr_branch
+
+maybe_stay_in_guest:
+
+        /* Get the target register in r30 */
+kvm_emulate_mtmsr_reg2:
+        ori     r30, r0, 0
+
+        /* Check if we have to fetch an interrupt */
+        lwz     r31, (KVM_MAGIC_PAGE + KVM_MAGIC_INT)(0)
+        cmpwi   r31, 0
+        beq+    no_mtmsr
+
+        /* Check if we may trigger an interrupt */
+        andi.   r31, r30, MSR_EE
+        beq     no_mtmsr
+
+        b       do_mtmsr
+
+no_mtmsr:
+
+        /* Put MSR into magic page because we don't call mtmsr */
+        STL64(r30, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+
+        SCRATCH_RESTORE
+
+        /* Go back to caller */
+kvm_emulate_mtmsr_branch:
+        b       .
+kvm_emulate_mtmsr_end:
+
+.global kvm_emulate_mtmsr_branch_offs
+kvm_emulate_mtmsr_branch_offs:
+        .long (kvm_emulate_mtmsr_branch - kvm_emulate_mtmsr) / 4
+
+.global kvm_emulate_mtmsr_reg1_offs
+kvm_emulate_mtmsr_reg1_offs:
+        .long (kvm_emulate_mtmsr_reg1 - kvm_emulate_mtmsr) / 4
+
+.global kvm_emulate_mtmsr_reg2_offs
+kvm_emulate_mtmsr_reg2_offs:
+        .long (kvm_emulate_mtmsr_reg2 - kvm_emulate_mtmsr) / 4
+
+.global kvm_emulate_mtmsr_orig_ins_offs
+kvm_emulate_mtmsr_orig_ins_offs:
+        .long (kvm_emulate_mtmsr_orig_ins - kvm_emulate_mtmsr) / 4
+
+.global kvm_emulate_mtmsr_len
+kvm_emulate_mtmsr_len:
+        .long (kvm_emulate_mtmsr_end - kvm_emulate_mtmsr) / 4
+
+
+
+.global kvm_emulate_wrteei
+kvm_emulate_wrteei:
+
+        SCRATCH_SAVE
+
+        /* Fetch old MSR in r31 */
+        LL64(r31, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+
+        /* Remove MSR_EE from old MSR */
+        li      r30, 0
+        ori     r30, r30, MSR_EE
+        andc    r31, r31, r30
+
+        /* OR new MSR_EE onto the old MSR */
+kvm_emulate_wrteei_ee:
+        ori     r31, r31, 0
+
+        /* Write new MSR value back */
+        STL64(r31, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+
+        SCRATCH_RESTORE
+
+        /* Go back to caller */
+kvm_emulate_wrteei_branch:
+        b       .
+kvm_emulate_wrteei_end:
+
+.global kvm_emulate_wrteei_branch_offs
+kvm_emulate_wrteei_branch_offs:
+        .long (kvm_emulate_wrteei_branch - kvm_emulate_wrteei) / 4
+
+.global kvm_emulate_wrteei_ee_offs
+kvm_emulate_wrteei_ee_offs:
+        .long (kvm_emulate_wrteei_ee - kvm_emulate_wrteei) / 4
+
+.global kvm_emulate_wrteei_len
+kvm_emulate_wrteei_len:
+        .long (kvm_emulate_wrteei_end - kvm_emulate_wrteei) / 4
+
+
+.global kvm_emulate_mtsrin
+kvm_emulate_mtsrin:
+
+        SCRATCH_SAVE
+
+        LL64(r31, KVM_MAGIC_PAGE + KVM_MAGIC_MSR, 0)
+        andi.   r31, r31, MSR_DR | MSR_IR
+        beq     kvm_emulate_mtsrin_reg1
+
+        SCRATCH_RESTORE
+
+kvm_emulate_mtsrin_orig_ins:
+        nop
+        b       kvm_emulate_mtsrin_branch
+
+kvm_emulate_mtsrin_reg1:
+        /* rX >> 26 */
+        rlwinm  r30,r0,6,26,29
+
+kvm_emulate_mtsrin_reg2:
+        stw     r0, (KVM_MAGIC_PAGE + KVM_MAGIC_SR)(r30)
+
+        SCRATCH_RESTORE
+
+        /* Go back to caller */
+kvm_emulate_mtsrin_branch:
+        b       .
+kvm_emulate_mtsrin_end:
+
+.global kvm_emulate_mtsrin_branch_offs
+kvm_emulate_mtsrin_branch_offs:
+        .long (kvm_emulate_mtsrin_branch - kvm_emulate_mtsrin) / 4
+
+.global kvm_emulate_mtsrin_reg1_offs
+kvm_emulate_mtsrin_reg1_offs:
+        .long (kvm_emulate_mtsrin_reg1 - kvm_emulate_mtsrin) / 4
+
+.global kvm_emulate_mtsrin_reg2_offs
+kvm_emulate_mtsrin_reg2_offs:
+        .long (kvm_emulate_mtsrin_reg2 - kvm_emulate_mtsrin) / 4
+
+.global kvm_emulate_mtsrin_orig_ins_offs
+kvm_emulate_mtsrin_orig_ins_offs:
+        .long (kvm_emulate_mtsrin_orig_ins - kvm_emulate_mtsrin) / 4
+
+.global kvm_emulate_mtsrin_len
+kvm_emulate_mtsrin_len:
+        .long (kvm_emulate_mtsrin_end - kvm_emulate_mtsrin) / 4
diff --git a/arch/powerpc/kernel/legacy_serial.c b/arch/powerpc/kernel/legacy_serial.c
index c1fd0f9658fd..c834757bebc0 100644
--- a/arch/powerpc/kernel/legacy_serial.c
+++ b/arch/powerpc/kernel/legacy_serial.c
@@ -52,14 +52,14 @@ static int __init add_legacy_port(struct device_node *np, int want_index,
                                   phys_addr_t taddr, unsigned long irq,
                                   upf_t flags, int irq_check_parent)
 {
-        const u32 *clk, *spd;
+        const __be32 *clk, *spd;
         u32 clock = BASE_BAUD * 16;
         int index;
 
         /* get clock freq. if present */
         clk = of_get_property(np, "clock-frequency", NULL);
         if (clk && *clk)
-                clock = *clk;
+                clock = be32_to_cpup(clk);
 
         /* get default speed if present */
         spd = of_get_property(np, "current-speed", NULL);
@@ -109,7 +109,7 @@ static int __init add_legacy_port(struct device_node *np, int want_index,
         legacy_serial_infos[index].taddr = taddr;
         legacy_serial_infos[index].np = of_node_get(np);
         legacy_serial_infos[index].clock = clock;
-        legacy_serial_infos[index].speed = spd ? *spd : 0;
+        legacy_serial_infos[index].speed = spd ? be32_to_cpup(spd) : 0;
         legacy_serial_infos[index].irq_check_parent = irq_check_parent;
 
         printk(KERN_DEBUG "Found legacy serial port %d for %s\n",
@@ -168,7 +168,7 @@ static int __init add_legacy_soc_port(struct device_node *np,
 static int __init add_legacy_isa_port(struct device_node *np,
                                       struct device_node *isa_brg)
 {
-        const u32 *reg;
+        const __be32 *reg;
         const char *typep;
         int index = -1;
         u64 taddr;
@@ -181,7 +181,7 @@ static int __init add_legacy_isa_port(struct device_node *np,
                 return -1;
 
         /* Verify it's an IO port, we don't support anything else */
-        if (!(reg[0] & 0x00000001))
+        if (!(be32_to_cpu(reg[0]) & 0x00000001))
                 return -1;
 
         /* Now look for an "ibm,aix-loc" property that gives us ordering
@@ -202,7 +202,7 @@ static int __init add_legacy_isa_port(struct device_node *np,
                 taddr = 0;
 
         /* Add port, irq will be dealt with later */
-        return add_legacy_port(np, index, UPIO_PORT, reg[1], taddr,
+        return add_legacy_port(np, index, UPIO_PORT, be32_to_cpu(reg[1]), taddr,
                                NO_IRQ, UPF_BOOT_AUTOCONF, 0);
 
 }
@@ -251,9 +251,9 @@ static int __init add_legacy_pci_port(struct device_node *np,
          * we get to their "reg" property
          */
         if (np != pci_dev) {
-                const u32 *reg = of_get_property(np, "reg", NULL);
-                if (reg && (*reg < 4))
-                        index = lindex = *reg;
+                const __be32 *reg = of_get_property(np, "reg", NULL);
+                if (reg && (be32_to_cpup(reg) < 4))
+                        index = lindex = be32_to_cpup(reg);
         }
 
         /* Local index means it's the Nth port in the PCI chip. Unfortunately
@@ -507,7 +507,7 @@ static int __init check_legacy_serial_console(void)
         struct device_node *prom_stdout = NULL;
         int i, speed = 0, offset = 0;
         const char *name;
-        const u32 *spd;
+        const __be32 *spd;
 
         DBG(" -> check_legacy_serial_console()\n");
 
@@ -547,7 +547,7 @@ static int __init check_legacy_serial_console(void)
         }
         spd = of_get_property(prom_stdout, "current-speed", NULL);
         if (spd)
-                speed = *spd;
+                speed = be32_to_cpup(spd);
 
         if (strcmp(name, "serial") != 0)
                 goto not_found;
diff --git a/arch/powerpc/kernel/lparcfg.c b/arch/powerpc/kernel/lparcfg.c
index 8d9e3b9cda64..16468362ad57 100644
--- a/arch/powerpc/kernel/lparcfg.c
+++ b/arch/powerpc/kernel/lparcfg.c
@@ -780,6 +780,7 @@ static const struct file_operations lparcfg_fops = {
         .write          = lparcfg_write,
         .open           = lparcfg_open,
         .release        = single_release,
+        .llseek         = seq_lseek,
 };
 
 static int __init lparcfg_init(void)
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index c3c6a8857544..9e3132db718b 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -364,10 +364,15 @@ static int __init early_init_dt_scan_cpus(unsigned long node,
         return 0;
 }
 
-void __init early_init_dt_scan_chosen_arch(unsigned long node)
+int __init early_init_dt_scan_chosen_ppc(unsigned long node, const char *uname,
+                                         int depth, void *data)
 {
         unsigned long *lprop;
 
+        /* Use common scan routine to determine if this is the chosen node */
+        if (early_init_dt_scan_chosen(node, uname, depth, data) == 0)
+                return 0;
+
 #ifdef CONFIG_PPC64
         /* check if iommu is forced on or off */
         if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
@@ -399,6 +404,9 @@ void __init early_init_dt_scan_chosen_arch(unsigned long node)
         if (lprop)
                 crashk_res.end = crashk_res.start + *lprop - 1;
 #endif
+
+        /* break now */
+        return 1;
 }
 
 #ifdef CONFIG_PPC_PSERIES
@@ -683,7 +691,7 @@ void __init early_init_devtree(void *params)
          * device-tree, including the platform type, initrd location and
          * size, TCE reserve, and more ...
          */
-        of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
+        of_scan_flat_dt(early_init_dt_scan_chosen_ppc, NULL);
 
         /* Scan memory nodes and rebuild MEMBLOCKs */
         memblock_init();
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 286d9783d93f..a9b32967cff6 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -1406,37 +1406,42 @@ static long ppc_del_hwdebug(struct task_struct *child, long addr, long data)
  * Here are the old "legacy" powerpc specific getregs/setregs ptrace calls,
  * we mark them as obsolete now, they will be removed in a future version
  */
-static long arch_ptrace_old(struct task_struct *child, long request, long addr,
-                            long data)
+static long arch_ptrace_old(struct task_struct *child, long request,
+                            unsigned long addr, unsigned long data)
 {
+        void __user *datavp = (void __user *) data;
+
         switch (request) {
         case PPC_PTRACE_GETREGS:        /* Get GPRs 0 - 31. */
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_GPR, 0, 32 * sizeof(long),
-                                           (void __user *) data);
+                                           datavp);
 
         case PPC_PTRACE_SETREGS:        /* Set GPRs 0 - 31. */
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_GPR, 0, 32 * sizeof(long),
-                                             (const void __user *) data);
+                                             datavp);
 
         case PPC_PTRACE_GETFPREGS:      /* Get FPRs 0 - 31. */
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_FPR, 0, 32 * sizeof(double),
-                                           (void __user *) data);
+                                           datavp);
 
         case PPC_PTRACE_SETFPREGS:      /* Set FPRs 0 - 31. */
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_FPR, 0, 32 * sizeof(double),
-                                             (const void __user *) data);
+                                             datavp);
         }
 
         return -EPERM;
 }
 
-long arch_ptrace(struct task_struct *child, long request, long addr, long data)
+long arch_ptrace(struct task_struct *child, long request,
+                 unsigned long addr, unsigned long data)
 {
         int ret = -EPERM;
+        void __user *datavp = (void __user *) data;
+        unsigned long __user *datalp = datavp;
 
         switch (request) {
         /* read the word at location addr in the USER area. */
@@ -1446,11 +1451,11 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 ret = -EIO;
                 /* convert to index and check */
 #ifdef CONFIG_PPC32
-                index = (unsigned long) addr >> 2;
+                index = addr >> 2;
                 if ((addr & 3) || (index > PT_FPSCR)
                     || (child->thread.regs == NULL))
 #else
-                index = (unsigned long) addr >> 3;
+                index = addr >> 3;
                 if ((addr & 7) || (index > PT_FPSCR))
 #endif
                         break;
@@ -1463,7 +1468,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                         tmp = ((unsigned long *)child->thread.fpr)
                                 [TS_FPRWIDTH * (index - PT_FPR0)];
                 }
-                ret = put_user(tmp,(unsigned long __user *) data);
+                ret = put_user(tmp, datalp);
                 break;
         }
 
@@ -1474,11 +1479,11 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 ret = -EIO;
                 /* convert to index and check */
 #ifdef CONFIG_PPC32
-                index = (unsigned long) addr >> 2;
+                index = addr >> 2;
                 if ((addr & 3) || (index > PT_FPSCR)
                     || (child->thread.regs == NULL))
 #else
-                index = (unsigned long) addr >> 3;
+                index = addr >> 3;
                 if ((addr & 7) || (index > PT_FPSCR))
 #endif
                         break;
@@ -1525,11 +1530,11 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 dbginfo.features = 0;
 #endif /* CONFIG_PPC_ADV_DEBUG_REGS */
 
-                if (!access_ok(VERIFY_WRITE, data,
+                if (!access_ok(VERIFY_WRITE, datavp,
                                sizeof(struct ppc_debug_info)))
                         return -EFAULT;
-                ret = __copy_to_user((struct ppc_debug_info __user *)data,
-                                     &dbginfo, sizeof(struct ppc_debug_info)) ?
+                ret = __copy_to_user(datavp, &dbginfo,
+                                     sizeof(struct ppc_debug_info)) ?
                       -EFAULT : 0;
                 break;
         }
@@ -1537,11 +1542,10 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         case PPC_PTRACE_SETHWDEBUG: {
                 struct ppc_hw_breakpoint bp_info;
 
-                if (!access_ok(VERIFY_READ, data,
+                if (!access_ok(VERIFY_READ, datavp,
                                sizeof(struct ppc_hw_breakpoint)))
                         return -EFAULT;
-                ret = __copy_from_user(&bp_info,
-                                       (struct ppc_hw_breakpoint __user *)data,
+                ret = __copy_from_user(&bp_info, datavp,
                                        sizeof(struct ppc_hw_breakpoint)) ?
                       -EFAULT : 0;
                 if (!ret)
@@ -1560,11 +1564,9 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 if (addr > 0)
                         break;
 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
-                ret = put_user(child->thread.dac1,
-                               (unsigned long __user *)data);
+                ret = put_user(child->thread.dac1, datalp);
 #else
-                ret = put_user(child->thread.dabr,
-                               (unsigned long __user *)data);
+                ret = put_user(child->thread.dabr, datalp);
 #endif
                 break;
         }
@@ -1580,7 +1582,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_GPR,
                                            0, sizeof(struct pt_regs),
-                                           (void __user *) data);
+                                           datavp);
 
 #ifdef CONFIG_PPC64
         case PTRACE_SETREGS64:
@@ -1589,19 +1591,19 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_GPR,
                                              0, sizeof(struct pt_regs),
-                                             (const void __user *) data);
+                                             datavp);
 
         case PTRACE_GETFPREGS: /* Get the child FPU state (FPR0...31 + FPSCR) */
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_FPR,
                                            0, sizeof(elf_fpregset_t),
-                                           (void __user *) data);
+                                           datavp);
 
         case PTRACE_SETFPREGS: /* Set the child FPU state (FPR0...31 + FPSCR) */
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_FPR,
                                              0, sizeof(elf_fpregset_t),
-                                             (const void __user *) data);
+                                             datavp);
 
 #ifdef CONFIG_ALTIVEC
         case PTRACE_GETVRREGS:
@@ -1609,40 +1611,40 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                            REGSET_VMX,
                                            0, (33 * sizeof(vector128) +
                                                sizeof(u32)),
-                                           (void __user *) data);
+                                           datavp);
 
         case PTRACE_SETVRREGS:
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_VMX,
                                              0, (33 * sizeof(vector128) +
                                                  sizeof(u32)),
-                                             (const void __user *) data);
+                                             datavp);
 #endif
 #ifdef CONFIG_VSX
         case PTRACE_GETVSRREGS:
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_VSX,
                                            0, 32 * sizeof(double),
-                                           (void __user *) data);
+                                           datavp);
 
         case PTRACE_SETVSRREGS:
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_VSX,
                                              0, 32 * sizeof(double),
-                                             (const void __user *) data);
+                                             datavp);
 #endif
 #ifdef CONFIG_SPE
         case PTRACE_GETEVRREGS:
                 /* Get the child spe register state. */
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_SPE, 0, 35 * sizeof(u32),
-                                           (void __user *) data);
+                                           datavp);
 
         case PTRACE_SETEVRREGS:
                 /* Set the child spe register state. */
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_SPE, 0, 35 * sizeof(u32),
-                                             (const void __user *) data);
+                                             datavp);
 #endif
 
         /* Old reverse args ptrace callss */
diff --git a/arch/powerpc/kernel/rtas_flash.c b/arch/powerpc/kernel/rtas_flash.c
index 67a84d8f118d..2b442e6c21e6 100644
--- a/arch/powerpc/kernel/rtas_flash.c
+++ b/arch/powerpc/kernel/rtas_flash.c
@@ -716,6 +716,7 @@ static const struct file_operations rtas_flash_operations = {
         .write          = rtas_flash_write,
         .open           = rtas_excl_open,
         .release        = rtas_flash_release,
+        .llseek         = default_llseek,
 };
 
 static const struct file_operations manage_flash_operations = {
@@ -724,6 +725,7 @@ static const struct file_operations manage_flash_operations = {
         .write          = manage_flash_write,
         .open           = rtas_excl_open,
         .release        = rtas_excl_release,
+        .llseek         = default_llseek,
 };
 
 static const struct file_operations validate_flash_operations = {
@@ -732,6 +734,7 @@ static const struct file_operations validate_flash_operations = {
         .write          = validate_flash_write,
         .open           = rtas_excl_open,
         .release        = validate_flash_release,
+        .llseek         = default_llseek,
 };
 
 static int __init rtas_flash_init(void)
diff --git a/arch/powerpc/kernel/rtasd.c b/arch/powerpc/kernel/rtasd.c
index 638883e23e3a..0438f819fe6b 100644
--- a/arch/powerpc/kernel/rtasd.c
+++ b/arch/powerpc/kernel/rtasd.c
@@ -354,6 +354,7 @@ static const struct file_operations proc_rtas_log_operations = {
         .poll =         rtas_log_poll,
         .open =         rtas_log_open,
         .release =      rtas_log_release,
+        .llseek =       noop_llseek,
 };
 
 static int enable_surveillance(int timeout)
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index d692989a4318..441d2a722f06 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -238,9 +238,7 @@ static inline void vio_cmo_dealloc(struct vio_dev *viodev, size_t size)
          * memory in this pool does not change.
          */
         if (spare_needed && reserve_freed) {
-                tmp = min(spare_needed, min(reserve_freed,
-                                            (viodev->cmo.entitled -
-                                             VIO_CMO_MIN_ENT)));
+                tmp = min3(spare_needed, reserve_freed, (viodev->cmo.entitled - VIO_CMO_MIN_ENT));
 
                 vio_cmo.spare += tmp;
                 viodev->cmo.entitled -= tmp;