Merge branch 'for-kvm' into next

Topic branch for commits that the KVM tree might want to pull
in separately.

Hand merged a few files due to conflicts with the LE stuff

Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>

13 files changed, 215 insertions, 218 deletions

diff --git a/arch/powerpc/kernel/align.c b/arch/powerpc/kernel/align.c
index 59f70adcbcd9..6e3f9772aaba 100644
--- a/arch/powerpc/kernel/align.c
+++ b/arch/powerpc/kernel/align.c
@@ -652,9 +652,9 @@ static int emulate_vsx(unsigned char __user *addr, unsigned int reg,
         flush_vsx_to_thread(current);
 
         if (reg < 32)
-                ptr = (char *) &current->thread.fpr[reg][0];
+                ptr = (char *) &current->thread.fp_state.fpr[reg][0];
         else
-                ptr = (char *) &current->thread.vr[reg - 32];
+                ptr = (char *) &current->thread.vr_state.vr[reg - 32];
 
         lptr = (unsigned long *) ptr;
 
@@ -944,7 +944,7 @@ int fix_alignment(struct pt_regs *regs)
                         return -EFAULT;
 
         } else if (flags & F) {
-                data.dd = current->thread.TS_FPR(reg);
+                data.ll = current->thread.TS_FPR(reg);
                 if (flags & S) {
                         /* Single-precision FP store requires conversion... */
 #ifdef CONFIG_PPC_FPU
@@ -1021,7 +1021,7 @@ int fix_alignment(struct pt_regs *regs)
                 if (unlikely(ret))
                         return -EFAULT;
         } else if (flags & F)
-                current->thread.TS_FPR(reg) = data.dd;
+                current->thread.TS_FPR(reg) = data.ll;
         else
                 regs->gpr[reg] = data.ll;
 
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index 502c7a4e73f7..6278edddc3f8 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -90,16 +90,17 @@ int main(void)
         DEFINE(THREAD_NORMSAVES, offsetof(struct thread_struct, normsave[0]));
 #endif
         DEFINE(THREAD_FPEXC_MODE, offsetof(struct thread_struct, fpexc_mode));
-        DEFINE(THREAD_FPR0, offsetof(struct thread_struct, fpr[0]));
-        DEFINE(THREAD_FPSCR, offsetof(struct thread_struct, fpscr));
+        DEFINE(THREAD_FPSTATE, offsetof(struct thread_struct, fp_state));
+        DEFINE(THREAD_FPSAVEAREA, offsetof(struct thread_struct, fp_save_area));
+        DEFINE(FPSTATE_FPSCR, offsetof(struct thread_fp_state, fpscr));
 #ifdef CONFIG_ALTIVEC
-        DEFINE(THREAD_VR0, offsetof(struct thread_struct, vr[0]));
+        DEFINE(THREAD_VRSTATE, offsetof(struct thread_struct, vr_state));
+        DEFINE(THREAD_VRSAVEAREA, offsetof(struct thread_struct, vr_save_area));
         DEFINE(THREAD_VRSAVE, offsetof(struct thread_struct, vrsave));
-        DEFINE(THREAD_VSCR, offsetof(struct thread_struct, vscr));
         DEFINE(THREAD_USED_VR, offsetof(struct thread_struct, used_vr));
+        DEFINE(VRSTATE_VSCR, offsetof(struct thread_vr_state, vscr));
 #endif /* CONFIG_ALTIVEC */
 #ifdef CONFIG_VSX
-        DEFINE(THREAD_VSR0, offsetof(struct thread_struct, fpr));
         DEFINE(THREAD_USED_VSR, offsetof(struct thread_struct, used_vsr));
 #endif /* CONFIG_VSX */
 #ifdef CONFIG_PPC64
@@ -143,20 +144,12 @@ int main(void)
         DEFINE(THREAD_TM_PPR, offsetof(struct thread_struct, tm_ppr));
         DEFINE(THREAD_TM_DSCR, offsetof(struct thread_struct, tm_dscr));
         DEFINE(PT_CKPT_REGS, offsetof(struct thread_struct, ckpt_regs));
-        DEFINE(THREAD_TRANSACT_VR0, offsetof(struct thread_struct,
-                                         transact_vr[0]));
-        DEFINE(THREAD_TRANSACT_VSCR, offsetof(struct thread_struct,
-                                          transact_vscr));
+        DEFINE(THREAD_TRANSACT_VRSTATE, offsetof(struct thread_struct,
+                                                 transact_vr));
         DEFINE(THREAD_TRANSACT_VRSAVE, offsetof(struct thread_struct,
                                             transact_vrsave));
-        DEFINE(THREAD_TRANSACT_FPR0, offsetof(struct thread_struct,
-                                          transact_fpr[0]));
-        DEFINE(THREAD_TRANSACT_FPSCR, offsetof(struct thread_struct,
-                                           transact_fpscr));
-#ifdef CONFIG_VSX
-        DEFINE(THREAD_TRANSACT_VSR0, offsetof(struct thread_struct,
-                                          transact_fpr[0]));
-#endif
+        DEFINE(THREAD_TRANSACT_FPSTATE, offsetof(struct thread_struct,
+                                                 transact_fp));
         /* Local pt_regs on stack for Transactional Memory funcs. */
         DEFINE(TM_FRAME_SIZE, STACK_FRAME_OVERHEAD +
                sizeof(struct pt_regs) + 16);
diff --git a/arch/powerpc/kernel/fpu.S b/arch/powerpc/kernel/fpu.S
index caeaabf11a2f..4dca05e91e95 100644
--- a/arch/powerpc/kernel/fpu.S
+++ b/arch/powerpc/kernel/fpu.S
@@ -35,15 +35,6 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX);					\
 2:      REST_32VSRS(n,c,base);                                          \
 3:
 
-#define __REST_32FPVSRS_TRANSACT(n,c,base)                              \
-BEGIN_FTR_SECTION                                                       \
-        b       2f;                                                     \
-END_FTR_SECTION_IFSET(CPU_FTR_VSX);                                     \
-        REST_32FPRS_TRANSACT(n,base);                                   \
-        b       3f;                                                     \
-2:      REST_32VSRS_TRANSACT(n,c,base);                                 \
-3:
-
 #define __SAVE_32FPVSRS(n,c,base)                                       \
 BEGIN_FTR_SECTION                                                       \
         b       2f;                                                     \
@@ -54,40 +45,12 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX);					\
 3:
 #else
 #define __REST_32FPVSRS(n,b,base)       REST_32FPRS(n, base)
