| 1 | |
| 2 | |
| 3 | * Kernel support for the ptrace() and syscall tracing interfaces.
|
| 4 | *
|
| 5 | * Copyright (C) 2000 Hewlett-Packard Co, Linuxcare Inc.
|
| 6 | * Copyright (C) 2000 Matthew Wilcox <[email protected]>
|
| 7 | * Copyright (C) 2000 David Huggins-Daines <[email protected]>
|
| 8 | * Copyright (C) 2008-2016 Helge Deller <[email protected]>
|
| 9 |
|
| 10 |
|
| 11 | #include <linux/kernel.h>
|
| 12 | #include <linux/sched.h>
|
| 13 | #include <linux/mm.h>
|
| 14 | #include <linux/smp.h>
|
| 15 | #include <linux/elf.h>
|
| 16 | #include <linux/errno.h>
|
| 17 | #include <linux/ptrace.h>
|
| 18 | #include <linux/user.h>
|
| 19 | #include <linux/personality.h>
|
| 20 | #include <linux/regset.h>
|
| 21 | #include <linux/security.h>
|
| 22 | #include <linux/seccomp.h>
|
| 23 | #include <linux/compat.h>
|
| 24 | #include <linux/signal.h>
|
| 25 | #include <linux/audit.h>
|
| 26 |
|
| 27 | #include <linux/uaccess.h>
|
| 28 | #include <asm/processor.h>
|
| 29 | #include <asm/asm-offsets.h>
|
| 30 |
|
| 31 |
|
| 32 | #define USER_PSW_BITS (PSW_N | PSW_B | PSW_V | PSW_CB)
|
| 33 |
|
| 34 | #define CREATE_TRACE_POINTS
|
| 35 | #include <trace/events/syscalls.h>
|
| 36 |
|
| 37 | |
| 38 | * These are our native regset flavors.
|
| 39 |
|
| 40 | enum parisc_regset {
|
| 41 | REGSET_GENERAL,
|
| 42 | REGSET_FP
|
| 43 | };
|
| 44 |
|
| 45 | |
| 46 | * Called by kernel/ptrace.c when detaching..
|
| 47 | *
|
| 48 | * Make sure single step bits etc are not set.
|
| 49 |
|
| 50 | void ptrace_disable(struct task_struct *task)
|
| 51 | {
|
| 52 | clear_tsk_thread_flag(task, TIF_SINGLESTEP);
|
| 53 | clear_tsk_thread_flag(task, TIF_BLOCKSTEP);
|
| 54 |
|
| 55 |
|
| 56 | pa_psw(task)->r = 0;
|
| 57 | pa_psw(task)->t = 0;
|
| 58 | pa_psw(task)->h = 0;
|
| 59 | pa_psw(task)->l = 0;
|
| 60 | }
|
| 61 |
|
| 62 | |
| 63 | * The following functions are called by ptrace_resume() when
|
| 64 | * enabling or disabling single/block tracing.
|
| 65 |
|
| 66 | void user_disable_single_step(struct task_struct *task)
|
| 67 | {
|
| 68 | ptrace_disable(task);
|
| 69 | }
|
| 70 |
|
| 71 | void user_enable_single_step(struct task_struct *task)
|
| 72 | {
|
| 73 | clear_tsk_thread_flag(task, TIF_BLOCKSTEP);
|
| 74 | set_tsk_thread_flag(task, TIF_SINGLESTEP);
|
| 75 |
|
| 76 | if (pa_psw(task)->n) {
|
| 77 |
|
| 78 | task_regs(task)->iaoq[0] = task_regs(task)->iaoq[1];
|
| 79 | task_regs(task)->iasq[0] = task_regs(task)->iasq[1];
|
| 80 | task_regs(task)->iaoq[1] = task_regs(task)->iaoq[0] + 4;
|
| 81 | pa_psw(task)->n = 0;
|
| 82 | pa_psw(task)->x = 0;
|
| 83 | pa_psw(task)->y = 0;
|
| 84 | pa_psw(task)->z = 0;
|
| 85 | pa_psw(task)->b = 0;
|
| 86 | ptrace_disable(task);
|
| 87 | |
| 88 | parent know something happened.
|
| 89 | force_sig_fault_to_task(SIGTRAP, TRAP_TRACE,
|
| 90 | (void __user *) (task_regs(task)->iaoq[0] & ~3),
|
| 91 | task);
|
| 92 |
|
| 93 | return;
|
| 94 | }
|
| 95 |
|
| 96 | |
| 97 | * itself will be set to zero on a task switch. If the
|
| 98 | * task is suspended on a syscall then the syscall return
|
| 99 | * path will overwrite the recovery counter with a suitable
|
| 100 | * value such that it traps once back in user space. We
|
| 101 | * disable interrupts in the tasks PSW here also, to avoid
|
| 102 | * interrupts while the recovery counter is decrementing.
|
| 103 |
|
| 104 | pa_psw(task)->r = 1;
|
| 105 | pa_psw(task)->t = 0;
|
| 106 | pa_psw(task)->h = 0;
|
| 107 | pa_psw(task)->l = 0;
|
| 108 | }
|
| 109 |
|
| 110 | void user_enable_block_step(struct task_struct *task)
|
| 111 | {
|
| 112 | clear_tsk_thread_flag(task, TIF_SINGLESTEP);
|
| 113 | set_tsk_thread_flag(task, TIF_BLOCKSTEP);
|
| 114 |
|
| 115 |
|
| 116 | pa_psw(task)->r = 0;
|
| 117 | pa_psw(task)->t = 1;
|
| 118 | pa_psw(task)->h = 0;
|
| 119 | pa_psw(task)->l = 0;
|
| 120 | }
|
| 121 |
|
| 122 | long arch_ptrace(struct task_struct *child, long request,
|
| 123 | unsigned long addr, unsigned long data)
|
| 124 | {
|
| 125 | unsigned long __user *datap = (unsigned long __user *)data;
|
| 126 | unsigned long tmp;
|
| 127 | long ret = -EIO;
|
| 128 |
|
| 129 | unsigned long user_regs_struct_size = sizeof(struct user_regs_struct);
|
| 130 | #ifdef CONFIG_64BIT
|
| 131 | if (is_compat_task())
|
| 132 | user_regs_struct_size /= 2;
|
| 133 | #endif
|
| 134 |
|
| 135 | switch (request) {
|
| 136 |
|
| 137 | |
| 138 | processes, the kernel saves all regs on a syscall.
|
| 139 | case PTRACE_PEEKUSR:
|
| 140 | if ((addr & (sizeof(unsigned long)-1)) ||
|
| 141 | addr >= sizeof(struct pt_regs))
|
| 142 | break;
|
| 143 | tmp = *(unsigned long *) ((char *) task_regs(child) + addr);
|
| 144 | ret = put_user(tmp, datap);
|
| 145 | break;
|
| 146 |
|
| 147 | |
| 148 | to change when the kernel no longer saves all regs on a syscall.
|
| 149 | FIXME. There is a problem at the moment in that r3-r18 are only
|
| 150 | saved if the process is ptraced on syscall entry, and even then
|
| 151 | those values are overwritten by actual register values on syscall
|
| 152 | exit.
|
| 153 | case PTRACE_POKEUSR:
|
| 154 | |
| 155 | * entry.S:syscall_restore_rfi; e.g. iaoq is written with
|
| 156 | * r31/r31+4, and not with the values in pt_regs.
|
| 157 |
|
| 158 | if (addr == PT_PSW) {
|
| 159 | |
| 160 | * and carry/borrow bits.
|
| 161 | * BEWARE, if you set N, and then single step, it won't
|
| 162 | * stop on the nullified instruction.
|
| 163 |
|
| 164 | data &= USER_PSW_BITS;
|
| 165 | task_regs(child)->gr[0] &= ~USER_PSW_BITS;
|
| 166 | task_regs(child)->gr[0] |= data;
|
| 167 | ret = 0;
|
| 168 | break;
|
| 169 | }
|
| 170 |
|
| 171 | if ((addr & (sizeof(unsigned long)-1)) ||
|
| 172 | addr >= sizeof(struct pt_regs))
|
| 173 | break;
|
| 174 | if (addr == PT_IAOQ0 || addr == PT_IAOQ1) {
|
| 175 | data |= PRIV_USER;
|
| 176 | }
|
| 177 | if ((addr >= PT_GR1 && addr <= PT_GR31) ||
|
| 178 | addr == PT_IAOQ0 || addr == PT_IAOQ1 ||
|
| 179 | (addr >= PT_FR0 && addr <= PT_FR31 + 4) ||
|
| 180 | addr == PT_SAR) {
|
| 181 | *(unsigned long *) ((char *) task_regs(child) + addr) = data;
|
| 182 | ret = 0;
|
| 183 | }
|
| 184 | break;
|
| 185 |
|
| 186 | case PTRACE_GETREGS:
|
| 187 | return copy_regset_to_user(child,
|
| 188 | task_user_regset_view(current),
|
| 189 | REGSET_GENERAL,
|
| 190 | 0, user_regs_struct_size,
|
| 191 | datap);
|
| 192 |
|
| 193 | case PTRACE_SETREGS:
|
| 194 | return copy_regset_from_user(child,
|
| 195 | task_user_regset_view(current),
|
| 196 | REGSET_GENERAL,
|
| 197 | 0, user_regs_struct_size,
|
| 198 | datap);
|
| 199 |
|
| 200 | case PTRACE_GETFPREGS:
|
| 201 | return copy_regset_to_user(child,
|
| 202 | task_user_regset_view(current),
|
| 203 | REGSET_FP,
|
| 204 | 0, sizeof(struct user_fp_struct),
|
| 205 | datap);
|
| 206 |
|
| 207 | case PTRACE_SETFPREGS:
|
| 208 | return copy_regset_from_user(child,
|
| 209 | task_user_regset_view(current),
|
| 210 | REGSET_FP,
|
| 211 | 0, sizeof(struct user_fp_struct),
|
| 212 | datap);
|
| 213 |
|
| 214 | default:
|
| 215 | ret = ptrace_request(child, request, addr, data);
|
| 216 | break;
|
| 217 | }
|
| 218 |
|
| 219 | return ret;
|
| 220 | }
|
| 221 |
|
| 222 |
|
| 223 | #ifdef CONFIG_COMPAT
|
| 224 |
|
| 225 | |
| 226 | * 64 bit pt_regs offsets. For example, a 32 bit gdb under a 64 bit kernel
|
| 227 | * will request offset 12 if it wants gr3, but the lower 32 bits of
|
| 228 | * the 64 bit kernels view of gr3 will be at offset 28 (3*8 + 4).
|
| 229 | * This code relies on a 32 bit pt_regs being comprised of 32 bit values
|
| 230 | * except for the fp registers which (a) are 64 bits, and (b) follow
|
| 231 | * the gr registers at the start of pt_regs. The 32 bit pt_regs should
|
| 232 | * be half the size of the 64 bit pt_regs, plus 32*4 to allow for fr[]
|
| 233 | * being 64 bit in both cases.
|
| 234 |
|
| 235 |
|
| 236 | static compat_ulong_t translate_usr_offset(compat_ulong_t offset)
|
| 237 | {
|
| 238 | compat_ulong_t pos;
|
| 239 |
|
| 240 | if (offset < 32*4)
|
| 241 | pos = offset * 2 + 4;
|
| 242 | else if (offset < 32*4+32*8)
|
| 243 | pos = (offset - 32*4) + PT_FR0;
|
| 244 | else if (offset < sizeof(struct pt_regs)/2 + 32*4)
|
| 245 | pos = (offset - 32*4 - 32*8) * 2 + PT_SR0 + 4;
|
| 246 | else
|
| 247 | pos = sizeof(struct pt_regs);
|
| 248 |
|
| 249 | return pos;
|
| 250 | }
|
| 251 |
|
| 252 | long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|
| 253 | compat_ulong_t addr, compat_ulong_t data)
|
| 254 | {
|
| 255 | compat_uint_t tmp;
|
| 256 | long ret = -EIO;
|
| 257 |
|
| 258 | switch (request) {
|
| 259 |
|
| 260 | case PTRACE_PEEKUSR:
|
| 261 | if (addr & (sizeof(compat_uint_t)-1))
|
| 262 | break;
|
| 263 | addr = translate_usr_offset(addr);
|
| 264 | if (addr >= sizeof(struct pt_regs))
|
| 265 | break;
|
| 266 |
|
| 267 | tmp = *(compat_uint_t *) ((char *) task_regs(child) + addr);
|
| 268 | ret = put_user(tmp, (compat_uint_t *) (unsigned long) data);
|
| 269 | break;
|
| 270 |
|
| 271 | |
| 272 | to change when the kernel no longer saves all regs on a syscall.
|
| 273 | FIXME. There is a problem at the moment in that r3-r18 are only
|
| 274 | saved if the process is ptraced on syscall entry, and even then
|
| 275 | those values are overwritten by actual register values on syscall
|
| 276 | exit.
|
| 277 | case PTRACE_POKEUSR:
|
| 278 | |
| 279 | * entry.S:syscall_restore_rfi; e.g. iaoq is written with
|
| 280 | * r31/r31+4, and not with the values in pt_regs.
|
| 281 |
|
| 282 | if (addr == PT_PSW) {
|
| 283 | |
| 284 | * under 64 bit kernels as well.
|
| 285 |
|
| 286 | ret = arch_ptrace(child, request, addr, data);
|
| 287 | } else {
|
| 288 | if (addr & (sizeof(compat_uint_t)-1))
|
| 289 | break;
|
| 290 | addr = translate_usr_offset(addr);
|
| 291 | if (addr >= sizeof(struct pt_regs))
|
| 292 | break;
|
| 293 | if (addr == PT_IAOQ0+4 || addr == PT_IAOQ1+4) {
|
| 294 | data |= PRIV_USER;
|
| 295 | }
|
| 296 | if (addr >= PT_FR0 && addr <= PT_FR31 + 4) {
|
| 297 |
|
| 298 | *(__u32 *) ((char *) task_regs(child) + addr) = data;
|
| 299 | ret = 0;
|
| 300 | }
|
| 301 | else if ((addr >= PT_GR1+4 && addr <= PT_GR31+4) ||
|
| 302 | addr == PT_IAOQ0+4 || addr == PT_IAOQ1+4 ||
|
| 303 | addr == PT_SAR+4) {
|
| 304 |
|
| 305 | *(__u32 *) ((char *) task_regs(child) + addr - 4) = 0;
|
| 306 | *(__u32 *) ((char *) task_regs(child) + addr) = data;
|
| 307 | ret = 0;
|
| 308 | }
|
| 309 | }
|
| 310 | break;
|
| 311 | case PTRACE_GETREGS:
|
| 312 | case PTRACE_SETREGS:
|
| 313 | case PTRACE_GETFPREGS:
|
| 314 | case PTRACE_SETFPREGS:
|
| 315 | return arch_ptrace(child, request, addr, data);
|
| 316 |
|
| 317 | default:
|
| 318 | ret = compat_ptrace_request(child, request, addr, data);
|
| 319 | break;
|
| 320 | }
|
| 321 |
|
| 322 | return ret;
|
| 323 | }
|
| 324 | #endif
|
| 325 |
|
| 326 | long do_syscall_trace_enter(struct pt_regs *regs)
|
| 327 | {
|
| 328 | if (test_thread_flag(TIF_SYSCALL_TRACE)) {
|
| 329 | bool permit = ptrace_report_syscall_permit_entry(regs);
|
| 330 |
|
| 331 | |
| 332 | * As tracesys_next does not set %r28 to -ENOSYS
|
| 333 | * when %r20 is set to -1, initialize it here.
|
| 334 |
|
| 335 | regs->gr[28] = -ENOSYS;
|
| 336 |
|
| 337 | if (!permit) {
|
| 338 | |
| 339 | * Skip the syscall call and the syscall restart
|
| 340 | * handling.
|
| 341 | *
|
| 342 | * Note that the tracer may also just change
|
| 343 | * regs->gr[20] to an invalid syscall number,
|
| 344 | * that is handled by tracesys_next.
|
| 345 |
|
| 346 | regs->gr[20] = -1UL;
|
| 347 | return -1;
|
| 348 | }
|
| 349 | }
|
| 350 |
|
| 351 |
|
| 352 | if (!seccomp_permit_syscall())
|
| 353 | return -1;
|
| 354 |
|
| 355 | #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
|
| 356 | if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
|
| 357 | trace_sys_enter(regs, regs->gr[20]);
|
| 358 | #endif
|
| 359 |
|
| 360 | #ifdef CONFIG_64BIT
|
| 361 | if (!is_compat_task())
|
| 362 | audit_syscall_entry(regs->gr[20], regs->gr[26], regs->gr[25],
|
| 363 | regs->gr[24], regs->gr[23]);
|
| 364 | else
|
| 365 | #endif
|
| 366 | audit_syscall_entry(regs->gr[20] & 0xffffffff,
|
| 367 | regs->gr[26] & 0xffffffff,
|
| 368 | regs->gr[25] & 0xffffffff,
|
| 369 | regs->gr[24] & 0xffffffff,
|
| 370 | regs->gr[23] & 0xffffffff);
|
| 371 |
|
| 372 | |
| 373 | * Sign extend the syscall number to 64bit since it may have been
|
| 374 | * modified by a compat ptrace call
|
| 375 |
|
| 376 | return (int) ((u32) regs->gr[20]);
|
| 377 | }
|
| 378 |
|
| 379 | void do_syscall_trace_exit(struct pt_regs *regs)
|
| 380 | {
|
| 381 | int stepping = test_thread_flag(TIF_SINGLESTEP) ||
|
| 382 | test_thread_flag(TIF_BLOCKSTEP);
|
| 383 |
|
| 384 | audit_syscall_exit(regs);
|
| 385 |
|
| 386 | #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
|
| 387 | if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
|
| 388 | trace_sys_exit(regs, regs->gr[20]);
|
| 389 | #endif
|
| 390 |
|
| 391 | if (stepping || test_thread_flag(TIF_SYSCALL_TRACE))
|
| 392 | ptrace_report_syscall_exit(regs, stepping);
|
| 393 | }
|
| 394 |
|
| 395 |
|
| 396 | |
| 397 | * regset functions.
|
| 398 |
|
| 399 |
|
| 400 | static int fpr_get(struct task_struct *target,
|
| 401 | const struct user_regset *regset,
|
| 402 | struct membuf to)
|
| 403 | {
|
| 404 | struct pt_regs *regs = task_regs(target);
|
| 405 |
|
| 406 | return membuf_write(&to, regs->fr, ELF_NFPREG * sizeof(__u64));
|
| 407 | }
|
| 408 |
|
| 409 | static int fpr_set(struct task_struct *target,
|
| 410 | const struct user_regset *regset,
|
| 411 | unsigned int pos, unsigned int count,
|
| 412 | const void *kbuf, const void __user *ubuf)
|
| 413 | {
|
| 414 | struct pt_regs *regs = task_regs(target);
|
| 415 | const __u64 *k = kbuf;
|
| 416 | const __u64 __user *u = ubuf;
|
| 417 | __u64 reg;
|
| 418 |
|
| 419 | pos /= sizeof(reg);
|
| 420 | count /= sizeof(reg);
|
| 421 |
|
| 422 | if (kbuf)
|
| 423 | for (; count > 0 && pos < ELF_NFPREG; --count)
|
| 424 | regs->fr[pos++] = *k++;
|
| 425 | else
|
| 426 | for (; count > 0 && pos < ELF_NFPREG; --count) {
|
| 427 | if (__get_user(reg, u++))
|
| 428 | return -EFAULT;
|
| 429 | regs->fr[pos++] = reg;
|
| 430 | }
|
| 431 |
|
| 432 | kbuf = k;
|
| 433 | ubuf = u;
|
| 434 | pos *= sizeof(reg);
|
| 435 | count *= sizeof(reg);
|
| 436 | user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
|
| 437 | ELF_NFPREG * sizeof(reg), -1);
|
| 438 | return 0;
|
| 439 | }
|
| 440 |
|
| 441 | #define RI(reg) (offsetof(struct user_regs_struct,reg) / sizeof(long))
|
| 442 |
|
| 443 | static unsigned long get_reg(struct pt_regs *regs, int num)
|
| 444 | {
|
| 445 | switch (num) {
|
| 446 | case RI(gr[0]) ... RI(gr[31]): return regs->gr[num - RI(gr[0])];
|
| 447 | case RI(sr[0]) ... RI(sr[7]): return regs->sr[num - RI(sr[0])];
|
| 448 | case RI(iasq[0]): return regs->iasq[0];
|
| 449 | case RI(iasq[1]): return regs->iasq[1];
|
| 450 | case RI(iaoq[0]): return regs->iaoq[0];
|
| 451 | case RI(iaoq[1]): return regs->iaoq[1];
|
| 452 | case RI(sar): return regs->sar;
|
| 453 | case RI(iir): return regs->iir;
|
| 454 | case RI(isr): return regs->isr;
|
| 455 | case RI(ior): return regs->ior;
|
| 456 | case RI(ipsw): return regs->ipsw;
|
| 457 | case RI(cr27): return regs->cr27;
|
| 458 | case RI(cr0): return mfctl(0);
|
| 459 | case RI(cr24): return mfctl(24);
|
| 460 | case RI(cr25): return mfctl(25);
|
| 461 | case RI(cr26): return mfctl(26);
|
| 462 | case RI(cr28): return mfctl(28);
|
| 463 | case RI(cr29): return mfctl(29);
|
| 464 | case RI(cr30): return mfctl(30);
|
| 465 | case RI(cr31): return mfctl(31);
|
| 466 | case RI(cr8): return mfctl(8);
|
| 467 | case RI(cr9): return mfctl(9);
|
| 468 | case RI(cr12): return mfctl(12);
|
| 469 | case RI(cr13): return mfctl(13);
|
| 470 | case RI(cr10): return mfctl(10);
|
| 471 | case RI(cr15): return mfctl(15);
|
| 472 | default: return 0;
|
| 473 | }
|
| 474 | }
|
| 475 |
|
| 476 | static void set_reg(struct pt_regs *regs, int num, unsigned long val)
|
| 477 | {
|
| 478 | switch (num) {
|
| 479 | case RI(gr[0]): |
| 480 | * PSW is in gr[0].
|
| 481 | * Allow writing to Nullify, Divide-step-correction,
|
| 482 | * and carry/borrow bits.
|
| 483 | * BEWARE, if you set N, and then single step, it won't
|
| 484 | * stop on the nullified instruction.
|
| 485 |
|
| 486 | val &= USER_PSW_BITS;
|
| 487 | regs->gr[0] &= ~USER_PSW_BITS;
|
| 488 | regs->gr[0] |= val;
|
| 489 | return;
|
| 490 | case RI(gr[1]) ... RI(gr[31]):
|
| 491 | regs->gr[num - RI(gr[0])] = val;
|
| 492 | return;
|
| 493 | case RI(iaoq[0]):
|
| 494 | case RI(iaoq[1]):
|
| 495 |
|
| 496 | regs->iaoq[num - RI(iaoq[0])] = val | PRIV_USER;
|
| 497 | return;
|
| 498 | case RI(sar): regs->sar = val;
|
| 499 | return;
|
| 500 | default: return;
|
| 501 | #if 0 |
| 502 | /* do not allow to change any of the following registers (yet) */
|
| 503 | case RI(sr[0]) ... RI(sr[7]): return regs->sr[num - RI(sr[0])];
|
| 504 | case RI(iasq[0]): return regs->iasq[0];
|
| 505 | case RI(iasq[1]): return regs->iasq[1];
|
| 506 | case RI(iir): return regs->iir;
|
| 507 | case RI(isr): return regs->isr;
|
| 508 | case RI(ior): return regs->ior;
|
| 509 | case RI(ipsw): return regs->ipsw;
|
| 510 | case RI(cr27): return regs->cr27;
|
| 511 | case cr0, cr24, cr25, cr26, cr27, cr28, cr29, cr30, cr31;
|
| 512 | case cr8, cr9, cr12, cr13, cr10, cr15;
|
| 513 | #endif
|
| 514 | }
|
| 515 | }
|
| 516 |
|
| 517 | static int gpr_get(struct task_struct *target,
|
| 518 | const struct user_regset *regset,
|
| 519 | struct membuf to)
|
| 520 | {
|
| 521 | struct pt_regs *regs = task_regs(target);
|
| 522 | unsigned int pos;
|
| 523 |
|
| 524 | for (pos = 0; pos < ELF_NGREG; pos++)
|
| 525 | membuf_store(&to, get_reg(regs, pos));
|
| 526 | return 0;
|
| 527 | }
|
| 528 |
|
| 529 | static int gpr_set(struct task_struct *target,
|
| 530 | const struct user_regset *regset,
|
| 531 | unsigned int pos, unsigned int count,
|
| 532 | const void *kbuf, const void __user *ubuf)
|
| 533 | {
|
| 534 | struct pt_regs *regs = task_regs(target);
|
| 535 | const unsigned long *k = kbuf;
|
| 536 | const unsigned long __user *u = ubuf;
|
| 537 | unsigned long reg;
|
| 538 |
|
| 539 | pos /= sizeof(reg);
|
| 540 | count /= sizeof(reg);
|
| 541 |
|
| 542 | if (kbuf)
|
| 543 | for (; count > 0 && pos < ELF_NGREG; --count)
|
| 544 | set_reg(regs, pos++, *k++);
|
| 545 | else
|
| 546 | for (; count > 0 && pos < ELF_NGREG; --count) {
|
| 547 | if (__get_user(reg, u++))
|
| 548 | return -EFAULT;
|
| 549 | set_reg(regs, pos++, reg);
|
| 550 | }
|
| 551 |
|
| 552 | kbuf = k;
|
| 553 | ubuf = u;
|
| 554 | pos *= sizeof(reg);
|
| 555 | count *= sizeof(reg);
|
| 556 | user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
|
| 557 | ELF_NGREG * sizeof(reg), -1);
|
| 558 | return 0;
|
| 559 | }
|
| 560 |
|
| 561 | static const struct user_regset native_regsets[] = {
|
| 562 | [REGSET_GENERAL] = {
|
| 563 | USER_REGSET_NOTE_TYPE(PRSTATUS), .n = ELF_NGREG,
|
| 564 | .size = sizeof(long), .align = sizeof(long),
|
| 565 | .regset_get = gpr_get, .set = gpr_set
|
| 566 | },
|
| 567 | [REGSET_FP] = {
|
| 568 | USER_REGSET_NOTE_TYPE(PRFPREG), .n = ELF_NFPREG,
|
| 569 | .size = sizeof(__u64), .align = sizeof(__u64),
|
| 570 | .regset_get = fpr_get, .set = fpr_set
|
| 571 | }
|
| 572 | };
|
| 573 |
|
| 574 | static const struct user_regset_view user_parisc_native_view = {
|
| 575 | .name = "parisc", .e_machine = ELF_ARCH, .ei_osabi = ELFOSABI_LINUX,
|
| 576 | .regsets = native_regsets, .n = ARRAY_SIZE(native_regsets)
|
| 577 | };
|
| 578 |
|
| 579 | #ifdef CONFIG_64BIT
|
| 580 | static int gpr32_get(struct task_struct *target,
|
| 581 | const struct user_regset *regset,
|
| 582 | struct membuf to)
|
| 583 | {
|
| 584 | struct pt_regs *regs = task_regs(target);
|
| 585 | unsigned int pos;
|
| 586 |
|
| 587 | for (pos = 0; pos < ELF_NGREG; pos++)
|
| 588 | membuf_store(&to, (compat_ulong_t)get_reg(regs, pos));
|
| 589 |
|
| 590 | return 0;
|
| 591 | }
|
| 592 |
|
| 593 | static int gpr32_set(struct task_struct *target,
|
| 594 | const struct user_regset *regset,
|
| 595 | unsigned int pos, unsigned int count,
|
| 596 | const void *kbuf, const void __user *ubuf)
|
| 597 | {
|
| 598 | struct pt_regs *regs = task_regs(target);
|
| 599 | const compat_ulong_t *k = kbuf;
|
| 600 | const compat_ulong_t __user *u = ubuf;
|
| 601 | compat_ulong_t reg;
|
| 602 |
|
| 603 | pos /= sizeof(reg);
|
| 604 | count /= sizeof(reg);
|
| 605 |
|
| 606 | if (kbuf)
|
| 607 | for (; count > 0 && pos < ELF_NGREG; --count)
|
| 608 | set_reg(regs, pos++, *k++);
|
| 609 | else
|
| 610 | for (; count > 0 && pos < ELF_NGREG; --count) {
|
| 611 | if (__get_user(reg, u++))
|
| 612 | return -EFAULT;
|
| 613 | set_reg(regs, pos++, reg);
|
| 614 | }
|
| 615 |
|
| 616 | kbuf = k;
|
| 617 | ubuf = u;
|
| 618 | pos *= sizeof(reg);
|
| 619 | count *= sizeof(reg);
|
| 620 | user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
|
| 621 | ELF_NGREG * sizeof(reg), -1);
|
| 622 | return 0;
|
| 623 | }
|
| 624 |
|
| 625 | |
| 626 | * These are the regset flavors matching the 32bit native set.
|
| 627 |
|
| 628 | static const struct user_regset compat_regsets[] = {
|
| 629 | [REGSET_GENERAL] = {
|
| 630 | USER_REGSET_NOTE_TYPE(PRSTATUS), .n = ELF_NGREG,
|
| 631 | .size = sizeof(compat_long_t), .align = sizeof(compat_long_t),
|
| 632 | .regset_get = gpr32_get, .set = gpr32_set
|
| 633 | },
|
| 634 | [REGSET_FP] = {
|
| 635 | USER_REGSET_NOTE_TYPE(PRFPREG), .n = ELF_NFPREG,
|
| 636 | .size = sizeof(__u64), .align = sizeof(__u64),
|
| 637 | .regset_get = fpr_get, .set = fpr_set
|
| 638 | }
|
| 639 | };
|
| 640 |
|
| 641 | static const struct user_regset_view user_parisc_compat_view = {
|
| 642 | .name = "parisc", .e_machine = EM_PARISC, .ei_osabi = ELFOSABI_LINUX,
|
| 643 | .regsets = compat_regsets, .n = ARRAY_SIZE(compat_regsets)
|
| 644 | };
|
| 645 | #endif
|
| 646 |
|
| 647 | const struct user_regset_view *task_user_regset_view(struct task_struct *task)
|
| 648 | {
|
| 649 | BUILD_BUG_ON(sizeof(struct user_regs_struct)/sizeof(long) != ELF_NGREG);
|
| 650 | BUILD_BUG_ON(sizeof(struct user_fp_struct)/sizeof(__u64) != ELF_NFPREG);
|
| 651 | #ifdef CONFIG_64BIT
|
| 652 | if (is_compat_task())
|
| 653 | return &user_parisc_compat_view;
|
| 654 | #endif
|
| 655 | return &user_parisc_native_view;
|
| 656 | }
|
| 657 |
|
| 658 |
|
| 659 |
|
| 660 |
|
| 661 | struct pt_regs_offset {
|
| 662 | const char *name;
|
| 663 | int offset;
|
| 664 | };
|
| 665 |
|
| 666 | #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
|
| 667 | #define REG_OFFSET_INDEX(r,i) {.name = #r#i, .offset = offsetof(struct pt_regs, r[i])}
|
| 668 | #define REG_OFFSET_END {.name = NULL, .offset = 0}
|
| 669 |
|
| 670 | static const struct pt_regs_offset regoffset_table[] = {
|
| 671 | REG_OFFSET_INDEX(gr,0),
|
| 672 | REG_OFFSET_INDEX(gr,1),
|
| 673 | REG_OFFSET_INDEX(gr,2),
|
| 674 | REG_OFFSET_INDEX(gr,3),
|
| 675 | REG_OFFSET_INDEX(gr,4),
|
| 676 | REG_OFFSET_INDEX(gr,5),
|
| 677 | REG_OFFSET_INDEX(gr,6),
|
| 678 | REG_OFFSET_INDEX(gr,7),
|
| 679 | REG_OFFSET_INDEX(gr,8),
|
| 680 | REG_OFFSET_INDEX(gr,9),
|
| 681 | REG_OFFSET_INDEX(gr,10),
|
| 682 | REG_OFFSET_INDEX(gr,11),
|
| 683 | REG_OFFSET_INDEX(gr,12),
|
| 684 | REG_OFFSET_INDEX(gr,13),
|
| 685 | REG_OFFSET_INDEX(gr,14),
|
| 686 | REG_OFFSET_INDEX(gr,15),
|
| 687 | REG_OFFSET_INDEX(gr,16),
|
| 688 | REG_OFFSET_INDEX(gr,17),
|
| 689 | REG_OFFSET_INDEX(gr,18),
|
| 690 | REG_OFFSET_INDEX(gr,19),
|
| 691 | REG_OFFSET_INDEX(gr,20),
|
| 692 | REG_OFFSET_INDEX(gr,21),
|
| 693 | REG_OFFSET_INDEX(gr,22),
|
| 694 | REG_OFFSET_INDEX(gr,23),
|
| 695 | REG_OFFSET_INDEX(gr,24),
|
| 696 | REG_OFFSET_INDEX(gr,25),
|
| 697 | REG_OFFSET_INDEX(gr,26),
|
| 698 | REG_OFFSET_INDEX(gr,27),
|
| 699 | REG_OFFSET_INDEX(gr,28),
|
| 700 | REG_OFFSET_INDEX(gr,29),
|
| 701 | REG_OFFSET_INDEX(gr,30),
|
| 702 | REG_OFFSET_INDEX(gr,31),
|
| 703 | REG_OFFSET_INDEX(sr,0),
|
| 704 | REG_OFFSET_INDEX(sr,1),
|
| 705 | REG_OFFSET_INDEX(sr,2),
|
| 706 | REG_OFFSET_INDEX(sr,3),
|
| 707 | REG_OFFSET_INDEX(sr,4),
|
| 708 | REG_OFFSET_INDEX(sr,5),
|
| 709 | REG_OFFSET_INDEX(sr,6),
|
| 710 | REG_OFFSET_INDEX(sr,7),
|
| 711 | REG_OFFSET_INDEX(iasq,0),
|
| 712 | REG_OFFSET_INDEX(iasq,1),
|
| 713 | REG_OFFSET_INDEX(iaoq,0),
|
| 714 | REG_OFFSET_INDEX(iaoq,1),
|
| 715 | REG_OFFSET_NAME(cr27),
|
| 716 | REG_OFFSET_NAME(ksp),
|
| 717 | REG_OFFSET_NAME(kpc),
|
| 718 | REG_OFFSET_NAME(sar),
|
| 719 | REG_OFFSET_NAME(iir),
|
| 720 | REG_OFFSET_NAME(isr),
|
| 721 | REG_OFFSET_NAME(ior),
|
| 722 | REG_OFFSET_NAME(ipsw),
|
| 723 | REG_OFFSET_END,
|
| 724 | };
|
| 725 |
|
| 726 | |
| 727 | * regs_query_register_offset() - query register offset from its name
|
| 728 | * @name: the name of a register
|
| 729 | *
|
| 730 | * regs_query_register_offset() returns the offset of a register in struct
|
| 731 | * pt_regs from its name. If the name is invalid, this returns -EINVAL;
|
| 732 |
|
| 733 | int regs_query_register_offset(const char *name)
|
| 734 | {
|
| 735 | const struct pt_regs_offset *roff;
|
| 736 | for (roff = regoffset_table; roff->name != NULL; roff++)
|
| 737 | if (!strcmp(roff->name, name))
|
| 738 | return roff->offset;
|
| 739 | return -EINVAL;
|
| 740 | }
|
| 741 |
|
| 742 | |
| 743 | * regs_query_register_name() - query register name from its offset
|
| 744 | * @offset: the offset of a register in struct pt_regs.
|
| 745 | *
|
| 746 | * regs_query_register_name() returns the name of a register from its
|
| 747 | * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
|
| 748 |
|
| 749 | const char *regs_query_register_name(unsigned int offset)
|
| 750 | {
|
| 751 | const struct pt_regs_offset *roff;
|
| 752 | for (roff = regoffset_table; roff->name != NULL; roff++)
|
| 753 | if (roff->offset == offset)
|
| 754 | return roff->name;
|
| 755 | return NULL;
|
| 756 | }
|
| 757 |
|
| 758 | |
| 759 | * regs_within_kernel_stack() - check the address in the stack
|
| 760 | * @regs: pt_regs which contains kernel stack pointer.
|
| 761 | * @addr: address which is checked.
|
| 762 | *
|
| 763 | * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
|
| 764 | * If @addr is within the kernel stack, it returns true. If not, returns false.
|
| 765 |
|
| 766 | int regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
|
| 767 | {
|
| 768 | return ((addr & ~(THREAD_SIZE - 1)) ==
|
| 769 | (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
|
| 770 | }
|
| 771 |
|
| 772 | |
| 773 | * regs_get_kernel_stack_nth() - get Nth entry of the stack
|
| 774 | * @regs: pt_regs which contains kernel stack pointer.
|
| 775 | * @n: stack entry number.
|
| 776 | *
|
| 777 | * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
|
| 778 | * is specified by @regs. If the @n th entry is NOT in the kernel stack,
|
| 779 | * this returns 0.
|
| 780 |
|
| 781 | unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
|
| 782 | {
|
| 783 | unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
|
| 784 |
|
| 785 | addr -= n;
|
| 786 |
|
| 787 | if (!regs_within_kernel_stack(regs, (unsigned long)addr))
|
| 788 | return 0;
|
| 789 |
|
| 790 | return *addr;
|
| 791 | }
|