arch/powerpc/kernel/ptrace/ptrace-tm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <linux/regset.h>
   4
   5 #include <asm/switch_to.h>
   6 #include <asm/tm.h>
   7 #include <asm/asm-prototypes.h>
   8
   9 #include "ptrace-decl.h"
  10
  11 void flush_tmregs_to_thread(struct task_struct *tsk)
  12 {
  13         /*
  14          * If task is not current, it will have been flushed already to
  15          * it's thread_struct during __switch_to().
  16          *
  17          * A reclaim flushes ALL the state or if not in TM save TM SPRs
  18          * in the appropriate thread structures from live.
  19          */
  20
  21         if (!cpu_has_feature(CPU_FTR_TM) || tsk != current)
  22                 return;
  23
  24         if (MSR_TM_SUSPENDED(mfmsr())) {
  25                 tm_reclaim_current(TM_CAUSE_SIGNAL);
  26         } else {
  27                 tm_enable();
  28                 tm_save_sprs(&tsk->thread);
  29         }
  30 }
  31
  32 static unsigned long get_user_ckpt_msr(struct task_struct *task)
  33 {
  34         return task->thread.ckpt_regs.msr | task->thread.fpexc_mode;
  35 }
  36
  37 static int set_user_ckpt_msr(struct task_struct *task, unsigned long msr)
  38 {
  39         task->thread.ckpt_regs.msr &= ~MSR_DEBUGCHANGE;
  40         task->thread.ckpt_regs.msr |= msr & MSR_DEBUGCHANGE;
  41         return 0;
  42 }
  43
  44 static int set_user_ckpt_trap(struct task_struct *task, unsigned long trap)
  45 {
  46         set_trap(&task->thread.ckpt_regs, trap);
  47         return 0;
  48 }
  49
  50 /**
  51  * tm_cgpr_active - get active number of registers in CGPR
  52  * @target:     The target task.
  53  * @regset:     The user regset structure.
  54  *
  55  * This function checks for the active number of available
  56  * regisers in transaction checkpointed GPR category.
  57  */
  58 int tm_cgpr_active(struct task_struct *target, const struct user_regset *regset)
  59 {
  60         if (!cpu_has_feature(CPU_FTR_TM))
  61                 return -ENODEV;
  62
  63         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
  64                 return 0;
  65
  66         return regset->n;
  67 }
  68
  69 /**
  70  * tm_cgpr_get - get CGPR registers
  71  * @target:     The target task.
  72  * @regset:     The user regset structure.
  73  * @to:         Destination of copy.
  74  *
  75  * This function gets transaction checkpointed GPR registers.
  76  *
  77  * When the transaction is active, 'ckpt_regs' holds all the checkpointed
  78  * GPR register values for the current transaction to fall back on if it
  79  * aborts in between. This function gets those checkpointed GPR registers.
  80  * The userspace interface buffer layout is as follows.
  81  *
  82  * struct data {
  83  *      struct pt_regs ckpt_regs;
  84  * };
  85  */
  86 int tm_cgpr_get(struct task_struct *target, const struct user_regset *regset,
  87                 struct membuf to)
  88 {
  89         struct membuf to_msr = membuf_at(&to, offsetof(struct pt_regs, msr));
  90 #ifdef CONFIG_PPC64
  91         struct membuf to_softe = membuf_at(&to, offsetof(struct pt_regs, softe));
  92 #endif
  93
  94         if (!cpu_has_feature(CPU_FTR_TM))
  95                 return -ENODEV;
  96
  97         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
  98                 return -ENODATA;
  99
 100         flush_tmregs_to_thread(target);
 101         flush_fp_to_thread(target);
 102         flush_altivec_to_thread(target);
 103
 104         membuf_write(&to, &target->thread.ckpt_regs, sizeof(struct user_pt_regs));
 105
 106         membuf_store(&to_msr, get_user_ckpt_msr(target));
 107 #ifdef CONFIG_PPC64
 108         membuf_store(&to_softe, 0x1ul);
 109 #endif
 110         return membuf_zero(&to, ELF_NGREG * sizeof(unsigned long) -
 111                         sizeof(struct user_pt_regs));
 112 }
 113
 114 /*
 115  * tm_cgpr_set - set the CGPR registers
 116  * @target:     The target task.
 117  * @regset:     The user regset structure.
 118  * @pos:        The buffer position.
 119  * @count:      Number of bytes to copy.
 120  * @kbuf:       Kernel buffer to copy into.
 121  * @ubuf:       User buffer to copy from.
 122  *
 123  * This function sets in transaction checkpointed GPR registers.
 124  *
 125  * When the transaction is active, 'ckpt_regs' holds the checkpointed
 126  * GPR register values for the current transaction to fall back on if it
 127  * aborts in between. This function sets those checkpointed GPR registers.
 128  * The userspace interface buffer layout is as follows.
 129  *
 130  * struct data {
 131  *      struct pt_regs ckpt_regs;
 132  * };
 133  */
 134 int tm_cgpr_set(struct task_struct *target, const struct user_regset *regset,
 135                 unsigned int pos, unsigned int count,
 136                 const void *kbuf, const void __user *ubuf)
 137 {
 138         unsigned long reg;
 139         int ret;
 140
 141         if (!cpu_has_feature(CPU_FTR_TM))
 142                 return -ENODEV;
 143
 144         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 145                 return -ENODATA;
 146
 147         flush_tmregs_to_thread(target);
 148         flush_fp_to_thread(target);
 149         flush_altivec_to_thread(target);
 150
 151         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 152                                  &target->thread.ckpt_regs,
 153                                  0, PT_MSR * sizeof(reg));
 154
 155         if (!ret && count > 0) {
 156                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
 157                                          PT_MSR * sizeof(reg),
 158                                          (PT_MSR + 1) * sizeof(reg));
 159                 if (!ret)
 160                         ret = set_user_ckpt_msr(target, reg);
 161         }
 162
 163         BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
 164                      offsetof(struct pt_regs, msr) + sizeof(long));
 165
 166         if (!ret)
 167                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 168                                          &target->thread.ckpt_regs.orig_gpr3,
 169                                          PT_ORIG_R3 * sizeof(reg),
 170                                          (PT_MAX_PUT_REG + 1) * sizeof(reg));
 171
 172         if (PT_MAX_PUT_REG + 1 < PT_TRAP && !ret)
 173                 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 174                                           (PT_MAX_PUT_REG + 1) * sizeof(reg),
 175                                           PT_TRAP * sizeof(reg));
 176
 177         if (!ret && count > 0) {
 178                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
 179                                          PT_TRAP * sizeof(reg),
 180                                          (PT_TRAP + 1) * sizeof(reg));
 181                 if (!ret)
 182                         ret = set_user_ckpt_trap(target, reg);
 183         }
 184
 185         if (!ret)
 186                 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 187                                           (PT_TRAP + 1) * sizeof(reg), -1);
 188
 189         return ret;
 190 }
 191
 192 /**
 193  * tm_cfpr_active - get active number of registers in CFPR
 194  * @target:     The target task.
 195  * @regset:     The user regset structure.
 196  *
 197  * This function checks for the active number of available
 198  * regisers in transaction checkpointed FPR category.
 199  */
 200 int tm_cfpr_active(struct task_struct *target, const struct user_regset *regset)
 201 {
 202         if (!cpu_has_feature(CPU_FTR_TM))
 203                 return -ENODEV;
 204
 205         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 206                 return 0;
 207
 208         return regset->n;
 209 }
 210
 211 /**
 212  * tm_cfpr_get - get CFPR registers
 213  * @target:     The target task.
 214  * @regset:     The user regset structure.
 215  * @to:         Destination of copy.
 216  *
 217  * This function gets in transaction checkpointed FPR registers.
 218  *
 219  * When the transaction is active 'ckfp_state' holds the checkpointed
 220  * values for the current transaction to fall back on if it aborts
 221  * in between. This function gets those checkpointed FPR registers.
 222  * The userspace interface buffer layout is as follows.
 223  *
 224  * struct data {
 225  *      u64     fpr[32];
 226  *      u64     fpscr;
 227  *};
 228  */
 229 int tm_cfpr_get(struct task_struct *target, const struct user_regset *regset,
 230                 struct membuf to)
 231 {
 232         u64 buf[33];
 233         int i;
 234
 235         if (!cpu_has_feature(CPU_FTR_TM))
 236                 return -ENODEV;
 237
 238         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 239                 return -ENODATA;
 240
 241         flush_tmregs_to_thread(target);
 242         flush_fp_to_thread(target);
 243         flush_altivec_to_thread(target);
 244
 245         /* copy to local buffer then write that out */
 246         for (i = 0; i < 32 ; i++)
 247                 buf[i] = target->thread.TS_CKFPR(i);
 248         buf[32] = target->thread.ckfp_state.fpscr;
 249         return membuf_write(&to, buf, sizeof(buf));
 250 }
 251
 252 /**
 253  * tm_cfpr_set - set CFPR registers
 254  * @target:     The target task.
 255  * @regset:     The user regset structure.
 256  * @pos:        The buffer position.
 257  * @count:      Number of bytes to copy.
 258  * @kbuf:       Kernel buffer to copy into.
 259  * @ubuf:       User buffer to copy from.
 260  *
 261  * This function sets in transaction checkpointed FPR registers.
 262  *
 263  * When the transaction is active 'ckfp_state' holds the checkpointed
 264  * FPR register values for the current transaction to fall back on
 265  * if it aborts in between. This function sets these checkpointed
 266  * FPR registers. The userspace interface buffer layout is as follows.
 267  *
 268  * struct data {
 269  *      u64     fpr[32];
 270  *      u64     fpscr;
 271  *};
 272  */
 273 int tm_cfpr_set(struct task_struct *target, const struct user_regset *regset,
 274                 unsigned int pos, unsigned int count,
 275                 const void *kbuf, const void __user *ubuf)
 276 {
 277         u64 buf[33];
 278         int i;
 279
 280         if (!cpu_has_feature(CPU_FTR_TM))
 281                 return -ENODEV;
 282
 283         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 284                 return -ENODATA;
 285
 286         flush_tmregs_to_thread(target);
 287         flush_fp_to_thread(target);
 288         flush_altivec_to_thread(target);
 289
 290         for (i = 0; i < 32; i++)
 291                 buf[i] = target->thread.TS_CKFPR(i);
 292         buf[32] = target->thread.ckfp_state.fpscr;
 293
 294         /* copy to local buffer then write that out */
 295         i = user_regset_copyin(&pos, &count, &kbuf, &ubuf, buf, 0, -1);
 296         if (i)
 297                 return i;
 298         for (i = 0; i < 32 ; i++)
 299                 target->thread.TS_CKFPR(i) = buf[i];
 300         target->thread.ckfp_state.fpscr = buf[32];
 301         return 0;
 302 }
 303
 304 /**
 305  * tm_cvmx_active - get active number of registers in CVMX
 306  * @target:     The target task.
 307  * @regset:     The user regset structure.
 308  *
 309  * This function checks for the active number of available
 310  * regisers in checkpointed VMX category.
 311  */
 312 int tm_cvmx_active(struct task_struct *target, const struct user_regset *regset)
 313 {
 314         if (!cpu_has_feature(CPU_FTR_TM))
 315                 return -ENODEV;
 316
 317         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 318                 return 0;
 319
 320         return regset->n;
 321 }
 322
 323 /**
 324  * tm_cvmx_get - get CMVX registers
 325  * @target:     The target task.
 326  * @regset:     The user regset structure.
 327  * @to:         Destination of copy.
 328  *
 329  * This function gets in transaction checkpointed VMX registers.
 330  *
 331  * When the transaction is active 'ckvr_state' and 'ckvrsave' hold
 332  * the checkpointed values for the current transaction to fall
 333  * back on if it aborts in between. The userspace interface buffer
 334  * layout is as follows.
 335  *
 336  * struct data {
 337  *      vector128       vr[32];
 338  *      vector128       vscr;
 339  *      vector128       vrsave;
 340  *};
 341  */
 342 int tm_cvmx_get(struct task_struct *target, const struct user_regset *regset,
 343                 struct membuf to)
 344 {
 345         union {
 346                 elf_vrreg_t reg;
 347                 u32 word;
 348         } vrsave;
 349         BUILD_BUG_ON(TVSO(vscr) != TVSO(vr[32]));
 350
 351         if (!cpu_has_feature(CPU_FTR_TM))
 352                 return -ENODEV;
 353
 354         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 355                 return -ENODATA;
 356
 357         /* Flush the state */
 358         flush_tmregs_to_thread(target);
 359         flush_fp_to_thread(target);
 360         flush_altivec_to_thread(target);
 361
 362         membuf_write(&to, &target->thread.ckvr_state, 33 * sizeof(vector128));
 363         /*
 364          * Copy out only the low-order word of vrsave.
 365          */
 366         memset(&vrsave, 0, sizeof(vrsave));
 367         vrsave.word = target->thread.ckvrsave;
 368         return membuf_write(&to, &vrsave, sizeof(vrsave));
 369 }
 370
 371 /**
 372  * tm_cvmx_set - set CMVX registers
 373  * @target:     The target task.
 374  * @regset:     The user regset structure.
 375  * @pos:        The buffer position.
 376  * @count:      Number of bytes to copy.
 377  * @kbuf:       Kernel buffer to copy into.
 378  * @ubuf:       User buffer to copy from.
 379  *
 380  * This function sets in transaction checkpointed VMX registers.
 381  *
 382  * When the transaction is active 'ckvr_state' and 'ckvrsave' hold
 383  * the checkpointed values for the current transaction to fall
 384  * back on if it aborts in between. The userspace interface buffer
 385  * layout is as follows.
 386  *
 387  * struct data {
 388  *      vector128       vr[32];
 389  *      vector128       vscr;
 390  *      vector128       vrsave;
 391  *};
 392  */
 393 int tm_cvmx_set(struct task_struct *target, const struct user_regset *regset,
 394                 unsigned int pos, unsigned int count,
 395                 const void *kbuf, const void __user *ubuf)
 396 {
 397         int ret;
 398
 399         BUILD_BUG_ON(TVSO(vscr) != TVSO(vr[32]));
 400
 401         if (!cpu_has_feature(CPU_FTR_TM))
 402                 return -ENODEV;
 403
 404         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 405                 return -ENODATA;
 406
 407         flush_tmregs_to_thread(target);
 408         flush_fp_to_thread(target);
 409         flush_altivec_to_thread(target);
 410
 411         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &target->thread.ckvr_state,
 412                                  0, 33 * sizeof(vector128));
 413         if (!ret && count > 0) {
 414                 /*
 415                  * We use only the low-order word of vrsave.
 416                  */
 417                 union {
 418                         elf_vrreg_t reg;
 419                         u32 word;
 420                 } vrsave;
 421                 memset(&vrsave, 0, sizeof(vrsave));
 422                 vrsave.word = target->thread.ckvrsave;
 423                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &vrsave,
 424                                          33 * sizeof(vector128), -1);
 425                 if (!ret)
 426                         target->thread.ckvrsave = vrsave.word;
 427         }
 428
 429         return ret;
 430 }
 431
 432 /**
 433  * tm_cvsx_active - get active number of registers in CVSX
 434  * @target:     The target task.
 435  * @regset:     The user regset structure.
 436  *
 437  * This function checks for the active number of available
 438  * regisers in transaction checkpointed VSX category.
 439  */
 440 int tm_cvsx_active(struct task_struct *target, const struct user_regset *regset)
 441 {
 442         if (!cpu_has_feature(CPU_FTR_TM))
 443                 return -ENODEV;
 444
 445         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 446                 return 0;
 447
 448         flush_vsx_to_thread(target);
 449         return target->thread.used_vsr ? regset->n : 0;
 450 }
 451
 452 /**
 453  * tm_cvsx_get - get CVSX registers
 454  * @target:     The target task.
 455  * @regset:     The user regset structure.
 456  * @to:         Destination of copy.
 457  *
 458  * This function gets in transaction checkpointed VSX registers.
 459  *
 460  * When the transaction is active 'ckfp_state' holds the checkpointed
 461  * values for the current transaction to fall back on if it aborts
 462  * in between. This function gets those checkpointed VSX registers.
 463  * The userspace interface buffer layout is as follows.
 464  *
 465  * struct data {
 466  *      u64     vsx[32];
 467  *};
 468  */
 469 int tm_cvsx_get(struct task_struct *target, const struct user_regset *regset,
 470                 struct membuf to)
 471 {
 472         u64 buf[32];
 473         int i;
 474
 475         if (!cpu_has_feature(CPU_FTR_TM))
 476                 return -ENODEV;
 477
 478         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 479                 return -ENODATA;
 480
 481         /* Flush the state */
 482         flush_tmregs_to_thread(target);
 483         flush_fp_to_thread(target);
 484         flush_altivec_to_thread(target);
 485         flush_vsx_to_thread(target);
 486
 487         for (i = 0; i < 32 ; i++)
 488                 buf[i] = target->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
 489         return membuf_write(&to, buf, 32 * sizeof(double));
 490 }
 491
 492 /**
 493  * tm_cvsx_set - set CFPR registers
 494  * @target:     The target task.
 495  * @regset:     The user regset structure.
 496  * @pos:        The buffer position.
 497  * @count:      Number of bytes to copy.
 498  * @kbuf:       Kernel buffer to copy into.
 499  * @ubuf:       User buffer to copy from.
 500  *
 501  * This function sets in transaction checkpointed VSX registers.
 502  *
 503  * When the transaction is active 'ckfp_state' holds the checkpointed
 504  * VSX register values for the current transaction to fall back on
 505  * if it aborts in between. This function sets these checkpointed
 506  * FPR registers. The userspace interface buffer layout is as follows.
 507  *
 508  * struct data {
 509  *      u64     vsx[32];
 510  *};
 511  */
 512 int tm_cvsx_set(struct task_struct *target, const struct user_regset *regset,
 513                 unsigned int pos, unsigned int count,
 514                 const void *kbuf, const void __user *ubuf)
 515 {
 516         u64 buf[32];
 517         int ret, i;
 518
 519         if (!cpu_has_feature(CPU_FTR_TM))
 520                 return -ENODEV;
 521
 522         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 523                 return -ENODATA;
 524
 525         /* Flush the state */
 526         flush_tmregs_to_thread(target);
 527         flush_fp_to_thread(target);
 528         flush_altivec_to_thread(target);
 529         flush_vsx_to_thread(target);
 530
 531         for (i = 0; i < 32 ; i++)
 532                 buf[i] = target->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
 533
 534         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 535                                  buf, 0, 32 * sizeof(double));
 536         if (!ret)
 537                 for (i = 0; i < 32 ; i++)
 538                         target->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
 539
 540         return ret;
 541 }
 542
 543 /**
 544  * tm_spr_active - get active number of registers in TM SPR
 545  * @target:     The target task.
 546  * @regset:     The user regset structure.
 547  *
 548  * This function checks the active number of available
 549  * regisers in the transactional memory SPR category.
 550  */
 551 int tm_spr_active(struct task_struct *target, const struct user_regset *regset)
 552 {
 553         if (!cpu_has_feature(CPU_FTR_TM))
 554                 return -ENODEV;
 555
 556         return regset->n;
 557 }
 558
 559 /**
 560  * tm_spr_get - get the TM related SPR registers
 561  * @target:     The target task.
 562  * @regset:     The user regset structure.
 563  * @to:         Destination of copy.
 564  *
 565  * This function gets transactional memory related SPR registers.
 566  * The userspace interface buffer layout is as follows.
 567  *
 568  * struct {
 569  *      u64             tm_tfhar;
 570  *      u64             tm_texasr;
 571  *      u64             tm_tfiar;
 572  * };
 573  */
 574 int tm_spr_get(struct task_struct *target, const struct user_regset *regset,
 575                struct membuf to)
 576 {
 577         /* Build tests */
 578         BUILD_BUG_ON(TSO(tm_tfhar) + sizeof(u64) != TSO(tm_texasr));
 579         BUILD_BUG_ON(TSO(tm_texasr) + sizeof(u64) != TSO(tm_tfiar));
 580         BUILD_BUG_ON(TSO(tm_tfiar) + sizeof(u64) != TSO(ckpt_regs));
 581
 582         if (!cpu_has_feature(CPU_FTR_TM))
 583                 return -ENODEV;
 584
 585         /* Flush the states */
 586         flush_tmregs_to_thread(target);
 587         flush_fp_to_thread(target);
 588         flush_altivec_to_thread(target);
 589
 590         /* TFHAR register */
 591         membuf_write(&to, &target->thread.tm_tfhar, sizeof(u64));
 592         /* TEXASR register */
 593         membuf_write(&to, &target->thread.tm_texasr, sizeof(u64));
 594         /* TFIAR register */
 595         return membuf_write(&to, &target->thread.tm_tfiar, sizeof(u64));
 596 }
 597
 598 /**
 599  * tm_spr_set - set the TM related SPR registers
 600  * @target:     The target task.
 601  * @regset:     The user regset structure.
 602  * @pos:        The buffer position.
 603  * @count:      Number of bytes to copy.
 604  * @kbuf:       Kernel buffer to copy into.
 605  * @ubuf:       User buffer to copy from.
 606  *
 607  * This function sets transactional memory related SPR registers.
 608  * The userspace interface buffer layout is as follows.
 609  *
 610  * struct {
 611  *      u64             tm_tfhar;
 612  *      u64             tm_texasr;
 613  *      u64             tm_tfiar;
 614  * };
 615  */
 616 int tm_spr_set(struct task_struct *target, const struct user_regset *regset,
 617                unsigned int pos, unsigned int count,
 618                const void *kbuf, const void __user *ubuf)
 619 {
 620         int ret;
 621
 622         /* Build tests */
 623         BUILD_BUG_ON(TSO(tm_tfhar) + sizeof(u64) != TSO(tm_texasr));
 624         BUILD_BUG_ON(TSO(tm_texasr) + sizeof(u64) != TSO(tm_tfiar));
 625         BUILD_BUG_ON(TSO(tm_tfiar) + sizeof(u64) != TSO(ckpt_regs));
 626
 627         if (!cpu_has_feature(CPU_FTR_TM))
 628                 return -ENODEV;
 629
 630         /* Flush the states */
 631         flush_tmregs_to_thread(target);
 632         flush_fp_to_thread(target);
 633         flush_altivec_to_thread(target);
 634
 635         /* TFHAR register */
 636         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 637                                  &target->thread.tm_tfhar, 0, sizeof(u64));
 638
 639         /* TEXASR register */
 640         if (!ret)
 641                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 642                                          &target->thread.tm_texasr, sizeof(u64),
 643                                          2 * sizeof(u64));
 644
 645         /* TFIAR register */
 646         if (!ret)
 647                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 648                                          &target->thread.tm_tfiar,
 649                                          2 * sizeof(u64), 3 * sizeof(u64));
 650         return ret;
 651 }
 652
 653 int tm_tar_active(struct task_struct *target, const struct user_regset *regset)
 654 {
 655         if (!cpu_has_feature(CPU_FTR_TM))
 656                 return -ENODEV;
 657
 658         if (MSR_TM_ACTIVE(target->thread.regs->msr))
 659                 return regset->n;
 660
 661         return 0;
 662 }
 663
 664 int tm_tar_get(struct task_struct *target, const struct user_regset *regset,
 665                struct membuf to)
 666 {
 667         if (!cpu_has_feature(CPU_FTR_TM))
 668                 return -ENODEV;
 669
 670         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 671                 return -ENODATA;
 672
 673         return membuf_write(&to, &target->thread.tm_tar, sizeof(u64));
 674 }
 675
 676 int tm_tar_set(struct task_struct *target, const struct user_regset *regset,
 677                unsigned int pos, unsigned int count,
 678                const void *kbuf, const void __user *ubuf)
 679 {
 680         int ret;
 681
 682         if (!cpu_has_feature(CPU_FTR_TM))
 683                 return -ENODEV;
 684
 685         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 686                 return -ENODATA;
 687
 688         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 689                                  &target->thread.tm_tar, 0, sizeof(u64));
 690         return ret;
 691 }
 692
 693 int tm_ppr_active(struct task_struct *target, const struct user_regset *regset)
 694 {
 695         if (!cpu_has_feature(CPU_FTR_TM))
 696                 return -ENODEV;
 697
 698         if (MSR_TM_ACTIVE(target->thread.regs->msr))
 699                 return regset->n;
 700
 701         return 0;
 702 }
 703
 704
 705 int tm_ppr_get(struct task_struct *target, const struct user_regset *regset,
 706                struct membuf to)
 707 {
 708         if (!cpu_has_feature(CPU_FTR_TM))
 709                 return -ENODEV;
 710
 711         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 712                 return -ENODATA;
 713
 714         return membuf_write(&to, &target->thread.tm_ppr, sizeof(u64));
 715 }
 716
 717 int tm_ppr_set(struct task_struct *target, const struct user_regset *regset,
 718                unsigned int pos, unsigned int count,
 719                const void *kbuf, const void __user *ubuf)
 720 {
 721         int ret;
 722
 723         if (!cpu_has_feature(CPU_FTR_TM))
 724                 return -ENODEV;
 725
 726         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 727                 return -ENODATA;
 728
 729         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 730                                  &target->thread.tm_ppr, 0, sizeof(u64));
 731         return ret;
 732 }
 733
 734 int tm_dscr_active(struct task_struct *target, const struct user_regset *regset)
 735 {
 736         if (!cpu_has_feature(CPU_FTR_TM))
 737                 return -ENODEV;
 738
 739         if (MSR_TM_ACTIVE(target->thread.regs->msr))
 740                 return regset->n;
 741
 742         return 0;
 743 }
 744
 745 int tm_dscr_get(struct task_struct *target, const struct user_regset *regset,
 746                 struct membuf to)
 747 {
 748         if (!cpu_has_feature(CPU_FTR_TM))
 749                 return -ENODEV;
 750
 751         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 752                 return -ENODATA;
 753
 754         return membuf_write(&to, &target->thread.tm_dscr, sizeof(u64));
 755 }
 756
 757 int tm_dscr_set(struct task_struct *target, const struct user_regset *regset,
 758                 unsigned int pos, unsigned int count,
 759                 const void *kbuf, const void __user *ubuf)
 760 {
 761         int ret;
 762
 763         if (!cpu_has_feature(CPU_FTR_TM))
 764                 return -ENODEV;
 765
 766         if (!MSR_TM_ACTIVE(target->thread.regs->msr))
 767                 return -ENODATA;
 768
 769         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 770                                  &target->thread.tm_dscr, 0, sizeof(u64));
 771         return ret;
 772 }
 773
 774 int tm_cgpr32_get(struct task_struct *target, const struct user_regset *regset,
 775                   struct membuf to)
 776 {
 777         gpr32_get_common(target, regset, to,
 778                                 &target->thread.ckpt_regs.gpr[0]);
 779         return membuf_zero(&to, ELF_NGREG * sizeof(u32));
 780 }
 781
 782 int tm_cgpr32_set(struct task_struct *target, const struct user_regset *regset,
 783                   unsigned int pos, unsigned int count,
 784                   const void *kbuf, const void __user *ubuf)
 785 {
 786         return gpr32_set_common(target, regset, pos, count, kbuf, ubuf,
 787                                 &target->thread.ckpt_regs.gpr[0]);
 788 }