-#define __REST_32FPVSRS_TRANSACT(n,b,base)      REST_32FPRS(n, base)
 #define __SAVE_32FPVSRS(n,b,base)       SAVE_32FPRS(n, base)
 #endif
 #define REST_32FPVSRS(n,c,base) __REST_32FPVSRS(n,__REG_##c,__REG_##base)
-#define REST_32FPVSRS_TRANSACT(n,c,base) \
-        __REST_32FPVSRS_TRANSACT(n,__REG_##c,__REG_##base)
 #define SAVE_32FPVSRS(n,c,base) __SAVE_32FPVSRS(n,__REG_##c,__REG_##base)
 
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
-/*
- * Wrapper to call load_up_fpu from C.
- * void do_load_up_fpu(struct pt_regs *regs);
- */
-_GLOBAL(do_load_up_fpu)
-        mflr    r0
-        std     r0, 16(r1)
-        stdu    r1, -112(r1)
-
-        subi    r6, r3, STACK_FRAME_OVERHEAD
-        /* load_up_fpu expects r12=MSR, r13=PACA, and returns
-         * with r12 = new MSR.
-         */
-        ld      r12,_MSR(r6)
-        GET_PACA(r13)
-
-        bl      load_up_fpu
-        std     r12,_MSR(r6)
-
-        ld      r0, 112+16(r1)
-        addi    r1, r1, 112
-        mtlr    r0
-        blr
-
-
 /* void do_load_up_transact_fpu(struct thread_struct *thread)
  *
  * This is similar to load_up_fpu but for the transactional version of the FP
@@ -105,9 +68,10 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX)
         SYNC
         MTMSRD(r5)
 
-        lfd     fr0,THREAD_TRANSACT_FPSCR(r3)
+        addi    r7,r3,THREAD_TRANSACT_FPSTATE
+        lfd     fr0,FPSTATE_FPSCR(r7)
         MTFSF_L(fr0)
-        REST_32FPVSRS_TRANSACT(0, R4, R3)
+        REST_32FPVSRS(0, R4, R7)
 
         /* FP/VSX off again */
         MTMSRD(r6)
@@ -117,6 +81,26 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX)
 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
 
 /*
+ * Load state from memory into FP registers including FPSCR.
+ * Assumes the caller has enabled FP in the MSR.
+ */
+_GLOBAL(load_fp_state)
+        lfd     fr0,FPSTATE_FPSCR(r3)
+        MTFSF_L(fr0)
+        REST_32FPVSRS(0, R4, R3)
+        blr
+
+/*
+ * Store FP state into memory, including FPSCR
+ * Assumes the caller has enabled FP in the MSR.
+ */
+_GLOBAL(store_fp_state)
+        SAVE_32FPVSRS(0, R4, R3)
+        mffs    fr0
+        stfd    fr0,FPSTATE_FPSCR(r3)
+        blr
+
+/*
  * This task wants to use the FPU now.
  * On UP, disable FP for the task which had the FPU previously,
  * and save its floating-point registers in its thread_struct.
@@ -147,9 +131,10 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX)
         beq     1f
         toreal(r4)
         addi    r4,r4,THREAD            /* want last_task_used_math->thread */
-        SAVE_32FPVSRS(0, R5, R4)
+        addi    r8,r4,THREAD_FPSTATE
+        SAVE_32FPVSRS(0, R5, R8)
         mffs    fr0
-        stfd    fr0,THREAD_FPSCR(r4)
+        stfd    fr0,FPSTATE_FPSCR(r8)
         PPC_LL  r5,PT_REGS(r4)
         toreal(r5)
         PPC_LL  r4,_MSR-STACK_FRAME_OVERHEAD(r5)
@@ -160,7 +145,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX)
 #endif /* CONFIG_SMP */
         /* enable use of FP after return */
 #ifdef CONFIG_PPC32
-        mfspr   r5,SPRN_SPRG_THREAD             /* current task's THREAD (phys) */
+        mfspr   r5,SPRN_SPRG_THREAD     /* current task's THREAD (phys) */
         lwz     r4,THREAD_FPEXC_MODE(r5)
         ori     r9,r9,MSR_FP            /* enable FP for current */
         or      r9,r9,r4
@@ -172,9 +157,10 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX)
         or      r12,r12,r4
         std     r12,_MSR(r1)
 #endif
-        lfd     fr0,THREAD_FPSCR(r5)
+        addi    r7,r5,THREAD_FPSTATE
+        lfd     fr0,FPSTATE_FPSCR(r7)
         MTFSF_L(fr0)
-        REST_32FPVSRS(0, R4, R5)
+        REST_32FPVSRS(0, R4, R7)
 #ifndef CONFIG_SMP
         subi    r4,r5,THREAD
         fromreal(r4)
@@ -206,11 +192,15 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX)
         PPC_LCMPI       0,r3,0
         beqlr-                          /* if no previous owner, done */
         addi    r3,r3,THREAD            /* want THREAD of task */
+        PPC_LL  r6,THREAD_FPSAVEAREA(r3)
         PPC_LL  r5,PT_REGS(r3)
-        PPC_LCMPI       0,r5,0
-        SAVE_32FPVSRS(0, R4 ,R3)
+        PPC_LCMPI       0,r6,0
+        bne     2f
+        addi    r6,r3,THREAD_FPSTATE
+2:      PPC_LCMPI       0,r5,0
+        SAVE_32FPVSRS(0, R4, R6)
         mffs    fr0
-        stfd    fr0,THREAD_FPSCR(r3)
+        stfd    fr0,FPSTATE_FPSCR(r6)
         beq     1f
         PPC_LL  r4,_MSR-STACK_FRAME_OVERHEAD(r5)
         li      r3,MSR_FP|MSR_FE0|MSR_FE1
diff --git a/arch/powerpc/kernel/ppc_ksyms.c b/arch/powerpc/kernel/ppc_ksyms.c
index d8c34073b42a..3bd77edd7610 100644
--- a/arch/powerpc/kernel/ppc_ksyms.c
+++ b/arch/powerpc/kernel/ppc_ksyms.c
@@ -100,9 +100,13 @@ EXPORT_SYMBOL(start_thread);
 
 #ifdef CONFIG_PPC_FPU
 EXPORT_SYMBOL(giveup_fpu);
+EXPORT_SYMBOL(load_fp_state);
+EXPORT_SYMBOL(store_fp_state);
 #endif
 #ifdef CONFIG_ALTIVEC
 EXPORT_SYMBOL(giveup_altivec);
