Merge tag 'sched-urgent-2020-12-27' of git://git.kernel.org/pub/scm/linux/kernel...

[linux/fpc-iii.git] / arch / powerpc / kernel / ptrace / ptrace-tm.c

// 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]);
}