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