+EXPORT_SYMBOL(load_vr_state);
+EXPORT_SYMBOL(store_vr_state);
 #endif /* CONFIG_ALTIVEC */
 #ifdef CONFIG_VSX
 EXPORT_SYMBOL(giveup_vsx);
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 96d2fdf3aa9e..8649a3d629e1 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -1008,6 +1008,11 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
         p->thread.ptrace_bps[0] = NULL;
 #endif
 
+        p->thread.fp_save_area = NULL;
+#ifdef CONFIG_ALTIVEC
+        p->thread.vr_save_area = NULL;
+#endif
+
 #ifdef CONFIG_PPC_STD_MMU_64
         if (mmu_has_feature(MMU_FTR_SLB)) {
                 unsigned long sp_vsid;
@@ -1113,12 +1118,12 @@ void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp)
 #ifdef CONFIG_VSX
         current->thread.used_vsr = 0;
 #endif
-        memset(current->thread.fpr, 0, sizeof(current->thread.fpr));
-        current->thread.fpscr.val = 0;
+        memset(&current->thread.fp_state, 0, sizeof(current->thread.fp_state));
+        current->thread.fp_save_area = NULL;
 #ifdef CONFIG_ALTIVEC
-        memset(current->thread.vr, 0, sizeof(current->thread.vr));
-        memset(&current->thread.vscr, 0, sizeof(current->thread.vscr));
-        current->thread.vscr.u[3] = 0x00010000; /* Java mode disabled */
+        memset(&current->thread.vr_state, 0, sizeof(current->thread.vr_state));
+        current->thread.vr_state.vscr.u[3] = 0x00010000; /* Java mode disabled */
+        current->thread.vr_save_area = NULL;
         current->thread.vrsave = 0;
         current->thread.used_vr = 0;
 #endif /* CONFIG_ALTIVEC */
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 8d5d4e921a5e..1ca589c9ec6d 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -362,7 +362,7 @@ static int fpr_get(struct task_struct *target, const struct user_regset *regset,
                    void *kbuf, void __user *ubuf)
 {
 #ifdef CONFIG_VSX
-        double buf[33];
+        u64 buf[33];
         int i;
 #endif
         flush_fp_to_thread(target);
@@ -371,15 +371,15 @@ static int fpr_get(struct task_struct *target, const struct user_regset *regset,
         /* copy to local buffer then write that out */
         for (i = 0; i < 32 ; i++)
                 buf[i] = target->thread.TS_FPR(i);
-        memcpy(&buf[32], &target->thread.fpscr, sizeof(double));
+        buf[32] = target->thread.fp_state.fpscr;
         return user_regset_copyout(&pos, &count, &kbuf, &ubuf, buf, 0, -1);
 
 #else
-        BUILD_BUG_ON(offsetof(struct thread_struct, fpscr) !=
-                     offsetof(struct thread_struct, TS_FPR(32)));
+        BUILD_BUG_ON(offsetof(struct thread_fp_state, fpscr) !=
+                     offsetof(struct thread_fp_state, fpr[32][0]));
 
         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
-                                   &target->thread.fpr, 0, -1);
+                                   &target->thread.fp_state, 0, -1);
 #endif
 }
 
@@ -388,7 +388,7 @@ static int fpr_set(struct task_struct *target, const struct user_regset *regset,
                    const void *kbuf, const void __user *ubuf)
 {
 #ifdef CONFIG_VSX
-        double buf[33];
+        u64 buf[33];
         int i;
 #endif
         flush_fp_to_thread(target);
@@ -400,14 +400,14 @@ static int fpr_set(struct task_struct *target, const struct user_regset *regset,
                 return i;
         for (i = 0; i < 32 ; i++)
                 target->thread.TS_FPR(i) = buf[i];
-        memcpy(&target->thread.fpscr, &buf[32], sizeof(double));
+        target->thread.fp_state.fpscr = buf[32];
         return 0;
 #else
-        BUILD_BUG_ON(offsetof(struct thread_struct, fpscr) !=
-                     offsetof(struct thread_struct, TS_FPR(32)));
+        BUILD_BUG_ON(offsetof(struct thread_fp_state, fpscr) !=
+                     offsetof(struct thread_fp_state, fpr[32][0]));
 
         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
-                                  &target->thread.fpr, 0, -1);
+                                  &target->thread.fp_state, 0, -1);
 #endif
 }
 
