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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <linux/regset.h>
   4 #include <linux/elf.h>
   5 #include <linux/nospec.h>
   6 #include <linux/pkeys.h>
   7
   8 #include "ptrace-decl.h"
   9
  10 struct pt_regs_offset {
  11         const char *name;
  12         int offset;
  13 };
  14
  15 #define STR(s)  #s                      /* convert to string */
  16 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
  17 #define GPR_OFFSET_NAME(num)    \
  18         {.name = STR(r##num), .offset = offsetof(struct pt_regs, gpr[num])}, \
  19         {.name = STR(gpr##num), .offset = offsetof(struct pt_regs, gpr[num])}
  20 #define REG_OFFSET_END {.name = NULL, .offset = 0}
  21
  22 static const struct pt_regs_offset regoffset_table[] = {
  23         GPR_OFFSET_NAME(0),
  24         GPR_OFFSET_NAME(1),
  25         GPR_OFFSET_NAME(2),
  26         GPR_OFFSET_NAME(3),
  27         GPR_OFFSET_NAME(4),
  28         GPR_OFFSET_NAME(5),
  29         GPR_OFFSET_NAME(6),
  30         GPR_OFFSET_NAME(7),
  31         GPR_OFFSET_NAME(8),
  32         GPR_OFFSET_NAME(9),
  33         GPR_OFFSET_NAME(10),
  34         GPR_OFFSET_NAME(11),
  35         GPR_OFFSET_NAME(12),
  36         GPR_OFFSET_NAME(13),
  37         GPR_OFFSET_NAME(14),
  38         GPR_OFFSET_NAME(15),
  39         GPR_OFFSET_NAME(16),
  40         GPR_OFFSET_NAME(17),
  41         GPR_OFFSET_NAME(18),
  42         GPR_OFFSET_NAME(19),
  43         GPR_OFFSET_NAME(20),
  44         GPR_OFFSET_NAME(21),
  45         GPR_OFFSET_NAME(22),
  46         GPR_OFFSET_NAME(23),
  47         GPR_OFFSET_NAME(24),
  48         GPR_OFFSET_NAME(25),
  49         GPR_OFFSET_NAME(26),
  50         GPR_OFFSET_NAME(27),
  51         GPR_OFFSET_NAME(28),
  52         GPR_OFFSET_NAME(29),
  53         GPR_OFFSET_NAME(30),
  54         GPR_OFFSET_NAME(31),
  55         REG_OFFSET_NAME(nip),
  56         REG_OFFSET_NAME(msr),
  57         REG_OFFSET_NAME(ctr),
  58         REG_OFFSET_NAME(link),
  59         REG_OFFSET_NAME(xer),
  60         REG_OFFSET_NAME(ccr),
  61 #ifdef CONFIG_PPC64
  62         REG_OFFSET_NAME(softe),
  63 #else
  64         REG_OFFSET_NAME(mq),
  65 #endif
  66         REG_OFFSET_NAME(trap),
  67         REG_OFFSET_NAME(dar),
  68         REG_OFFSET_NAME(dsisr),
  69         REG_OFFSET_END,
  70 };
  71
  72 /**
  73  * regs_query_register_offset() - query register offset from its name
  74  * @name:       the name of a register
  75  *
  76  * regs_query_register_offset() returns the offset of a register in struct
  77  * pt_regs from its name. If the name is invalid, this returns -EINVAL;
  78  */
  79 int regs_query_register_offset(const char *name)
  80 {
  81         const struct pt_regs_offset *roff;
  82         for (roff = regoffset_table; roff->name != NULL; roff++)
  83                 if (!strcmp(roff->name, name))
  84                         return roff->offset;
  85         return -EINVAL;
  86 }
  87
  88 /**
  89  * regs_query_register_name() - query register name from its offset
  90  * @offset:     the offset of a register in struct pt_regs.
  91  *
  92  * regs_query_register_name() returns the name of a register from its
  93  * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
  94  */
  95 const char *regs_query_register_name(unsigned int offset)
  96 {
  97         const struct pt_regs_offset *roff;
  98         for (roff = regoffset_table; roff->name != NULL; roff++)
  99                 if (roff->offset == offset)
 100                         return roff->name;
 101         return NULL;
 102 }
 103
 104 /*
 105  * does not yet catch signals sent when the child dies.
 106  * in exit.c or in signal.c.
 107  */
 108
 109 static unsigned long get_user_msr(struct task_struct *task)
 110 {
 111         return task->thread.regs->msr | task->thread.fpexc_mode;
 112 }
 113
 114 static __always_inline int set_user_msr(struct task_struct *task, unsigned long msr)
 115 {
 116         task->thread.regs->msr &= ~MSR_DEBUGCHANGE;
 117         task->thread.regs->msr |= msr & MSR_DEBUGCHANGE;
 118         return 0;
 119 }
 120
 121 #ifdef CONFIG_PPC64
 122 static int get_user_dscr(struct task_struct *task, unsigned long *data)
 123 {
 124         *data = task->thread.dscr;
 125         return 0;
 126 }
 127
 128 static int set_user_dscr(struct task_struct *task, unsigned long dscr)
 129 {
 130         task->thread.dscr = dscr;
 131         task->thread.dscr_inherit = 1;
 132         return 0;
 133 }
 134 #else
 135 static int get_user_dscr(struct task_struct *task, unsigned long *data)
 136 {
 137         return -EIO;
 138 }
 139
 140 static int set_user_dscr(struct task_struct *task, unsigned long dscr)
 141 {
 142         return -EIO;
 143 }
 144 #endif
 145
 146 /*
 147  * We prevent mucking around with the reserved area of trap
 148  * which are used internally by the kernel.
 149  */
 150 static __always_inline int set_user_trap(struct task_struct *task, unsigned long trap)
 151 {
 152         set_trap(task->thread.regs, trap);
 153         return 0;
 154 }
 155
 156 /*
 157  * Get contents of register REGNO in task TASK.
 158  */
 159 int ptrace_get_reg(struct task_struct *task, int regno, unsigned long *data)
 160 {
 161         unsigned int regs_max;
 162
 163         if (task->thread.regs == NULL || !data)
 164                 return -EIO;
 165
 166         if (regno == PT_MSR) {
 167                 *data = get_user_msr(task);
 168                 return 0;
 169         }
 170
 171         if (regno == PT_DSCR)
 172                 return get_user_dscr(task, data);
 173
 174         /*
 175          * softe copies paca->irq_soft_mask variable state. Since irq_soft_mask is
 176          * no more used as a flag, lets force usr to alway see the softe value as 1
 177          * which means interrupts are not soft disabled.
 178          */
 179         if (IS_ENABLED(CONFIG_PPC64) && regno == PT_SOFTE) {
 180                 *data = 1;
 181                 return  0;
 182         }
 183
 184         regs_max = sizeof(struct user_pt_regs) / sizeof(unsigned long);
 185         if (regno < regs_max) {
 186                 regno = array_index_nospec(regno, regs_max);
 187                 *data = ((unsigned long *)task->thread.regs)[regno];
 188                 return 0;
 189         }
 190
 191         return -EIO;
 192 }
 193
 194 /*
 195  * Write contents of register REGNO in task TASK.
 196  */
 197 int ptrace_put_reg(struct task_struct *task, int regno, unsigned long data)
 198 {
 199         if (task->thread.regs == NULL)
 200                 return -EIO;
 201
 202         if (regno == PT_MSR)
 203                 return set_user_msr(task, data);
 204         if (regno == PT_TRAP)
 205                 return set_user_trap(task, data);
 206         if (regno == PT_DSCR)
 207                 return set_user_dscr(task, data);
 208
 209         if (regno <= PT_MAX_PUT_REG) {
 210                 regno = array_index_nospec(regno, PT_MAX_PUT_REG + 1);
 211                 ((unsigned long *)task->thread.regs)[regno] = data;
 212                 return 0;
 213         }
 214         return -EIO;
 215 }
 216
 217 static int gpr_get(struct task_struct *target, const struct user_regset *regset,
 218                    struct membuf to)
 219 {
 220         struct membuf to_msr = membuf_at(&to, offsetof(struct pt_regs, msr));
 221 #ifdef CONFIG_PPC64
 222         struct membuf to_softe = membuf_at(&to, offsetof(struct pt_regs, softe));
 223 #endif
 224         if (target->thread.regs == NULL)
 225                 return -EIO;
 226
 227         membuf_write(&to, target->thread.regs, sizeof(struct user_pt_regs));
 228
 229         membuf_store(&to_msr, get_user_msr(target));
 230 #ifdef CONFIG_PPC64
 231         membuf_store(&to_softe, 0x1ul);
 232 #endif
 233         return membuf_zero(&to, ELF_NGREG * sizeof(unsigned long) -
 234                                  sizeof(struct user_pt_regs));
 235 }
 236
 237 static int gpr_set(struct task_struct *target, const struct user_regset *regset,
 238                    unsigned int pos, unsigned int count, const void *kbuf,
 239                    const void __user *ubuf)
 240 {
 241         unsigned long reg;
 242         int ret;
 243
 244         if (target->thread.regs == NULL)
 245                 return -EIO;
 246
 247         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 248                                  target->thread.regs,
 249                                  0, PT_MSR * sizeof(reg));
 250
 251         if (!ret && count > 0) {
 252                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
 253                                          PT_MSR * sizeof(reg),
 254                                          (PT_MSR + 1) * sizeof(reg));
 255                 if (!ret)
 256                         ret = set_user_msr(target, reg);
 257         }
 258
 259         BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
 260                      offsetof(struct pt_regs, msr) + sizeof(long));
 261
 262         if (!ret)
 263                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 264                                          &target->thread.regs->orig_gpr3,
 265                                          PT_ORIG_R3 * sizeof(reg),
 266                                          (PT_MAX_PUT_REG + 1) * sizeof(reg));
 267
 268         if (PT_MAX_PUT_REG + 1 < PT_TRAP && !ret)
 269                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 270                                                 (PT_MAX_PUT_REG + 1) * sizeof(reg),
 271                                                 PT_TRAP * sizeof(reg));
 272
 273         if (!ret && count > 0) {
 274                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
 275                                          PT_TRAP * sizeof(reg),
 276                                          (PT_TRAP + 1) * sizeof(reg));
 277                 if (!ret)
 278                         ret = set_user_trap(target, reg);
 279         }
 280
 281         if (!ret)
 282                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 283                                                 (PT_TRAP + 1) * sizeof(reg), -1);
 284
 285         return ret;
 286 }
 287
 288 #ifdef CONFIG_PPC64
 289 static int ppr_get(struct task_struct *target, const struct user_regset *regset,
 290                    struct membuf to)
 291 {
 292         return membuf_write(&to, &target->thread.regs->ppr, sizeof(u64));
 293 }
 294
 295 static int ppr_set(struct task_struct *target, const struct user_regset *regset,
 296                    unsigned int pos, unsigned int count, const void *kbuf,
 297                    const void __user *ubuf)
 298 {
 299         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 300                                   &target->thread.regs->ppr, 0, sizeof(u64));
 301 }
 302
 303 static int dscr_get(struct task_struct *target, const struct user_regset *regset,
 304                     struct membuf to)
 305 {
 306         return membuf_write(&to, &target->thread.dscr, sizeof(u64));
 307 }
 308 static int dscr_set(struct task_struct *target, const struct user_regset *regset,
 309                     unsigned int pos, unsigned int count, const void *kbuf,
 310                     const void __user *ubuf)
 311 {
 312         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 313                                   &target->thread.dscr, 0, sizeof(u64));
 314 }
 315 #endif
 316 #ifdef CONFIG_PPC_BOOK3S_64
 317 static int tar_get(struct task_struct *target, const struct user_regset *regset,
 318                    struct membuf to)
 319 {
 320         return membuf_write(&to, &target->thread.tar, sizeof(u64));
 321 }
 322 static int tar_set(struct task_struct *target, const struct user_regset *regset,
 323                    unsigned int pos, unsigned int count, const void *kbuf,
 324                    const void __user *ubuf)
 325 {
 326         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 327                                   &target->thread.tar, 0, sizeof(u64));
 328 }
 329
 330 static int ebb_active(struct task_struct *target, const struct user_regset *regset)
 331 {
 332         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 333                 return -ENODEV;
 334
 335         if (target->thread.used_ebb)
 336                 return regset->n;
 337
 338         return 0;
 339 }
 340
 341 static int ebb_get(struct task_struct *target, const struct user_regset *regset,
 342                    struct membuf to)
 343 {
 344         /* Build tests */
 345         BUILD_BUG_ON(TSO(ebbrr) + sizeof(unsigned long) != TSO(ebbhr));
 346         BUILD_BUG_ON(TSO(ebbhr) + sizeof(unsigned long) != TSO(bescr));
 347
 348         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 349                 return -ENODEV;
 350
 351         if (!target->thread.used_ebb)
 352                 return -ENODATA;
 353
 354         return membuf_write(&to, &target->thread.ebbrr, 3 * sizeof(unsigned long));
 355 }
 356
 357 static int ebb_set(struct task_struct *target, const struct user_regset *regset,
 358                    unsigned int pos, unsigned int count, const void *kbuf,
 359                    const void __user *ubuf)
 360 {
 361         int ret = 0;
 362
 363         /* Build tests */
 364         BUILD_BUG_ON(TSO(ebbrr) + sizeof(unsigned long) != TSO(ebbhr));
 365         BUILD_BUG_ON(TSO(ebbhr) + sizeof(unsigned long) != TSO(bescr));
 366
 367         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 368                 return -ENODEV;
 369
 370         if (target->thread.used_ebb)
 371                 return -ENODATA;
 372
 373         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &target->thread.ebbrr,
 374                                  0, sizeof(unsigned long));
 375
 376         if (!ret)
 377                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 378                                          &target->thread.ebbhr, sizeof(unsigned long),
 379                                          2 * sizeof(unsigned long));
 380
 381         if (!ret)
 382                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 383                                          &target->thread.bescr, 2 * sizeof(unsigned long),
 384                                          3 * sizeof(unsigned long));
 385
 386         return ret;
 387 }
 388 static int pmu_active(struct task_struct *target, const struct user_regset *regset)
 389 {
 390         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 391                 return -ENODEV;
 392
 393         return regset->n;
 394 }
 395
 396 static int pmu_get(struct task_struct *target, const struct user_regset *regset,
 397                    struct membuf to)
 398 {
 399         /* Build tests */
 400         BUILD_BUG_ON(TSO(siar) + sizeof(unsigned long) != TSO(sdar));
 401         BUILD_BUG_ON(TSO(sdar) + sizeof(unsigned long) != TSO(sier));
 402         BUILD_BUG_ON(TSO(sier) + sizeof(unsigned long) != TSO(mmcr2));
 403         BUILD_BUG_ON(TSO(mmcr2) + sizeof(unsigned long) != TSO(mmcr0));
 404
 405         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 406                 return -ENODEV;
 407
 408         return membuf_write(&to, &target->thread.siar, 5 * sizeof(unsigned long));
 409 }
 410
 411 static int pmu_set(struct task_struct *target, const struct user_regset *regset,
 412                    unsigned int pos, unsigned int count, const void *kbuf,
 413                    const void __user *ubuf)
 414 {
 415         int ret = 0;
 416
 417         /* Build tests */
 418         BUILD_BUG_ON(TSO(siar) + sizeof(unsigned long) != TSO(sdar));
 419         BUILD_BUG_ON(TSO(sdar) + sizeof(unsigned long) != TSO(sier));
 420         BUILD_BUG_ON(TSO(sier) + sizeof(unsigned long) != TSO(mmcr2));
 421         BUILD_BUG_ON(TSO(mmcr2) + sizeof(unsigned long) != TSO(mmcr0));
 422
 423         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 424                 return -ENODEV;
 425
 426         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &target->thread.siar,
 427                                  0, sizeof(unsigned long));
 428
 429         if (!ret)
 430                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 431                                          &target->thread.sdar, sizeof(unsigned long),
 432                                          2 * sizeof(unsigned long));
 433
 434         if (!ret)
 435                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 436                                          &target->thread.sier, 2 * sizeof(unsigned long),
 437                                          3 * sizeof(unsigned long));
 438
 439         if (!ret)
 440                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 441                                          &target->thread.mmcr2, 3 * sizeof(unsigned long),
 442                                          4 * sizeof(unsigned long));
 443
 444         if (!ret)
 445                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 446                                          &target->thread.mmcr0, 4 * sizeof(unsigned long),
 447                                          5 * sizeof(unsigned long));
 448         return ret;
 449 }
 450 #endif
 451
 452 #ifdef CONFIG_PPC_MEM_KEYS
 453 static int pkey_active(struct task_struct *target, const struct user_regset *regset)
 454 {
 455         if (!arch_pkeys_enabled())
 456                 return -ENODEV;
 457
 458         return regset->n;
 459 }
 460
 461 static int pkey_get(struct task_struct *target, const struct user_regset *regset,
 462                     struct membuf to)
 463 {
 464
 465         if (!arch_pkeys_enabled())
 466                 return -ENODEV;
 467
 468         membuf_store(&to, target->thread.regs->amr);
 469         membuf_store(&to, target->thread.regs->iamr);
 470         return membuf_store(&to, default_uamor);
 471 }
 472
 473 static int pkey_set(struct task_struct *target, const struct user_regset *regset,
 474                     unsigned int pos, unsigned int count, const void *kbuf,
 475                     const void __user *ubuf)
 476 {
 477         u64 new_amr;
 478         int ret;
 479
 480         if (!arch_pkeys_enabled())
 481                 return -ENODEV;
 482
 483         /* Only the AMR can be set from userspace */
 484         if (pos != 0 || count != sizeof(new_amr))
 485                 return -EINVAL;
 486
 487         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
 488                                  &new_amr, 0, sizeof(new_amr));
 489         if (ret)
 490                 return ret;
 491
 492         /*
 493          * UAMOR determines which bits of the AMR can be set from userspace.
 494          * UAMOR value 0b11 indicates that the AMR value can be modified
 495          * from userspace. If the kernel is using a specific key, we avoid
 496          * userspace modifying the AMR value for that key by masking them
 497          * via UAMOR 0b00.
 498          *
 499          * Pick the AMR values for the keys that kernel is using. This
 500          * will be indicated by the ~default_uamor bits.
 501          */
 502         target->thread.regs->amr = (new_amr & default_uamor) |
 503                 (target->thread.regs->amr & ~default_uamor);
 504
 505         return 0;
 506 }
 507 #endif /* CONFIG_PPC_MEM_KEYS */
 508
 509 static const struct user_regset native_regsets[] = {
 510         [REGSET_GPR] = {
 511                 .core_note_type = NT_PRSTATUS, .n = ELF_NGREG,
 512                 .size = sizeof(long), .align = sizeof(long),
 513                 .regset_get = gpr_get, .set = gpr_set
 514         },
 515         [REGSET_FPR] = {
 516                 .core_note_type = NT_PRFPREG, .n = ELF_NFPREG,
 517                 .size = sizeof(double), .align = sizeof(double),
 518                 .regset_get = fpr_get, .set = fpr_set
 519         },
 520 #ifdef CONFIG_ALTIVEC
 521         [REGSET_VMX] = {
 522                 .core_note_type = NT_PPC_VMX, .n = 34,
 523                 .size = sizeof(vector128), .align = sizeof(vector128),
 524                 .active = vr_active, .regset_get = vr_get, .set = vr_set
 525         },
 526 #endif
 527 #ifdef CONFIG_VSX
 528         [REGSET_VSX] = {
 529                 .core_note_type = NT_PPC_VSX, .n = 32,
 530                 .size = sizeof(double), .align = sizeof(double),
 531                 .active = vsr_active, .regset_get = vsr_get, .set = vsr_set
 532         },
 533 #endif
 534 #ifdef CONFIG_SPE
 535         [REGSET_SPE] = {
 536                 .core_note_type = NT_PPC_SPE, .n = 35,
 537                 .size = sizeof(u32), .align = sizeof(u32),
 538                 .active = evr_active, .regset_get = evr_get, .set = evr_set
 539         },
 540 #endif
 541 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 542         [REGSET_TM_CGPR] = {
 543                 .core_note_type = NT_PPC_TM_CGPR, .n = ELF_NGREG,
 544                 .size = sizeof(long), .align = sizeof(long),
 545                 .active = tm_cgpr_active, .regset_get = tm_cgpr_get, .set = tm_cgpr_set
 546         },
 547         [REGSET_TM_CFPR] = {
 548                 .core_note_type = NT_PPC_TM_CFPR, .n = ELF_NFPREG,
 549                 .size = sizeof(double), .align = sizeof(double),
 550                 .active = tm_cfpr_active, .regset_get = tm_cfpr_get, .set = tm_cfpr_set
 551         },
 552         [REGSET_TM_CVMX] = {
 553                 .core_note_type = NT_PPC_TM_CVMX, .n = ELF_NVMX,
 554                 .size = sizeof(vector128), .align = sizeof(vector128),
 555                 .active = tm_cvmx_active, .regset_get = tm_cvmx_get, .set = tm_cvmx_set
 556         },
 557         [REGSET_TM_CVSX] = {
 558                 .core_note_type = NT_PPC_TM_CVSX, .n = ELF_NVSX,
 559                 .size = sizeof(double), .align = sizeof(double),
 560                 .active = tm_cvsx_active, .regset_get = tm_cvsx_get, .set = tm_cvsx_set
 561         },
 562         [REGSET_TM_SPR] = {
 563                 .core_note_type = NT_PPC_TM_SPR, .n = ELF_NTMSPRREG,
 564                 .size = sizeof(u64), .align = sizeof(u64),
 565                 .active = tm_spr_active, .regset_get = tm_spr_get, .set = tm_spr_set
 566         },
 567         [REGSET_TM_CTAR] = {
 568                 .core_note_type = NT_PPC_TM_CTAR, .n = 1,
 569                 .size = sizeof(u64), .align = sizeof(u64),
 570                 .active = tm_tar_active, .regset_get = tm_tar_get, .set = tm_tar_set
 571         },
 572         [REGSET_TM_CPPR] = {
 573                 .core_note_type = NT_PPC_TM_CPPR, .n = 1,
 574                 .size = sizeof(u64), .align = sizeof(u64),
 575                 .active = tm_ppr_active, .regset_get = tm_ppr_get, .set = tm_ppr_set
 576         },
 577         [REGSET_TM_CDSCR] = {
 578                 .core_note_type = NT_PPC_TM_CDSCR, .n = 1,
 579                 .size = sizeof(u64), .align = sizeof(u64),
 580                 .active = tm_dscr_active, .regset_get = tm_dscr_get, .set = tm_dscr_set
 581         },
 582 #endif
 583 #ifdef CONFIG_PPC64
 584         [REGSET_PPR] = {
 585                 .core_note_type = NT_PPC_PPR, .n = 1,
 586                 .size = sizeof(u64), .align = sizeof(u64),
 587                 .regset_get = ppr_get, .set = ppr_set
 588         },
 589         [REGSET_DSCR] = {
 590                 .core_note_type = NT_PPC_DSCR, .n = 1,
 591                 .size = sizeof(u64), .align = sizeof(u64),
 592                 .regset_get = dscr_get, .set = dscr_set
 593         },
 594 #endif
 595 #ifdef CONFIG_PPC_BOOK3S_64
 596         [REGSET_TAR] = {
 597                 .core_note_type = NT_PPC_TAR, .n = 1,
 598                 .size = sizeof(u64), .align = sizeof(u64),
 599                 .regset_get = tar_get, .set = tar_set
 600         },
 601         [REGSET_EBB] = {
 602                 .core_note_type = NT_PPC_EBB, .n = ELF_NEBB,
 603                 .size = sizeof(u64), .align = sizeof(u64),
 604                 .active = ebb_active, .regset_get = ebb_get, .set = ebb_set
 605         },
 606         [REGSET_PMR] = {
 607                 .core_note_type = NT_PPC_PMU, .n = ELF_NPMU,
 608                 .size = sizeof(u64), .align = sizeof(u64),
 609                 .active = pmu_active, .regset_get = pmu_get, .set = pmu_set
 610         },
 611 #endif
 612 #ifdef CONFIG_PPC_MEM_KEYS
 613         [REGSET_PKEY] = {
 614                 .core_note_type = NT_PPC_PKEY, .n = ELF_NPKEY,
 615                 .size = sizeof(u64), .align = sizeof(u64),
 616                 .active = pkey_active, .regset_get = pkey_get, .set = pkey_set
 617         },
 618 #endif
 619 };
 620
 621 const struct user_regset_view user_ppc_native_view = {
 622         .name = UTS_MACHINE, .e_machine = ELF_ARCH, .ei_osabi = ELF_OSABI,
 623         .regsets = native_regsets, .n = ARRAY_SIZE(native_regsets)
 624 };
 625
 626 #include <linux/compat.h>
 627
 628 int gpr32_get_common(struct task_struct *target,
 629                      const struct user_regset *regset,
 630                      struct membuf to, unsigned long *regs)
 631 {
 632         int i;
 633
 634         for (i = 0; i < PT_MSR; i++)
 635                 membuf_store(&to, (u32)regs[i]);
 636         membuf_store(&to, (u32)get_user_msr(target));
 637         for (i++ ; i < PT_REGS_COUNT; i++)
 638                 membuf_store(&to, (u32)regs[i]);
 639         return membuf_zero(&to, (ELF_NGREG - PT_REGS_COUNT) * sizeof(u32));
 640 }
 641
 642 int gpr32_set_common(struct task_struct *target,
 643                      const struct user_regset *regset,
 644                      unsigned int pos, unsigned int count,
 645                      const void *kbuf, const void __user *ubuf,
 646                      unsigned long *regs)
 647 {
 648         const compat_ulong_t *k = kbuf;
 649         const compat_ulong_t __user *u = ubuf;
 650         compat_ulong_t reg;
 651
 652         if (!kbuf && !user_read_access_begin(u, count))
 653                 return -EFAULT;
 654
 655         pos /= sizeof(reg);
 656         count /= sizeof(reg);
 657
 658         if (kbuf)
 659                 for (; count > 0 && pos < PT_MSR; --count)
 660                         regs[pos++] = *k++;
 661         else
 662                 for (; count > 0 && pos < PT_MSR; --count) {
 663                         unsafe_get_user(reg, u++, Efault);
 664                         regs[pos++] = reg;
 665                 }
 666
 667
 668         if (count > 0 && pos == PT_MSR) {
 669                 if (kbuf)
 670                         reg = *k++;
 671                 else
 672                         unsafe_get_user(reg, u++, Efault);
 673                 set_user_msr(target, reg);
 674                 ++pos;
 675                 --count;
 676         }
 677
 678         if (kbuf) {
 679                 for (; count > 0 && pos <= PT_MAX_PUT_REG; --count)
 680                         regs[pos++] = *k++;
 681                 for (; count > 0 && pos < PT_TRAP; --count, ++pos)
 682                         ++k;
 683         } else {
 684                 for (; count > 0 && pos <= PT_MAX_PUT_REG; --count) {
 685                         unsafe_get_user(reg, u++, Efault);
 686                         regs[pos++] = reg;
 687                 }
 688                 for (; count > 0 && pos < PT_TRAP; --count, ++pos)
 689                         unsafe_get_user(reg, u++, Efault);
 690         }
 691
 692         if (count > 0 && pos == PT_TRAP) {
 693                 if (kbuf)
 694                         reg = *k++;
 695                 else
 696                         unsafe_get_user(reg, u++, Efault);
 697                 set_user_trap(target, reg);
 698                 ++pos;
 699                 --count;
 700         }
 701         if (!kbuf)
 702                 user_read_access_end();
 703
 704         kbuf = k;
 705         ubuf = u;
 706         pos *= sizeof(reg);
 707         count *= sizeof(reg);
 708         return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
 709                                          (PT_TRAP + 1) * sizeof(reg), -1);
 710
 711 Efault:
 712         user_read_access_end();
 713         return -EFAULT;
 714 }
 715
 716 static int gpr32_get(struct task_struct *target,
 717                      const struct user_regset *regset,
 718                      struct membuf to)
 719 {
 720         if (target->thread.regs == NULL)
 721                 return -EIO;
 722
 723         return gpr32_get_common(target, regset, to,
 724                         &target->thread.regs->gpr[0]);
 725 }
 726
 727 static int gpr32_set(struct task_struct *target,
 728                      const struct user_regset *regset,
 729                      unsigned int pos, unsigned int count,
 730                      const void *kbuf, const void __user *ubuf)
 731 {
 732         if (target->thread.regs == NULL)
 733                 return -EIO;
 734
 735         return gpr32_set_common(target, regset, pos, count, kbuf, ubuf,
 736                         &target->thread.regs->gpr[0]);
 737 }
 738
 739 /*
 740  * These are the regset flavors matching the CONFIG_PPC32 native set.
 741  */
 742 static const struct user_regset compat_regsets[] = {
 743         [REGSET_GPR] = {
 744                 .core_note_type = NT_PRSTATUS, .n = ELF_NGREG,
 745                 .size = sizeof(compat_long_t), .align = sizeof(compat_long_t),
 746                 .regset_get = gpr32_get, .set = gpr32_set
 747         },
 748         [REGSET_FPR] = {
 749                 .core_note_type = NT_PRFPREG, .n = ELF_NFPREG,
 750                 .size = sizeof(double), .align = sizeof(double),
 751                 .regset_get = fpr_get, .set = fpr_set
 752         },
 753 #ifdef CONFIG_ALTIVEC
 754         [REGSET_VMX] = {
 755                 .core_note_type = NT_PPC_VMX, .n = 34,
 756                 .size = sizeof(vector128), .align = sizeof(vector128),
 757                 .active = vr_active, .regset_get = vr_get, .set = vr_set
 758         },
 759 #endif
 760 #ifdef CONFIG_SPE
 761         [REGSET_SPE] = {
 762                 .core_note_type = NT_PPC_SPE, .n = 35,
 763                 .size = sizeof(u32), .align = sizeof(u32),
 764                 .active = evr_active, .regset_get = evr_get, .set = evr_set
 765         },
 766 #endif
 767 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 768         [REGSET_TM_CGPR] = {
 769                 .core_note_type = NT_PPC_TM_CGPR, .n = ELF_NGREG,
 770                 .size = sizeof(long), .align = sizeof(long),
 771                 .active = tm_cgpr_active,
 772                 .regset_get = tm_cgpr32_get, .set = tm_cgpr32_set
 773         },
 774         [REGSET_TM_CFPR] = {
 775                 .core_note_type = NT_PPC_TM_CFPR, .n = ELF_NFPREG,
 776                 .size = sizeof(double), .align = sizeof(double),
 777                 .active = tm_cfpr_active, .regset_get = tm_cfpr_get, .set = tm_cfpr_set
 778         },
 779         [REGSET_TM_CVMX] = {
 780                 .core_note_type = NT_PPC_TM_CVMX, .n = ELF_NVMX,
 781                 .size = sizeof(vector128), .align = sizeof(vector128),
 782                 .active = tm_cvmx_active, .regset_get = tm_cvmx_get, .set = tm_cvmx_set
 783         },
 784         [REGSET_TM_CVSX] = {
 785                 .core_note_type = NT_PPC_TM_CVSX, .n = ELF_NVSX,
 786                 .size = sizeof(double), .align = sizeof(double),
 787                 .active = tm_cvsx_active, .regset_get = tm_cvsx_get, .set = tm_cvsx_set
 788         },
 789         [REGSET_TM_SPR] = {
 790                 .core_note_type = NT_PPC_TM_SPR, .n = ELF_NTMSPRREG,
 791                 .size = sizeof(u64), .align = sizeof(u64),
 792                 .active = tm_spr_active, .regset_get = tm_spr_get, .set = tm_spr_set
 793         },
 794         [REGSET_TM_CTAR] = {
 795                 .core_note_type = NT_PPC_TM_CTAR, .n = 1,
 796                 .size = sizeof(u64), .align = sizeof(u64),
 797                 .active = tm_tar_active, .regset_get = tm_tar_get, .set = tm_tar_set
 798         },
 799         [REGSET_TM_CPPR] = {
 800                 .core_note_type = NT_PPC_TM_CPPR, .n = 1,
 801                 .size = sizeof(u64), .align = sizeof(u64),
 802                 .active = tm_ppr_active, .regset_get = tm_ppr_get, .set = tm_ppr_set
 803         },
 804         [REGSET_TM_CDSCR] = {
 805                 .core_note_type = NT_PPC_TM_CDSCR, .n = 1,
 806                 .size = sizeof(u64), .align = sizeof(u64),
 807                 .active = tm_dscr_active, .regset_get = tm_dscr_get, .set = tm_dscr_set
 808         },
 809 #endif
 810 #ifdef CONFIG_PPC64
 811         [REGSET_PPR] = {
 812                 .core_note_type = NT_PPC_PPR, .n = 1,
 813                 .size = sizeof(u64), .align = sizeof(u64),
 814                 .regset_get = ppr_get, .set = ppr_set
 815         },
 816         [REGSET_DSCR] = {
 817                 .core_note_type = NT_PPC_DSCR, .n = 1,
 818                 .size = sizeof(u64), .align = sizeof(u64),
 819                 .regset_get = dscr_get, .set = dscr_set
 820         },
 821 #endif
 822 #ifdef CONFIG_PPC_BOOK3S_64
 823         [REGSET_TAR] = {
 824                 .core_note_type = NT_PPC_TAR, .n = 1,
 825                 .size = sizeof(u64), .align = sizeof(u64),
 826                 .regset_get = tar_get, .set = tar_set
 827         },
 828         [REGSET_EBB] = {
 829                 .core_note_type = NT_PPC_EBB, .n = ELF_NEBB,
 830                 .size = sizeof(u64), .align = sizeof(u64),
 831                 .active = ebb_active, .regset_get = ebb_get, .set = ebb_set
 832         },
 833 #endif
 834 };
 835
 836 static const struct user_regset_view user_ppc_compat_view = {
 837         .name = "ppc", .e_machine = EM_PPC, .ei_osabi = ELF_OSABI,
 838         .regsets = compat_regsets, .n = ARRAY_SIZE(compat_regsets)
 839 };
 840
 841 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
 842 {
 843         if (IS_ENABLED(CONFIG_PPC64) && test_tsk_thread_flag(task, TIF_32BIT))
 844                 return &user_ppc_compat_view;
 845         return &user_ppc_native_view;
 846 }