1 // SPDX-License-Identifier: GPL-2.0 2 /* ptrace.c: Sparc process tracing support. 3 * 4 * Copyright (C) 1996, 2008 David S. Miller (davem@davemloft.net) 5 * 6 * Based upon code written by Ross Biro, Linus Torvalds, Bob Manson, 7 * and David Mosberger. 8 * 9 * Added Linux support -miguel (weird, eh?, the original code was meant 10 * to emulate SunOS). 11 */ 12 13 #include <linux/kernel.h> 14 #include <linux/sched.h> 15 #include <linux/mm.h> 16 #include <linux/errno.h> 17 #include <linux/ptrace.h> 18 #include <linux/user.h> 19 #include <linux/smp.h> 20 #include <linux/security.h> 21 #include <linux/signal.h> 22 #include <linux/regset.h> 23 #include <linux/elf.h> 24 25 #include <linux/uaccess.h> 26 #include <asm/cacheflush.h> 27 28 #include "kernel.h" 29 30 /* #define ALLOW_INIT_TRACING */ 31 32 /* 33 * Called by kernel/ptrace.c when detaching.. 34 * 35 * Make sure single step bits etc are not set. 36 */ 37 void ptrace_disable(struct task_struct *child) 38 { 39 /* nothing to do */ 40 } 41 42 enum sparc_regset { 43 REGSET_GENERAL, 44 REGSET_FP, 45 }; 46 47 static int regwindow32_get(struct task_struct *target, 48 const struct pt_regs *regs, 49 u32 *uregs) 50 { 51 unsigned long reg_window = regs->u_regs[UREG_I6]; 52 int size = 16 * sizeof(u32); 53 54 if (target == current) { 55 if (copy_from_user(uregs, (void __user *)reg_window, size)) 56 return -EFAULT; 57 } else { 58 if (access_process_vm(target, reg_window, uregs, size, 59 FOLL_FORCE) != size) 60 return -EFAULT; 61 } 62 return 0; 63 } 64 65 static int regwindow32_set(struct task_struct *target, 66 const struct pt_regs *regs, 67 u32 *uregs) 68 { 69 unsigned long reg_window = regs->u_regs[UREG_I6]; 70 int size = 16 * sizeof(u32); 71 72 if (target == current) { 73 if (copy_to_user((void __user *)reg_window, uregs, size)) 74 return -EFAULT; 75 } else { 76 if (access_process_vm(target, reg_window, uregs, size, 77 FOLL_FORCE | FOLL_WRITE) != size) 78 return -EFAULT; 79 } 80 return 0; 81 } 82 83 static int genregs32_get(struct task_struct *target, 84 const struct user_regset *regset, 85 struct membuf to) 86 { 87 const struct pt_regs *regs = target->thread.kregs; 88 u32 uregs[16]; 89 90 if (target == current) 91 flush_user_windows(); 92 93 membuf_write(&to, regs->u_regs, 16 * sizeof(u32)); 94 if (!to.left) 95 return 0; 96 if (regwindow32_get(target, regs, uregs)) 97 return -EFAULT; 98 membuf_write(&to, uregs, 16 * sizeof(u32)); 99 membuf_store(&to, regs->psr); 100 membuf_store(&to, regs->pc); 101 membuf_store(&to, regs->npc); 102 membuf_store(&to, regs->y); 103 return membuf_zero(&to, 2 * sizeof(u32)); 104 } 105 106 static int genregs32_set(struct task_struct *target, 107 const struct user_regset *regset, 108 unsigned int pos, unsigned int count, 109 const void *kbuf, const void __user *ubuf) 110 { 111 struct pt_regs *regs = target->thread.kregs; 112 u32 uregs[16]; 113 u32 psr; 114 int ret; 115 116 if (target == current) 117 flush_user_windows(); 118 119 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 120 regs->u_regs, 121 0, 16 * sizeof(u32)); 122 if (ret || !count) 123 return ret; 124 125 if (regwindow32_get(target, regs, uregs)) 126 return -EFAULT; 127 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 128 uregs, 129 16 * sizeof(u32), 32 * sizeof(u32)); 130 if (ret) 131 return ret; 132 if (regwindow32_set(target, regs, uregs)) 133 return -EFAULT; 134 if (!count) 135 return 0; 136 137 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 138 &psr, 139 32 * sizeof(u32), 33 * sizeof(u32)); 140 if (ret) 141 return ret; 142 regs->psr = (regs->psr & ~(PSR_ICC | PSR_SYSCALL)) | 143 (psr & (PSR_ICC | PSR_SYSCALL)); 144 if (!count) 145 return 0; 146 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 147 ®s->pc, 148 33 * sizeof(u32), 34 * sizeof(u32)); 149 if (ret || !count) 150 return ret; 151 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 152 ®s->npc, 153 34 * sizeof(u32), 35 * sizeof(u32)); 154 if (ret || !count) 155 return ret; 156 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 157 ®s->y, 158 35 * sizeof(u32), 36 * sizeof(u32)); 159 if (ret || !count) 160 return ret; 161 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, 36 * sizeof(u32), 162 38 * sizeof(u32)); 163 return 0; 164 } 165 166 static int fpregs32_get(struct task_struct *target, 167 const struct user_regset *regset, 168 struct membuf to) 169 { 170 #if 0 171 if (target == current) 172 save_and_clear_fpu(); 173 #endif 174 175 membuf_write(&to, target->thread.float_regs, 32 * sizeof(u32)); 176 membuf_zero(&to, sizeof(u32)); 177 membuf_write(&to, &target->thread.fsr, sizeof(u32)); 178 membuf_store(&to, (u32)((1 << 8) | (8 << 16))); 179 return membuf_zero(&to, 64 * sizeof(u32)); 180 } 181 182 static int fpregs32_set(struct task_struct *target, 183 const struct user_regset *regset, 184 unsigned int pos, unsigned int count, 185 const void *kbuf, const void __user *ubuf) 186 { 187 unsigned long *fpregs = target->thread.float_regs; 188 int ret; 189 190 #if 0 191 if (target == current) 192 save_and_clear_fpu(); 193 #endif 194 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 195 fpregs, 196 0, 32 * sizeof(u32)); 197 if (!ret) 198 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, 199 32 * sizeof(u32), 200 33 * sizeof(u32)); 201 if (!ret) 202 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 203 &target->thread.fsr, 204 33 * sizeof(u32), 205 34 * sizeof(u32)); 206 if (!ret) 207 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, 208 34 * sizeof(u32), -1); 209 return ret; 210 } 211 212 static const struct user_regset sparc32_regsets[] = { 213 /* Format is: 214 * G0 --> G7 215 * O0 --> O7 216 * L0 --> L7 217 * I0 --> I7 218 * PSR, PC, nPC, Y, WIM, TBR 219 */ 220 [REGSET_GENERAL] = { 221 .core_note_type = NT_PRSTATUS, 222 .n = 38, 223 .size = sizeof(u32), .align = sizeof(u32), 224 .regset_get = genregs32_get, .set = genregs32_set 225 }, 226 /* Format is: 227 * F0 --> F31 228 * empty 32-bit word 229 * FSR (32--bit word) 230 * FPU QUEUE COUNT (8-bit char) 231 * FPU QUEUE ENTRYSIZE (8-bit char) 232 * FPU ENABLED (8-bit char) 233 * empty 8-bit char 234 * FPU QUEUE (64 32-bit ints) 235 */ 236 [REGSET_FP] = { 237 .core_note_type = NT_PRFPREG, 238 .n = 99, 239 .size = sizeof(u32), .align = sizeof(u32), 240 .regset_get = fpregs32_get, .set = fpregs32_set 241 }, 242 }; 243 244 static int getregs_get(struct task_struct *target, 245 const struct user_regset *regset, 246 struct membuf to) 247 { 248 const struct pt_regs *regs = target->thread.kregs; 249 250 if (target == current) 251 flush_user_windows(); 252 253 membuf_store(&to, regs->psr); 254 membuf_store(&to, regs->pc); 255 membuf_store(&to, regs->npc); 256 membuf_store(&to, regs->y); 257 return membuf_write(&to, regs->u_regs + 1, 15 * sizeof(u32)); 258 } 259 260 static int setregs_set(struct task_struct *target, 261 const struct user_regset *regset, 262 unsigned int pos, unsigned int count, 263 const void *kbuf, const void __user *ubuf) 264 { 265 struct pt_regs *regs = target->thread.kregs; 266 u32 v[4]; 267 int ret; 268 269 if (target == current) 270 flush_user_windows(); 271 272 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 273 v, 274 0, 4 * sizeof(u32)); 275 if (ret) 276 return ret; 277 regs->psr = (regs->psr & ~(PSR_ICC | PSR_SYSCALL)) | 278 (v[0] & (PSR_ICC | PSR_SYSCALL)); 279 regs->pc = v[1]; 280 regs->npc = v[2]; 281 regs->y = v[3]; 282 return user_regset_copyin(&pos, &count, &kbuf, &ubuf, 283 regs->u_regs + 1, 284 4 * sizeof(u32) , 19 * sizeof(u32)); 285 } 286 287 static int getfpregs_get(struct task_struct *target, 288 const struct user_regset *regset, 289 struct membuf to) 290 { 291 #if 0 292 if (target == current) 293 save_and_clear_fpu(); 294 #endif 295 membuf_write(&to, &target->thread.float_regs, 32 * sizeof(u32)); 296 membuf_write(&to, &target->thread.fsr, sizeof(u32)); 297 return membuf_zero(&to, 35 * sizeof(u32)); 298 } 299 300 static int setfpregs_set(struct task_struct *target, 301 const struct user_regset *regset, 302 unsigned int pos, unsigned int count, 303 const void *kbuf, const void __user *ubuf) 304 { 305 unsigned long *fpregs = target->thread.float_regs; 306 int ret; 307 308 #if 0 309 if (target == current) 310 save_and_clear_fpu(); 311 #endif 312 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, 313 fpregs, 314 0, 32 * sizeof(u32)); 315 if (ret) 316 return ret; 317 return user_regset_copyin(&pos, &count, &kbuf, &ubuf, 318 &target->thread.fsr, 319 32 * sizeof(u32), 320 33 * sizeof(u32)); 321 } 322 323 static const struct user_regset ptrace32_regsets[] = { 324 [REGSET_GENERAL] = { 325 .n = 19, .size = sizeof(u32), 326 .regset_get = getregs_get, .set = setregs_set, 327 }, 328 [REGSET_FP] = { 329 .n = 68, .size = sizeof(u32), 330 .regset_get = getfpregs_get, .set = setfpregs_set, 331 }, 332 }; 333 334 static const struct user_regset_view ptrace32_view = { 335 .regsets = ptrace32_regsets, .n = ARRAY_SIZE(ptrace32_regsets) 336 }; 337 338 static const struct user_regset_view user_sparc32_view = { 339 .name = "sparc", .e_machine = EM_SPARC, 340 .regsets = sparc32_regsets, .n = ARRAY_SIZE(sparc32_regsets) 341 }; 342 343 const struct user_regset_view *task_user_regset_view(struct task_struct *task) 344 { 345 return &user_sparc32_view; 346 } 347 348 struct fps { 349 unsigned long regs[32]; 350 unsigned long fsr; 351 unsigned long flags; 352 unsigned long extra; 353 unsigned long fpqd; 354 struct fq { 355 unsigned long *insnaddr; 356 unsigned long insn; 357 } fpq[16]; 358 }; 359 360 long arch_ptrace(struct task_struct *child, long request, 361 unsigned long addr, unsigned long data) 362 { 363 unsigned long addr2 = current->thread.kregs->u_regs[UREG_I4]; 364 void __user *addr2p; 365 struct pt_regs __user *pregs; 366 struct fps __user *fps; 367 int ret; 368 369 addr2p = (void __user *) addr2; 370 pregs = (struct pt_regs __user *) addr; 371 fps = (struct fps __user *) addr; 372 373 switch(request) { 374 case PTRACE_GETREGS: { 375 ret = copy_regset_to_user(child, &ptrace32_view, 376 REGSET_GENERAL, 0, 377 19 * sizeof(u32), 378 pregs); 379 break; 380 } 381 382 case PTRACE_SETREGS: { 383 ret = copy_regset_from_user(child, &ptrace32_view, 384 REGSET_GENERAL, 0, 385 19 * sizeof(u32), 386 pregs); 387 break; 388 } 389 390 case PTRACE_GETFPREGS: { 391 ret = copy_regset_to_user(child, &ptrace32_view, 392 REGSET_FP, 0, 393 68 * sizeof(u32), 394 fps); 395 break; 396 } 397 398 case PTRACE_SETFPREGS: { 399 ret = copy_regset_from_user(child, &ptrace32_view, 400 REGSET_FP, 0, 401 33 * sizeof(u32), 402 fps); 403 break; 404 } 405 406 case PTRACE_READTEXT: 407 case PTRACE_READDATA: 408 ret = ptrace_readdata(child, addr, addr2p, data); 409 410 if (ret == data) 411 ret = 0; 412 else if (ret >= 0) 413 ret = -EIO; 414 break; 415 416 case PTRACE_WRITETEXT: 417 case PTRACE_WRITEDATA: 418 ret = ptrace_writedata(child, addr2p, addr, data); 419 420 if (ret == data) 421 ret = 0; 422 else if (ret >= 0) 423 ret = -EIO; 424 break; 425 426 default: 427 if (request == PTRACE_SPARC_DETACH) 428 request = PTRACE_DETACH; 429 ret = ptrace_request(child, request, addr, data); 430 break; 431 } 432 433 return ret; 434 } 435 436 asmlinkage int syscall_trace(struct pt_regs *regs, int syscall_exit_p) 437 { 438 int ret = 0; 439 440 if (test_thread_flag(TIF_SYSCALL_TRACE)) { 441 if (syscall_exit_p) 442 ptrace_report_syscall_exit(regs, 0); 443 else 444 ret = ptrace_report_syscall_entry(regs); 445 } 446 447 return ret; 448 } 449