@@ -440,11 +440,11 @@ static int vr_get(struct task_struct *target, const struct user_regset *regset,
 
         flush_altivec_to_thread(target);
 
-        BUILD_BUG_ON(offsetof(struct thread_struct, vscr) !=
-                     offsetof(struct thread_struct, vr[32]));
+        BUILD_BUG_ON(offsetof(struct thread_vr_state, vscr) !=
+                     offsetof(struct thread_vr_state, vr[32]));
 
         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
-                                  &target->thread.vr, 0,
+                                  &target->thread.vr_state, 0,
                                   33 * sizeof(vector128));
         if (!ret) {
                 /*
@@ -471,11 +471,12 @@ static int vr_set(struct task_struct *target, const struct user_regset *regset,
 
         flush_altivec_to_thread(target);
 
-        BUILD_BUG_ON(offsetof(struct thread_struct, vscr) !=
-                     offsetof(struct thread_struct, vr[32]));
+        BUILD_BUG_ON(offsetof(struct thread_vr_state, vscr) !=
+                     offsetof(struct thread_vr_state, vr[32]));
 
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
-                                 &target->thread.vr, 0, 33 * sizeof(vector128));
+                                 &target->thread.vr_state, 0,
+                                 33 * sizeof(vector128));
         if (!ret && count > 0) {
                 /*
                  * We use only the first word of vrsave.
@@ -514,13 +515,13 @@ static int vsr_get(struct task_struct *target, const struct user_regset *regset,
                    unsigned int pos, unsigned int count,
                    void *kbuf, void __user *ubuf)
 {
-        double buf[32];
+        u64 buf[32];
         int ret, i;
 
         flush_vsx_to_thread(target);
 
         for (i = 0; i < 32 ; i++)
-                buf[i] = target->thread.fpr[i][TS_VSRLOWOFFSET];
+                buf[i] = target->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
                                   buf, 0, 32 * sizeof(double));
 
@@ -531,7 +532,7 @@ static int vsr_set(struct task_struct *target, const struct user_regset *regset,
                    unsigned int pos, unsigned int count,
                    const void *kbuf, const void __user *ubuf)
 {
-        double buf[32];
+        u64 buf[32];
         int ret,i;
 
         flush_vsx_to_thread(target);
@@ -539,7 +540,7 @@ static int vsr_set(struct task_struct *target, const struct user_regset *regset,
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                                  buf, 0, 32 * sizeof(double));
         for (i = 0; i < 32 ; i++)
-                target->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
+                target->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
 
 
         return ret;
@@ -1554,10 +1555,10 @@ long arch_ptrace(struct task_struct *child, long request,
 
                         flush_fp_to_thread(child);
                         if (fpidx < (PT_FPSCR - PT_FPR0))
-                                memcpy(&tmp, &child->thread.TS_FPR(fpidx),
+                                memcpy(&tmp, &child->thread.fp_state.fpr,
                                        sizeof(long));
                         else
-                                tmp = child->thread.fpscr.val;
+                                tmp = child->thread.fp_state.fpscr;
                 }
                 ret = put_user(tmp, datalp);
                 break;
@@ -1587,10 +1588,10 @@ long arch_ptrace(struct task_struct *child, long request,
 
                         flush_fp_to_thread(child);
                         if (fpidx < (PT_FPSCR - PT_FPR0))
-                                memcpy(&child->thread.TS_FPR(fpidx), &data,
+                                memcpy(&child->thread.fp_state.fpr, &data,
                                        sizeof(long));
                         else
-                                child->thread.fpscr.val = data;
+                                child->thread.fp_state.fpscr = data;
                         ret = 0;
                 }
                 break;
diff --git a/arch/powerpc/kernel/ptrace32.c b/arch/powerpc/kernel/ptrace32.c
index f51599e941c7..097f8dc426a0 100644
--- a/arch/powerpc/kernel/ptrace32.c
+++ b/arch/powerpc/kernel/ptrace32.c
@@ -43,7 +43,6 @@
 #define FPRNUMBER(i) (((i) - PT_FPR0) >> 1)
 #define FPRHALF(i) (((i) - PT_FPR0) & 1)
 #define FPRINDEX(i) TS_FPRWIDTH * FPRNUMBER(i) * 2 + FPRHALF(i)
-#define FPRINDEX_3264(i) (TS_FPRWIDTH * ((i) - PT_FPR0))
 
 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                         compat_ulong_t caddr, compat_ulong_t cdata)
@@ -105,7 +104,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                          * to be an array of unsigned int (32 bits) - the
                          * index passed in is based on this assumption.
                          */
-                        tmp = ((unsigned int *)child->thread.fpr)
+                        tmp = ((unsigned int *)child->thread.fp_state.fpr)
                                 [FPRINDEX(index)];
                 }
                 ret = put_user((unsigned int)tmp, (u32 __user *)data);
@@ -147,8 +146,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                 if (numReg >= PT_FPR0) {
                         flush_fp_to_thread(child);
                         /* get 64 bit FPR */
-                        tmp = ((u64 *)child->thread.fpr)
-                                [FPRINDEX_3264(numReg)];
+                        tmp = child->thread.fp_state.fpr[numReg - PT_FPR0][0];
                 } else { /* register within PT_REGS struct */
                         unsigned long tmp2;
                         ret = ptrace_get_reg(child, numReg, &tmp2);
@@ -207,7 +205,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                          * to be an array of unsigned int (32 bits) - the
                          * index passed in is based on this assumption.
                          */
-                        ((unsigned int *)child->thread.fpr)
+                        ((unsigned int *)child->thread.fp_state.fpr)
                                 [FPRINDEX(index)] = data;
                         ret = 0;
                 }
@@ -251,8 +249,7 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
                         u64 *tmp;
                         flush_fp_to_thread(child);
                         /* get 64 bit FPR ... */
-                        tmp = &(((u64 *)child->thread.fpr)
-                                [FPRINDEX_3264(numReg)]);
+                        tmp = &child->thread.fp_state.fpr[numReg - PT_FPR0][0];
                         /* ... write the 32 bit part we want */
                         ((u32 *)tmp)[index % 2] = data;
                         ret = 0;
