OSCL-LXR linux-6.0.1/​arch/​powerpc/​kernel/​ptrace/​ptrace-tm.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <linux/regset.h>
 
 #include <asm/switch_to.h>
 #include <asm/tm.h>
 #include <asm/asm-prototypes.h>
 
 #include "ptrace-decl.h"
 
 void flush_tmregs_to_thread(struct task_struct *tsk)
 {
     /*
      * If task is not current, it will have been flushed already to
      * it's thread_struct during __switch_to().
      *
      * A reclaim flushes ALL the state or if not in TM save TM SPRs
      * in the appropriate thread structures from live.
      */
 
     if (!cpu_has_feature(CPU_FTR_TM) || tsk != current)
         return;
 
     if (MSR_TM_SUSPENDED(mfmsr())) {
         tm_reclaim_current(TM_CAUSE_SIGNAL);
     } else {
         tm_enable();
         tm_save_sprs(&tsk->thread);
     }
 }
 
 static unsigned long get_user_ckpt_msr(struct task_struct *task)
 {
     return task->thread.ckpt_regs.msr | task->thread.fpexc_mode;
 }
 
 static int set_user_ckpt_msr(struct task_struct *task, unsigned long msr)
 {
     task->thread.ckpt_regs.msr &= ~MSR_DEBUGCHANGE;
     task->thread.ckpt_regs.msr |= msr & MSR_DEBUGCHANGE;
     return 0;
 }
 
 static int set_user_ckpt_trap(struct task_struct *task, unsigned long trap)
 {
     set_trap(&task->thread.ckpt_regs, trap);
     return 0;
 }
 
 /**
  * tm_cgpr_active - get active number of registers in CGPR
  * @target: The target task.
  * @regset: The user regset structure.
  *
  * This function checks for the active number of available
  * regisers in transaction checkpointed GPR category.
  */
 int tm_cgpr_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return 0;
 
     return regset->n;
 }
 
 /**
  * tm_cgpr_get - get CGPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @to:     Destination of copy.
  *
  * This function gets transaction checkpointed GPR registers.
  *
  * When the transaction is active, 'ckpt_regs' holds all the checkpointed
  * GPR register values for the current transaction to fall back on if it
  * aborts in between. This function gets those checkpointed GPR registers.
  * The userspace interface buffer layout is as follows.
  *
  * struct data {
  *  struct pt_regs ckpt_regs;
  * };
  */
 int tm_cgpr_get(struct task_struct *target, const struct user_regset *regset,
         struct membuf to)
 {
     struct membuf to_msr = membuf_at(&to, offsetof(struct pt_regs, msr));
 #ifdef CONFIG_PPC64
     struct membuf to_softe = membuf_at(&to, offsetof(struct pt_regs, softe));
 #endif
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     membuf_write(&to, &target->thread.ckpt_regs, sizeof(struct user_pt_regs));
 
     membuf_store(&to_msr, get_user_ckpt_msr(target));
 #ifdef CONFIG_PPC64
     membuf_store(&to_softe, 0x1ul);
 #endif
     return membuf_zero(&to, ELF_NGREG * sizeof(unsigned long) -
             sizeof(struct user_pt_regs));
 }
 
 /*
  * tm_cgpr_set - set the CGPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @pos:    The buffer position.
  * @count:  Number of bytes to copy.
  * @kbuf:   Kernel buffer to copy into.
  * @ubuf:   User buffer to copy from.
  *
  * This function sets in transaction checkpointed GPR registers.
  *
  * When the transaction is active, 'ckpt_regs' holds the checkpointed
  * GPR register values for the current transaction to fall back on if it
  * aborts in between. This function sets those checkpointed GPR registers.
  * The userspace interface buffer layout is as follows.
  *
  * struct data {
  *  struct pt_regs ckpt_regs;
  * };
  */
 int tm_cgpr_set(struct task_struct *target, const struct user_regset *regset,
         unsigned int pos, unsigned int count,
         const void *kbuf, const void __user *ubuf)
 {
     unsigned long reg;
     int ret;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                  &target->thread.ckpt_regs,
                  0, PT_MSR * sizeof(reg));
 
     if (!ret && count > 0) {
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
                      PT_MSR * sizeof(reg),
                      (PT_MSR + 1) * sizeof(reg));
         if (!ret)
             ret = set_user_ckpt_msr(target, reg);
     }
 
     BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
              offsetof(struct pt_regs, msr) + sizeof(long));
 
     if (!ret)
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                      &target->thread.ckpt_regs.orig_gpr3,
                      PT_ORIG_R3 * sizeof(reg),
                      (PT_MAX_PUT_REG + 1) * sizeof(reg));
 
     if (PT_MAX_PUT_REG + 1 < PT_TRAP && !ret)
         ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
                         (PT_MAX_PUT_REG + 1) * sizeof(reg),
                         PT_TRAP * sizeof(reg));
 
     if (!ret && count > 0) {
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
                      PT_TRAP * sizeof(reg),
                      (PT_TRAP + 1) * sizeof(reg));
         if (!ret)
             ret = set_user_ckpt_trap(target, reg);
     }
 
     if (!ret)
         ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
                         (PT_TRAP + 1) * sizeof(reg), -1);
 
     return ret;
 }
 
 /**
  * tm_cfpr_active - get active number of registers in CFPR
  * @target: The target task.
  * @regset: The user regset structure.
  *
  * This function checks for the active number of available
  * regisers in transaction checkpointed FPR category.
  */
 int tm_cfpr_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return 0;
 
     return regset->n;
 }
 
 /**
  * tm_cfpr_get - get CFPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @to:     Destination of copy.
  *
  * This function gets in transaction checkpointed FPR registers.
  *
  * When the transaction is active 'ckfp_state' holds the checkpointed
  * values for the current transaction to fall back on if it aborts
  * in between. This function gets those checkpointed FPR registers.
  * The userspace interface buffer layout is as follows.
  *
  * struct data {
  *  u64 fpr[32];
  *  u64 fpscr;
  *};
  */
 int tm_cfpr_get(struct task_struct *target, const struct user_regset *regset,
         struct membuf to)
 {
     u64 buf[33];
     int i;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     /* copy to local buffer then write that out */
     for (i = 0; i < 32 ; i++)
         buf[i] = target->thread.TS_CKFPR(i);
     buf[32] = target->thread.ckfp_state.fpscr;
     return membuf_write(&to, buf, sizeof(buf));
 }
 
 /**
  * tm_cfpr_set - set CFPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @pos:    The buffer position.
  * @count:  Number of bytes to copy.
  * @kbuf:   Kernel buffer to copy into.
  * @ubuf:   User buffer to copy from.
  *
  * This function sets in transaction checkpointed FPR registers.
  *
  * When the transaction is active 'ckfp_state' holds the checkpointed
  * FPR register values for the current transaction to fall back on
  * if it aborts in between. This function sets these checkpointed
  * FPR registers. The userspace interface buffer layout is as follows.
  *
  * struct data {
  *  u64 fpr[32];
  *  u64 fpscr;
  *};
  */
 int tm_cfpr_set(struct task_struct *target, const struct user_regset *regset,
         unsigned int pos, unsigned int count,
         const void *kbuf, const void __user *ubuf)
 {
     u64 buf[33];
     int i;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     for (i = 0; i < 32; i++)
         buf[i] = target->thread.TS_CKFPR(i);
     buf[32] = target->thread.ckfp_state.fpscr;
 
     /* copy to local buffer then write that out */
     i = user_regset_copyin(&pos, &count, &kbuf, &ubuf, buf, 0, -1);
     if (i)
         return i;
     for (i = 0; i < 32 ; i++)
         target->thread.TS_CKFPR(i) = buf[i];
     target->thread.ckfp_state.fpscr = buf[32];
     return 0;
 }
 
 /**
  * tm_cvmx_active - get active number of registers in CVMX
  * @target: The target task.
  * @regset: The user regset structure.
  *
  * This function checks for the active number of available
  * regisers in checkpointed VMX category.
  */
 int tm_cvmx_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return 0;
 
     return regset->n;
 }
 
 /**
  * tm_cvmx_get - get CMVX registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @to:     Destination of copy.
  *
  * This function gets in transaction checkpointed VMX registers.
  *
  * When the transaction is active 'ckvr_state' and 'ckvrsave' hold
  * the checkpointed values for the current transaction to fall
  * back on if it aborts in between. The userspace interface buffer
  * layout is as follows.
  *
  * struct data {
  *  vector128   vr[32];
  *  vector128   vscr;
  *  vector128   vrsave;
  *};
  */
 int tm_cvmx_get(struct task_struct *target, const struct user_regset *regset,
         struct membuf to)
 {
     union {
         elf_vrreg_t reg;
         u32 word;
     } vrsave;
     BUILD_BUG_ON(TVSO(vscr) != TVSO(vr[32]));
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     /* Flush the state */
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     membuf_write(&to, &target->thread.ckvr_state, 33 * sizeof(vector128));
     /*
      * Copy out only the low-order word of vrsave.
      */
     memset(&vrsave, 0, sizeof(vrsave));
     vrsave.word = target->thread.ckvrsave;
     return membuf_write(&to, &vrsave, sizeof(vrsave));
 }
 
 /**
  * tm_cvmx_set - set CMVX registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @pos:    The buffer position.
  * @count:  Number of bytes to copy.
  * @kbuf:   Kernel buffer to copy into.
  * @ubuf:   User buffer to copy from.
  *
  * This function sets in transaction checkpointed VMX registers.
  *
  * When the transaction is active 'ckvr_state' and 'ckvrsave' hold
  * the checkpointed values for the current transaction to fall
  * back on if it aborts in between. The userspace interface buffer
  * layout is as follows.
  *
  * struct data {
  *  vector128   vr[32];
  *  vector128   vscr;
  *  vector128   vrsave;
  *};
  */
 int tm_cvmx_set(struct task_struct *target, const struct user_regset *regset,
         unsigned int pos, unsigned int count,
         const void *kbuf, const void __user *ubuf)
 {
     int ret;
 
     BUILD_BUG_ON(TVSO(vscr) != TVSO(vr[32]));
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &target->thread.ckvr_state,
                  0, 33 * sizeof(vector128));
     if (!ret && count > 0) {
         /*
          * We use only the low-order word of vrsave.
          */
         union {
             elf_vrreg_t reg;
             u32 word;
         } vrsave;
         memset(&vrsave, 0, sizeof(vrsave));
         vrsave.word = target->thread.ckvrsave;
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &vrsave,
                      33 * sizeof(vector128), -1);
         if (!ret)
             target->thread.ckvrsave = vrsave.word;
     }
 
     return ret;
 }
 
 /**
  * tm_cvsx_active - get active number of registers in CVSX
  * @target: The target task.
  * @regset: The user regset structure.
  *
  * This function checks for the active number of available
  * regisers in transaction checkpointed VSX category.
  */
 int tm_cvsx_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return 0;
 
     flush_vsx_to_thread(target);
     return target->thread.used_vsr ? regset->n : 0;
 }
 
 /**
  * tm_cvsx_get - get CVSX registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @to:     Destination of copy.
  *
  * This function gets in transaction checkpointed VSX registers.
  *
  * When the transaction is active 'ckfp_state' holds the checkpointed
  * values for the current transaction to fall back on if it aborts
  * in between. This function gets those checkpointed VSX registers.
  * The userspace interface buffer layout is as follows.
  *
  * struct data {
  *  u64 vsx[32];
  *};
  */
 int tm_cvsx_get(struct task_struct *target, const struct user_regset *regset,
         struct membuf to)
 {
     u64 buf[32];
     int i;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     /* Flush the state */
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
     flush_vsx_to_thread(target);
 
     for (i = 0; i < 32 ; i++)
         buf[i] = target->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
     return membuf_write(&to, buf, 32 * sizeof(double));
 }
 
 /**
  * tm_cvsx_set - set CFPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @pos:    The buffer position.
  * @count:  Number of bytes to copy.
  * @kbuf:   Kernel buffer to copy into.
  * @ubuf:   User buffer to copy from.
  *
  * This function sets in transaction checkpointed VSX registers.
  *
  * When the transaction is active 'ckfp_state' holds the checkpointed
  * VSX register values for the current transaction to fall back on
  * if it aborts in between. This function sets these checkpointed
  * FPR registers. The userspace interface buffer layout is as follows.
  *
  * struct data {
  *  u64 vsx[32];
  *};
  */
 int tm_cvsx_set(struct task_struct *target, const struct user_regset *regset,
         unsigned int pos, unsigned int count,
         const void *kbuf, const void __user *ubuf)
 {
     u64 buf[32];
     int ret, i;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     /* Flush the state */
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
     flush_vsx_to_thread(target);
 
     for (i = 0; i < 32 ; i++)
         buf[i] = target->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
 
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                  buf, 0, 32 * sizeof(double));
     if (!ret)
         for (i = 0; i < 32 ; i++)
             target->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
 
     return ret;
 }
 
 /**
  * tm_spr_active - get active number of registers in TM SPR
  * @target: The target task.
  * @regset: The user regset structure.
  *
  * This function checks the active number of available
  * regisers in the transactional memory SPR category.
  */
 int tm_spr_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     return regset->n;
 }
 
 /**
  * tm_spr_get - get the TM related SPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @to:     Destination of copy.
  *
  * This function gets transactional memory related SPR registers.
  * The userspace interface buffer layout is as follows.
  *
  * struct {
  *  u64     tm_tfhar;
  *  u64     tm_texasr;
  *  u64     tm_tfiar;
  * };
  */
 int tm_spr_get(struct task_struct *target, const struct user_regset *regset,
            struct membuf to)
 {
     /* Build tests */
     BUILD_BUG_ON(TSO(tm_tfhar) + sizeof(u64) != TSO(tm_texasr));
     BUILD_BUG_ON(TSO(tm_texasr) + sizeof(u64) != TSO(tm_tfiar));
     BUILD_BUG_ON(TSO(tm_tfiar) + sizeof(u64) != TSO(ckpt_regs));
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     /* Flush the states */
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     /* TFHAR register */
     membuf_write(&to, &target->thread.tm_tfhar, sizeof(u64));
     /* TEXASR register */
     membuf_write(&to, &target->thread.tm_texasr, sizeof(u64));
     /* TFIAR register */
     return membuf_write(&to, &target->thread.tm_tfiar, sizeof(u64));
 }
 
 /**
  * tm_spr_set - set the TM related SPR registers
  * @target: The target task.
  * @regset: The user regset structure.
  * @pos:    The buffer position.
  * @count:  Number of bytes to copy.
  * @kbuf:   Kernel buffer to copy into.
  * @ubuf:   User buffer to copy from.
  *
  * This function sets transactional memory related SPR registers.
  * The userspace interface buffer layout is as follows.
  *
  * struct {
  *  u64     tm_tfhar;
  *  u64     tm_texasr;
  *  u64     tm_tfiar;
  * };
  */
 int tm_spr_set(struct task_struct *target, const struct user_regset *regset,
            unsigned int pos, unsigned int count,
            const void *kbuf, const void __user *ubuf)
 {
     int ret;
 
     /* Build tests */
     BUILD_BUG_ON(TSO(tm_tfhar) + sizeof(u64) != TSO(tm_texasr));
     BUILD_BUG_ON(TSO(tm_texasr) + sizeof(u64) != TSO(tm_tfiar));
     BUILD_BUG_ON(TSO(tm_tfiar) + sizeof(u64) != TSO(ckpt_regs));
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     /* Flush the states */
     flush_tmregs_to_thread(target);
     flush_fp_to_thread(target);
     flush_altivec_to_thread(target);
 
     /* TFHAR register */
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                  &target->thread.tm_tfhar, 0, sizeof(u64));
 
     /* TEXASR register */
     if (!ret)
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                      &target->thread.tm_texasr, sizeof(u64),
                      2 * sizeof(u64));
 
     /* TFIAR register */
     if (!ret)
         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                      &target->thread.tm_tfiar,
                      2 * sizeof(u64), 3 * sizeof(u64));
     return ret;
 }
 
 int tm_tar_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (MSR_TM_ACTIVE(target->thread.regs->msr))
         return regset->n;
 
     return 0;
 }
 
 int tm_tar_get(struct task_struct *target, const struct user_regset *regset,
            struct membuf to)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     return membuf_write(&to, &target->thread.tm_tar, sizeof(u64));
 }
 
 int tm_tar_set(struct task_struct *target, const struct user_regset *regset,
            unsigned int pos, unsigned int count,
            const void *kbuf, const void __user *ubuf)
 {
     int ret;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                  &target->thread.tm_tar, 0, sizeof(u64));
     return ret;
 }
 
 int tm_ppr_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (MSR_TM_ACTIVE(target->thread.regs->msr))
         return regset->n;
 
     return 0;
 }
 
 
 int tm_ppr_get(struct task_struct *target, const struct user_regset *regset,
            struct membuf to)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     return membuf_write(&to, &target->thread.tm_ppr, sizeof(u64));
 }
 
 int tm_ppr_set(struct task_struct *target, const struct user_regset *regset,
            unsigned int pos, unsigned int count,
            const void *kbuf, const void __user *ubuf)
 {
     int ret;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                  &target->thread.tm_ppr, 0, sizeof(u64));
     return ret;
 }
 
 int tm_dscr_active(struct task_struct *target, const struct user_regset *regset)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (MSR_TM_ACTIVE(target->thread.regs->msr))
         return regset->n;
 
     return 0;
 }
 
 int tm_dscr_get(struct task_struct *target, const struct user_regset *regset,
         struct membuf to)
 {
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     return membuf_write(&to, &target->thread.tm_dscr, sizeof(u64));
 }
 
 int tm_dscr_set(struct task_struct *target, const struct user_regset *regset,
         unsigned int pos, unsigned int count,
         const void *kbuf, const void __user *ubuf)
 {
     int ret;
 
     if (!cpu_has_feature(CPU_FTR_TM))
         return -ENODEV;
 
     if (!MSR_TM_ACTIVE(target->thread.regs->msr))
         return -ENODATA;
 
     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                  &target->thread.tm_dscr, 0, sizeof(u64));
     return ret;
 }
 
 int tm_cgpr32_get(struct task_struct *target, const struct user_regset *regset,
           struct membuf to)
 {
     gpr32_get_common(target, regset, to,
                 &target->thread.ckpt_regs.gpr[0]);
     return membuf_zero(&to, ELF_NGREG * sizeof(u32));
 }
 
 int tm_cgpr32_set(struct task_struct *target, const struct user_regset *regset,
           unsigned int pos, unsigned int count,
           const void *kbuf, const void __user *ubuf)
 {
     return gpr32_set_common(target, regset, pos, count, kbuf, ubuf,
                 &target->thread.ckpt_regs.gpr[0]);
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team