diff --git a/arch/powerpc/kernel/signal_32.c b/arch/powerpc/kernel/signal_32.c
index b386b0be8d02..c094e28b3f10 100644
--- a/arch/powerpc/kernel/signal_32.c
+++ b/arch/powerpc/kernel/signal_32.c
@@ -265,27 +265,27 @@ struct rt_sigframe {
 unsigned long copy_fpr_to_user(void __user *to,
                                struct task_struct *task)
 {
-        double buf[ELF_NFPREG];
+        u64 buf[ELF_NFPREG];
         int i;
 
         /* save FPR copy to local buffer then write to the thread_struct */
         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
                 buf[i] = task->thread.TS_FPR(i);
-        memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
+        buf[i] = task->thread.fp_state.fpscr;
         return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
 }
 
 unsigned long copy_fpr_from_user(struct task_struct *task,
                                  void __user *from)
 {
-        double buf[ELF_NFPREG];
+        u64 buf[ELF_NFPREG];
         int i;
 
         if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
                 return 1;
         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
                 task->thread.TS_FPR(i) = buf[i];
-        memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
+        task->thread.fp_state.fpscr = buf[i];
 
         return 0;
 }
@@ -293,25 +293,25 @@ unsigned long copy_fpr_from_user(struct task_struct *task,
 unsigned long copy_vsx_to_user(void __user *to,
                                struct task_struct *task)
 {
-        double buf[ELF_NVSRHALFREG];
+        u64 buf[ELF_NVSRHALFREG];
         int i;
 
         /* save FPR copy to local buffer then write to the thread_struct */
         for (i = 0; i < ELF_NVSRHALFREG; i++)
-                buf[i] = task->thread.fpr[i][TS_VSRLOWOFFSET];
+                buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
         return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
 }
 
 unsigned long copy_vsx_from_user(struct task_struct *task,
                                  void __user *from)
 {
-        double buf[ELF_NVSRHALFREG];
+        u64 buf[ELF_NVSRHALFREG];
         int i;
 
         if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
                 return 1;
         for (i = 0; i < ELF_NVSRHALFREG ; i++)
-                task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
+                task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
         return 0;
 }
 
@@ -319,27 +319,27 @@ unsigned long copy_vsx_from_user(struct task_struct *task,
 unsigned long copy_transact_fpr_to_user(void __user *to,
                                   struct task_struct *task)
 {
-        double buf[ELF_NFPREG];
+        u64 buf[ELF_NFPREG];
         int i;
 
         /* save FPR copy to local buffer then write to the thread_struct */
         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
                 buf[i] = task->thread.TS_TRANS_FPR(i);
-        memcpy(&buf[i], &task->thread.transact_fpscr, sizeof(double));
+        buf[i] = task->thread.transact_fp.fpscr;
         return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
 }
 
 unsigned long copy_transact_fpr_from_user(struct task_struct *task,
                                           void __user *from)
 {
-        double buf[ELF_NFPREG];
+        u64 buf[ELF_NFPREG];
         int i;
 
         if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
                 return 1;
         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
                 task->thread.TS_TRANS_FPR(i) = buf[i];
-        memcpy(&task->thread.transact_fpscr, &buf[i], sizeof(double));
+        task->thread.transact_fp.fpscr = buf[i];
 
         return 0;
 }
@@ -347,25 +347,25 @@ unsigned long copy_transact_fpr_from_user(struct task_struct *task,
 unsigned long copy_transact_vsx_to_user(void __user *to,
                                   struct task_struct *task)
 {
-        double buf[ELF_NVSRHALFREG];
+        u64 buf[ELF_NVSRHALFREG];
         int i;
 
         /* save FPR copy to local buffer then write to the thread_struct */
         for (i = 0; i < ELF_NVSRHALFREG; i++)
-                buf[i] = task->thread.transact_fpr[i][TS_VSRLOWOFFSET];
+                buf[i] = task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET];
         return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
 }
 
 unsigned long copy_transact_vsx_from_user(struct task_struct *task,
                                           void __user *from)
 {
-        double buf[ELF_NVSRHALFREG];
+        u64 buf[ELF_NVSRHALFREG];
         int i;
 
         if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
                 return 1;
         for (i = 0; i < ELF_NVSRHALFREG ; i++)
-                task->thread.transact_fpr[i][TS_VSRLOWOFFSET] = buf[i];
+                task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = buf[i];
         return 0;
 }
 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
@@ -373,14 +373,14 @@ unsigned long copy_transact_vsx_from_user(struct task_struct *task,
 inline unsigned long copy_fpr_to_user(void __user *to,
                                       struct task_struct *task)
 {
-        return __copy_to_user(to, task->thread.fpr,
+        return __copy_to_user(to, task->thread.fp_state.fpr,
                               ELF_NFPREG * sizeof(double));
 }
 
 inline unsigned long copy_fpr_from_user(struct task_struct *task,
                                         void __user *from)
 {
-        return __copy_from_user(task->thread.fpr, from,
+        return __copy_from_user(task->thread.fp_state.fpr, from,
                               ELF_NFPREG * sizeof(double));
 }
 
@@ -388,14 +388,14 @@ inline unsigned long copy_fpr_from_user(struct task_struct *task,
 inline unsigned long copy_transact_fpr_to_user(void __user *to,
                                          struct task_struct *task)
 {
-        return __copy_to_user(to, task->thread.transact_fpr,
+        return __copy_to_user(to, task->thread.transact_fp.fpr,
                               ELF_NFPREG * sizeof(double));
 }
 
 inline unsigned long copy_transact_fpr_from_user(struct task_struct *task,
                                                  void __user *from)
 {
-        return __copy_from_user(task->thread.transact_fpr, from,
+        return __copy_from_user(task->thread.transact_fp.fpr, from,
                                 ELF_NFPREG * sizeof(double));
 }
 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
@@ -423,7 +423,7 @@ static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
         /* save altivec registers */
         if (current->thread.used_vr) {
                 flush_altivec_to_thread(current);
-                if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
+                if (__copy_to_user(&frame->mc_vregs, &current->thread.vr_state,
                                    ELF_NVRREG * sizeof(vector128)))
                         return 1;
                 /* set MSR_VEC in the saved MSR value to indicate that
@@ -534,17 +534,17 @@ static int save_tm_user_regs(struct pt_regs *regs,
         /* save altivec registers */
         if (current->thread.used_vr) {
                 flush_altivec_to_thread(current);
-                if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
+                if (__copy_to_user(&frame->mc_vregs, &current->thread.vr_state,
                                    ELF_NVRREG * sizeof(vector128)))
                         return 1;
                 if (msr & MSR_VEC) {
                         if (__copy_to_user(&tm_frame->mc_vregs,
-                                           current->thread.transact_vr,
+                                           &current->thread.transact_vr,
                                            ELF_NVRREG * sizeof(vector128)))
                                 return 1;
                 } else {
                         if (__copy_to_user(&tm_frame->mc_vregs,
-                                           current->thread.vr,
+                                           &current->thread.vr_state,
                                            ELF_NVRREG * sizeof(vector128)))
                                 return 1;
                 }
@@ -692,11 +692,12 @@ static long restore_user_regs(struct pt_regs *regs,
         regs->msr &= ~MSR_VEC;
         if (msr & MSR_VEC) {
                 /* restore altivec registers from the stack */
-                if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
+                if (__copy_from_user(&current->thread.vr_state, &sr->mc_vregs,
                                      sizeof(sr->mc_vregs)))
                         return 1;
         } else if (current->thread.used_vr)
-                memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
+                memset(&current->thread.vr_state, 0,
+                       ELF_NVRREG * sizeof(vector128));
 
         /* Always get VRSAVE back */
         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
@@ -722,7 +723,7 @@ static long restore_user_regs(struct pt_regs *regs,
                         return 1;
         } else if (current->thread.used_vsr)
                 for (i = 0; i < 32 ; i++)
-                        current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
+                        current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
 #endif /* CONFIG_VSX */
         /*
          * force the process to reload the FP registers from
@@ -798,15 +799,16 @@ static long restore_tm_user_regs(struct pt_regs *regs,
         regs->msr &= ~MSR_VEC;
         if (msr & MSR_VEC) {
                 /* restore altivec registers from the stack */
-                if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
+                if (__copy_from_user(&current->thread.vr_state, &sr->mc_vregs,
                                      sizeof(sr->mc_vregs)) ||
-                    __copy_from_user(current->thread.transact_vr,
+                    __copy_from_user(&current->thread.transact_vr,
                                      &tm_sr->mc_vregs,
                                      sizeof(sr->mc_vregs)))
                         return 1;
         } else if (current->thread.used_vr) {
-                memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
-                memset(current->thread.transact_vr, 0,
+                memset(&current->thread.vr_state, 0,
+                       ELF_NVRREG * sizeof(vector128));
+                memset(&current->thread.transact_vr, 0,
                        ELF_NVRREG * sizeof(vector128));
         }
 
@@ -838,8 +840,8 @@ static long restore_tm_user_regs(struct pt_regs *regs,
                         return 1;
         } else if (current->thread.used_vsr)
                 for (i = 0; i < 32 ; i++) {
-                        current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
-                        current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
+                        current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
+                        current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0;
                 }
 #endif /* CONFIG_VSX */
 
@@ -1030,7 +1032,7 @@ int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
                 if (__put_user(0, &rt_sf->uc.uc_link))
                         goto badframe;
 
-        current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
+        current->thread.fp_state.fpscr = 0;     /* turn off all fp exceptions */
 
         /* create a stack frame for the caller of the handler */
         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
@@ -1463,7 +1465,7 @@ int handle_signal32(unsigned long sig, struct k_sigaction *ka,
 
         regs->link = tramp;
 
-        current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
+        current->thread.fp_state.fpscr = 0;     /* turn off all fp exceptions */
 
         /* create a stack frame for the caller of the handler */
         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
diff --git a/arch/powerpc/kernel/signal_64.c b/arch/powerpc/kernel/signal_64.c
index 8b51b0278106..b3c615764c9b 100644
--- a/arch/powerpc/kernel/signal_64.c
+++ b/arch/powerpc/kernel/signal_64.c
@@ -103,7 +103,8 @@ static long setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
         if (current->thread.used_vr) {
                 flush_altivec_to_thread(current);
                 /* Copy 33 vec registers (vr0..31 and vscr) to the stack */
-                err |= __copy_to_user(v_regs, current->thread.vr, 33 * sizeof(vector128));
+                err |= __copy_to_user(v_regs, &current->thread.vr_state,
+                                      33 * sizeof(vector128));
                 /* set MSR_VEC in the MSR value in the frame to indicate that sc->v_reg)
                  * contains valid data.
                  */
@@ -195,18 +196,18 @@ static long setup_tm_sigcontexts(struct sigcontext __user *sc,
         if (current->thread.used_vr) {
                 flush_altivec_to_thread(current);
                 /* Copy 33 vec registers (vr0..31 and vscr) to the stack */
-                err |= __copy_to_user(v_regs, current->thread.vr,
+                err |= __copy_to_user(v_regs, &current->thread.vr_state,
                                       33 * sizeof(vector128));
                 /* If VEC was enabled there are transactional VRs valid too,
                  * else they're a copy of the checkpointed VRs.
                  */
                 if (msr & MSR_VEC)
                         err |= __copy_to_user(tm_v_regs,
-                                              current->thread.transact_vr,
+                                              &current->thread.transact_vr,
                                               33 * sizeof(vector128));
                 else
                         err |= __copy_to_user(tm_v_regs,
-                                              current->thread.vr,
+                                              &current->thread.vr_state,
                                               33 * sizeof(vector128));
 
                 /* set MSR_VEC in the MSR value in the frame to indicate
@@ -349,10 +350,10 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
                 return -EFAULT;
         /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
         if (v_regs != NULL && (msr & MSR_VEC) != 0)
-                err |= __copy_from_user(current->thread.vr, v_regs,
+                err |= __copy_from_user(&current->thread.vr_state, v_regs,
                                         33 * sizeof(vector128));
         else if (current->thread.used_vr)
-                memset(current->thread.vr, 0, 33 * sizeof(vector128));
+                memset(&current->thread.vr_state, 0, 33 * sizeof(vector128));
         /* Always get VRSAVE back */
         if (v_regs != NULL)
                 err |= __get_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
@@ -374,7 +375,7 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
                 err |= copy_vsx_from_user(current, v_regs);
         else
                 for (i = 0; i < 32 ; i++)
-                        current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
+                        current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
 #endif
         return err;
 }
@@ -468,14 +469,14 @@ static long restore_tm_sigcontexts(struct pt_regs *regs,
                 return -EFAULT;
         /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
         if (v_regs != NULL && tm_v_regs != NULL && (msr & MSR_VEC) != 0) {
-                err |= __copy_from_user(current->thread.vr, v_regs,
+                err |= __copy_from_user(&current->thread.vr_state, v_regs,
                                         33 * sizeof(vector128));
-                err |= __copy_from_user(current->thread.transact_vr, tm_v_regs,
+                err |= __copy_from_user(&current->thread.transact_vr, tm_v_regs,
                                         33 * sizeof(vector128));
         }
         else if (current->thread.used_vr) {
-                memset(current->thread.vr, 0, 33 * sizeof(vector128));
-                memset(current->thread.transact_vr, 0, 33 * sizeof(vector128));
+                memset(&current->thread.vr_state, 0, 33 * sizeof(vector128));
+                memset(&current->thread.transact_vr, 0, 33 * sizeof(vector128));
         }
         /* Always get VRSAVE back */
         if (v_regs != NULL && tm_v_regs != NULL) {
@@ -507,8 +508,8 @@ static long restore_tm_sigcontexts(struct pt_regs *regs,
                 err |= copy_transact_vsx_from_user(current, tm_v_regs);
         } else {
                 for (i = 0; i < 32 ; i++) {
-                        current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
-                        current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
+                        current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
+                        current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0;
                 }
         }
 #endif
@@ -747,7 +748,7 @@ int handle_rt_signal64(int signr, struct k_sigaction *ka, siginfo_t *info,
                 goto badframe;
 
         /* Make sure signal handler doesn't get spurious FP exceptions */
-        current->thread.fpscr.val = 0;
+        current->thread.fp_state.fpscr = 0;
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
         /* Remove TM bits from thread's MSR.  The MSR in the sigcontext
          * just indicates to userland that we were doing a transaction, but we
diff --git a/arch/powerpc/kernel/tm.S b/arch/powerpc/kernel/tm.S
index cd809eaa8b5c..761af4f0a632 100644
--- a/arch/powerpc/kernel/tm.S
+++ b/arch/powerpc/kernel/tm.S
@@ -12,16 +12,15 @@
 #include <asm/reg.h>
 
 #ifdef CONFIG_VSX
-/* See fpu.S, this is very similar but to save/restore checkpointed FPRs/VSRs */
-#define __SAVE_32FPRS_VSRS_TRANSACT(n,c,base)   \
+/* See fpu.S, this is borrowed from there */
+#define __SAVE_32FPRS_VSRS(n,c,base)            \
 BEGIN_FTR_SECTION                               \
         b       2f;                             \
 END_FTR_SECTION_IFSET(CPU_FTR_VSX);             \
-        SAVE_32FPRS_TRANSACT(n,base);           \
+        SAVE_32FPRS(n,base);                    \
         b       3f;                             \
-2:      SAVE_32VSRS_TRANSACT(n,c,base);         \
+2:      SAVE_32VSRS(n,c,base);                  \
 3:
-/* ...and this is just plain borrowed from there. */
 #define __REST_32FPRS_VSRS(n,c,base)            \
 BEGIN_FTR_SECTION                               \
         b       2f;                             \
@@ -31,11 +30,11 @@ END_FTR_SECTION_IFSET(CPU_FTR_VSX);		\
 2:      REST_32VSRS(n,c,base);                  \
 3:
 #else
-#define __SAVE_32FPRS_VSRS_TRANSACT(n,c,base) SAVE_32FPRS_TRANSACT(n, base)
-#define __REST_32FPRS_VSRS(n,c,base)          REST_32FPRS(n, base)
+#define __SAVE_32FPRS_VSRS(n,c,base)    SAVE_32FPRS(n, base)
+#define __REST_32FPRS_VSRS(n,c,base)    REST_32FPRS(n, base)
 #endif
-#define SAVE_32FPRS_VSRS_TRANSACT(n,c,base) \
-        __SAVE_32FPRS_VSRS_TRANSACT(n,__REG_##c,__REG_##base)
+#define SAVE_32FPRS_VSRS(n,c,base) \
+        __SAVE_32FPRS_VSRS(n,__REG_##c,__REG_##base)
 #define REST_32FPRS_VSRS(n,c,base) \
         __REST_32FPRS_VSRS(n,__REG_##c,__REG_##base)
 
@@ -157,10 +156,11 @@ _GLOBAL(tm_reclaim)
         andis.          r0, r4, MSR_VEC@h
         beq     dont_backup_vec
 
-        SAVE_32VRS_TRANSACT(0, r6, r3)  /* r6 scratch, r3 thread */
+        addi    r7, r3, THREAD_TRANSACT_VRSTATE
+        SAVE_32VRS(0, r6, r7)   /* r6 scratch, r7 transact vr state */
         mfvscr  vr0
-        li      r6, THREAD_TRANSACT_VSCR
-        stvx    vr0, r3, r6
+        li      r6, VRSTATE_VSCR
+        stvx    vr0, r7, r6
 dont_backup_vec:
         mfspr   r0, SPRN_VRSAVE
         std     r0, THREAD_TRANSACT_VRSAVE(r3)
@@ -168,10 +168,11 @@ dont_backup_vec:
         andi.   r0, r4, MSR_FP
         beq     dont_backup_fp
 
-        SAVE_32FPRS_VSRS_TRANSACT(0, R6, R3)    /* r6 scratch, r3 thread */
+        addi    r7, r3, THREAD_TRANSACT_FPSTATE
+        SAVE_32FPRS_VSRS(0, R6, R7)     /* r6 scratch, r7 transact fp state */
 
         mffs    fr0
-        stfd    fr0,THREAD_TRANSACT_FPSCR(r3)
+        stfd    fr0,FPSTATE_FPSCR(r7)
 
 dont_backup_fp:
         /* The moment we treclaim, ALL of our GPRs will switch
@@ -358,10 +359,11 @@ _GLOBAL(tm_recheckpoint)
         andis.  r0, r4, MSR_VEC@h
         beq     dont_restore_vec
 
-        li      r5, THREAD_VSCR
-        lvx     vr0, r3, r5
+        addi    r8, r3, THREAD_VRSTATE
+        li      r5, VRSTATE_VSCR
+        lvx     vr0, r8, r5
         mtvscr  vr0
-        REST_32VRS(0, r5, r3)                   /* r5 scratch, r3 THREAD ptr */
+        REST_32VRS(0, r5, r8)                   /* r5 scratch, r8 ptr */
 dont_restore_vec:
         ld      r5, THREAD_VRSAVE(r3)
         mtspr   SPRN_VRSAVE, r5
@@ -370,9 +372,10 @@ dont_restore_vec:
         andi.   r0, r4, MSR_FP
         beq     dont_restore_fp
 
-        lfd     fr0, THREAD_FPSCR(r3)
+        addi    r8, r3, THREAD_FPSTATE
+        lfd     fr0, FPSTATE_FPSCR(r8)
         MTFSF_L(fr0)
-        REST_32FPRS_VSRS(0, R4, R3)
+        REST_32FPRS_VSRS(0, R4, R8)
 
 dont_restore_fp:
         mtmsr   r6                              /* FP/Vec off again! */
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index f783c932faeb..f0a6814007a5 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -816,7 +816,7 @@ static void parse_fpe(struct pt_regs *regs)
 
         flush_fp_to_thread(current);
 
-        code = __parse_fpscr(current->thread.fpscr.val);
+        code = __parse_fpscr(current->thread.fp_state.fpscr);
 
         _exception(SIGFPE, regs, code, regs->nip);
 }
@@ -1069,7 +1069,7 @@ static int emulate_math(struct pt_regs *regs)
                 return 0;
         case 1: {
                         int code = 0;
-                        code = __parse_fpscr(current->thread.fpscr.val);
+                        code = __parse_fpscr(current->thread.fp_state.fpscr);
                         _exception(SIGFPE, regs, code, regs->nip);
                         return 0;
                 }
@@ -1371,8 +1371,6 @@ void facility_unavailable_exception(struct pt_regs *regs)
 
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 
-extern void do_load_up_fpu(struct pt_regs *regs);
-
 void fp_unavailable_tm(struct pt_regs *regs)
 {
         /* Note:  This does not handle any kind of FP laziness. */
@@ -1403,8 +1401,6 @@ void fp_unavailable_tm(struct pt_regs *regs)
 }
 
 #ifdef CONFIG_ALTIVEC
-extern void do_load_up_altivec(struct pt_regs *regs);
-
 void altivec_unavailable_tm(struct pt_regs *regs)
 {
         /* See the comments in fp_unavailable_tm().  This function operates
@@ -1634,7 +1630,7 @@ void altivec_assist_exception(struct pt_regs *regs)
                 /* XXX quick hack for now: set the non-Java bit in the VSCR */
                 printk_ratelimited(KERN_ERR "Unrecognized altivec instruction "
                                    "in %s at %lx\n", current->comm, regs->nip);
-                current->thread.vscr.u[3] |= 0x10000;
+                current->thread.vr_state.vscr.u[3] |= 0x10000;
         }
 }
 #endif /* CONFIG_ALTIVEC */
diff --git a/arch/powerpc/kernel/vecemu.c b/arch/powerpc/kernel/vecemu.c
index 604d0947cb20..c4bfadb2606b 100644
--- a/arch/powerpc/kernel/vecemu.c
+++ b/arch/powerpc/kernel/vecemu.c
@@ -271,7 +271,7 @@ int emulate_altivec(struct pt_regs *regs)
         vb = (instr >> 11) & 0x1f;
         vc = (instr >> 6) & 0x1f;
 
-        vrs = current->thread.vr;
+        vrs = current->thread.vr_state.vr;
         switch (instr & 0x3f) {
         case 10:
                 switch (vc) {
@@ -320,12 +320,12 @@ int emulate_altivec(struct pt_regs *regs)
                 case 14:        /* vctuxs */
                         for (i = 0; i < 4; ++i)
                                 vrs[vd].u[i] = ctuxs(vrs[vb].u[i], va,
-                                                &current->thread.vscr.u[3]);
+                                        &current->thread.vr_state.vscr.u[3]);
                         break;
                 case 15:        /* vctsxs */
                         for (i = 0; i < 4; ++i)
                                 vrs[vd].u[i] = ctsxs(vrs[vb].u[i], va,
-                                                &current->thread.vscr.u[3]);
+                                        &current->thread.vr_state.vscr.u[3]);
                         break;
                 default:
                         return -EINVAL;
diff --git a/arch/powerpc/kernel/vector.S b/arch/powerpc/kernel/vector.S
index 9e20999aaef2..eacda4eea2d7 100644
--- a/arch/powerpc/kernel/vector.S
+++ b/arch/powerpc/kernel/vector.S
@@ -8,29 +8,6 @@
 #include <asm/ptrace.h>
 
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
-/*
- * Wrapper to call load_up_altivec from C.
- * void do_load_up_altivec(struct pt_regs *regs);
- */
-_GLOBAL(do_load_up_altivec)
-        mflr    r0
-        std     r0, 16(r1)
-        stdu    r1, -112(r1)
-
-        subi    r6, r3, STACK_FRAME_OVERHEAD
-        /* load_up_altivec expects r12=MSR, r13=PACA, and returns
-         * with r12 = new MSR.
-         */
-        ld      r12,_MSR(r6)
-        GET_PACA(r13)
-        bl      load_up_altivec
-        std     r12,_MSR(r6)
-
-        ld      r0, 112+16(r1)
-        addi    r1, r1, 112
-        mtlr    r0
-        blr
-
 /* void do_load_up_transact_altivec(struct thread_struct *thread)
  *
  * This is similar to load_up_altivec but for the transactional version of the
@@ -46,10 +23,11 @@ _GLOBAL(do_load_up_transact_altivec)
         li      r4,1
         stw     r4,THREAD_USED_VR(r3)
 
-        li      r10,THREAD_TRANSACT_VSCR
+        li      r10,THREAD_TRANSACT_VRSTATE+VRSTATE_VSCR
         lvx     vr0,r10,r3
         mtvscr  vr0
-        REST_32VRS_TRANSACT(0,r4,r3)
+        addi    r10,r3,THREAD_TRANSACT_VRSTATE
+        REST_32VRS(0,r4,r10)
 
         /* Disable VEC again. */
         MTMSRD(r6)
@@ -59,7 +37,28 @@ _GLOBAL(do_load_up_transact_altivec)
 #endif
 
 /*
- * load_up_altivec(unused, unused, tsk)
+ * Load state from memory into VMX registers including VSCR.
+ * Assumes the caller has enabled VMX in the MSR.
+ */
+_GLOBAL(load_vr_state)
+        li      r4,VRSTATE_VSCR
+        lvx     vr0,r4,r3
+        mtvscr  vr0
+        REST_32VRS(0,r4,r3)
+        blr
+
+/*
+ * Store VMX state into memory, including VSCR.
+ * Assumes the caller has enabled VMX in the MSR.
+ */
+_GLOBAL(store_vr_state)
+        SAVE_32VRS(0, r4, r3)
+        mfvscr  vr0
+        li      r4, VRSTATE_VSCR
+        stvx    vr0, r4, r3
+        blr
+
+/*
  * Disable VMX for the task which had it previously,
  * and save its vector registers in its thread_struct.
  * Enables the VMX for use in the kernel on return.
@@ -90,10 +89,11 @@ _GLOBAL(load_up_altivec)
         /* Save VMX state to last_task_used_altivec's THREAD struct */
         toreal(r4)
         addi    r4,r4,THREAD
-        SAVE_32VRS(0,r5,r4)
+        addi    r7,r4,THREAD_VRSTATE
+        SAVE_32VRS(0,r5,r7)
         mfvscr  vr0
-        li      r10,THREAD_VSCR
-        stvx    vr0,r10,r4
+        li      r10,VRSTATE_VSCR
+        stvx    vr0,r10,r7
         /* Disable VMX for last_task_used_altivec */
         PPC_LL  r5,PT_REGS(r4)
         toreal(r5)
@@ -125,12 +125,13 @@ _GLOBAL(load_up_altivec)
         oris    r12,r12,MSR_VEC@h
         std     r12,_MSR(r1)
 #endif
+        addi    r7,r5,THREAD_VRSTATE
         li      r4,1
-        li      r10,THREAD_VSCR
+        li      r10,VRSTATE_VSCR
         stw     r4,THREAD_USED_VR(r5)
-        lvx     vr0,r10,r5
+        lvx     vr0,r10,r7
         mtvscr  vr0
-        REST_32VRS(0,r4,r5)
+        REST_32VRS(0,r4,r7)
 #ifndef CONFIG_SMP
         /* Update last_task_used_altivec to 'current' */
         subi    r4,r5,THREAD            /* Back to 'current' */
@@ -165,12 +166,16 @@ _GLOBAL(giveup_altivec)
         PPC_LCMPI       0,r3,0
         beqlr                           /* if no previous owner, done */
         addi    r3,r3,THREAD            /* want THREAD of task */
+        PPC_LL  r7,THREAD_VRSAVEAREA(r3)
         PPC_LL  r5,PT_REGS(r3)
-        PPC_LCMPI       0,r5,0
-        SAVE_32VRS(0,r4,r3)
+        PPC_LCMPI       0,r7,0
+        bne     2f
+        addi    r7,r3,THREAD_VRSTATE
+2:      PPC_LCMPI       0,r5,0
+        SAVE_32VRS(0,r4,r7)
         mfvscr  vr0
-        li      r4,THREAD_VSCR
-        stvx    vr0,r4,r3
+        li      r4,VRSTATE_VSCR
+        stvx    vr0,r4,r7
         beq     1f
         PPC_LL  r4,_MSR-STACK_FRAME_OVERHEAD(r5)
 #ifdef CONFIG_VSX