ptrace.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
  4. */
  5. #include <linux/ptrace.h>
  6. #include <linux/sched/task_stack.h>
  7. #include <linux/regset.h>
  8. #include <linux/unistd.h>
  9. #include <linux/elf.h>
  10. #define CREATE_TRACE_POINTS
  11. #include <trace/events/syscalls.h>
  12. struct pt_regs_offset {
  13. const char *name;
  14. int offset;
  15. };
  16. #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
  17. #define REG_OFFSET_END {.name = NULL, .offset = 0}
  18. #ifdef CONFIG_ISA_ARCOMPACT
  19. static const struct pt_regs_offset regoffset_table[] = {
  20. REG_OFFSET_NAME(bta),
  21. REG_OFFSET_NAME(lp_start),
  22. REG_OFFSET_NAME(lp_end),
  23. REG_OFFSET_NAME(lp_count),
  24. REG_OFFSET_NAME(status32),
  25. REG_OFFSET_NAME(ret),
  26. REG_OFFSET_NAME(blink),
  27. REG_OFFSET_NAME(fp),
  28. REG_OFFSET_NAME(r26),
  29. REG_OFFSET_NAME(r12),
  30. REG_OFFSET_NAME(r11),
  31. REG_OFFSET_NAME(r10),
  32. REG_OFFSET_NAME(r9),
  33. REG_OFFSET_NAME(r8),
  34. REG_OFFSET_NAME(r7),
  35. REG_OFFSET_NAME(r6),
  36. REG_OFFSET_NAME(r5),
  37. REG_OFFSET_NAME(r4),
  38. REG_OFFSET_NAME(r3),
  39. REG_OFFSET_NAME(r2),
  40. REG_OFFSET_NAME(r1),
  41. REG_OFFSET_NAME(r0),
  42. REG_OFFSET_NAME(sp),
  43. REG_OFFSET_NAME(orig_r0),
  44. REG_OFFSET_NAME(event),
  45. REG_OFFSET_NAME(user_r25),
  46. REG_OFFSET_END,
  47. };
  48. #else
  49. static const struct pt_regs_offset regoffset_table[] = {
  50. REG_OFFSET_NAME(orig_r0),
  51. REG_OFFSET_NAME(event),
  52. REG_OFFSET_NAME(bta),
  53. REG_OFFSET_NAME(user_r25),
  54. REG_OFFSET_NAME(r26),
  55. REG_OFFSET_NAME(fp),
  56. REG_OFFSET_NAME(sp),
  57. REG_OFFSET_NAME(r12),
  58. REG_OFFSET_NAME(r30),
  59. #ifdef CONFIG_ARC_HAS_ACCL_REGS
  60. REG_OFFSET_NAME(r58),
  61. REG_OFFSET_NAME(r59),
  62. #endif
  63. #ifdef CONFIG_ARC_DSP_SAVE_RESTORE_REGS
  64. REG_OFFSET_NAME(DSP_CTRL),
  65. #endif
  66. REG_OFFSET_NAME(r0),
  67. REG_OFFSET_NAME(r1),
  68. REG_OFFSET_NAME(r2),
  69. REG_OFFSET_NAME(r3),
  70. REG_OFFSET_NAME(r4),
  71. REG_OFFSET_NAME(r5),
  72. REG_OFFSET_NAME(r6),
  73. REG_OFFSET_NAME(r7),
  74. REG_OFFSET_NAME(r8),
  75. REG_OFFSET_NAME(r9),
  76. REG_OFFSET_NAME(r10),
  77. REG_OFFSET_NAME(r11),
  78. REG_OFFSET_NAME(blink),
  79. REG_OFFSET_NAME(lp_end),
  80. REG_OFFSET_NAME(lp_start),
  81. REG_OFFSET_NAME(lp_count),
  82. REG_OFFSET_NAME(ei),
  83. REG_OFFSET_NAME(ldi),
  84. REG_OFFSET_NAME(jli),
  85. REG_OFFSET_NAME(ret),
  86. REG_OFFSET_NAME(status32),
  87. REG_OFFSET_END,
  88. };
  89. #endif
  90. static struct callee_regs *task_callee_regs(struct task_struct *tsk)
  91. {
  92. struct callee_regs *tmp = (struct callee_regs *)tsk->thread.callee_reg;
  93. return tmp;
  94. }
  95. static int genregs_get(struct task_struct *target,
  96. const struct user_regset *regset,
  97. struct membuf to)
  98. {
  99. const struct pt_regs *ptregs = task_pt_regs(target);
  100. const struct callee_regs *cregs = task_callee_regs(target);
  101. unsigned int stop_pc_val;
  102. membuf_zero(&to, 4); // pad
  103. membuf_store(&to, ptregs->bta);
  104. membuf_store(&to, ptregs->lp_start);
  105. membuf_store(&to, ptregs->lp_end);
  106. membuf_store(&to, ptregs->lp_count);
  107. membuf_store(&to, ptregs->status32);
  108. membuf_store(&to, ptregs->ret);
  109. membuf_store(&to, ptregs->blink);
  110. membuf_store(&to, ptregs->fp);
  111. membuf_store(&to, ptregs->r26); // gp
  112. membuf_store(&to, ptregs->r12);
  113. membuf_store(&to, ptregs->r11);
  114. membuf_store(&to, ptregs->r10);
  115. membuf_store(&to, ptregs->r9);
  116. membuf_store(&to, ptregs->r8);
  117. membuf_store(&to, ptregs->r7);
  118. membuf_store(&to, ptregs->r6);
  119. membuf_store(&to, ptregs->r5);
  120. membuf_store(&to, ptregs->r4);
  121. membuf_store(&to, ptregs->r3);
  122. membuf_store(&to, ptregs->r2);
  123. membuf_store(&to, ptregs->r1);
  124. membuf_store(&to, ptregs->r0);
  125. membuf_store(&to, ptregs->sp);
  126. membuf_zero(&to, 4); // pad2
  127. membuf_store(&to, cregs->r25);
  128. membuf_store(&to, cregs->r24);
  129. membuf_store(&to, cregs->r23);
  130. membuf_store(&to, cregs->r22);
  131. membuf_store(&to, cregs->r21);
  132. membuf_store(&to, cregs->r20);
  133. membuf_store(&to, cregs->r19);
  134. membuf_store(&to, cregs->r18);
  135. membuf_store(&to, cregs->r17);
  136. membuf_store(&to, cregs->r16);
  137. membuf_store(&to, cregs->r15);
  138. membuf_store(&to, cregs->r14);
  139. membuf_store(&to, cregs->r13);
  140. membuf_store(&to, target->thread.fault_address); // efa
  141. if (in_brkpt_trap(ptregs)) {
  142. stop_pc_val = target->thread.fault_address;
  143. pr_debug("\t\tstop_pc (brk-pt)\n");
  144. } else {
  145. stop_pc_val = ptregs->ret;
  146. pr_debug("\t\tstop_pc (others)\n");
  147. }
  148. return membuf_store(&to, stop_pc_val); // stop_pc
  149. }
  150. static int genregs_set(struct task_struct *target,
  151. const struct user_regset *regset,
  152. unsigned int pos, unsigned int count,
  153. const void *kbuf, const void __user *ubuf)
  154. {
  155. const struct pt_regs *ptregs = task_pt_regs(target);
  156. const struct callee_regs *cregs = task_callee_regs(target);
  157. int ret = 0;
  158. #define REG_IN_CHUNK(FIRST, NEXT, PTR) \
  159. if (!ret) \
  160. ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, \
  161. (void *)(PTR), \
  162. offsetof(struct user_regs_struct, FIRST), \
  163. offsetof(struct user_regs_struct, NEXT));
  164. #define REG_IN_ONE(LOC, PTR) \
  165. if (!ret) \
  166. ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, \
  167. (void *)(PTR), \
  168. offsetof(struct user_regs_struct, LOC), \
  169. offsetof(struct user_regs_struct, LOC) + 4);
  170. #define REG_IGNORE_ONE(LOC) \
  171. if (!ret) \
  172. ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, \
  173. offsetof(struct user_regs_struct, LOC), \
  174. offsetof(struct user_regs_struct, LOC) + 4);
  175. REG_IGNORE_ONE(pad);
  176. REG_IN_ONE(scratch.bta, &ptregs->bta);
  177. REG_IN_ONE(scratch.lp_start, &ptregs->lp_start);
  178. REG_IN_ONE(scratch.lp_end, &ptregs->lp_end);
  179. REG_IN_ONE(scratch.lp_count, &ptregs->lp_count);
  180. REG_IGNORE_ONE(scratch.status32);
  181. REG_IN_ONE(scratch.ret, &ptregs->ret);
  182. REG_IN_ONE(scratch.blink, &ptregs->blink);
  183. REG_IN_ONE(scratch.fp, &ptregs->fp);
  184. REG_IN_ONE(scratch.gp, &ptregs->r26);
  185. REG_IN_ONE(scratch.r12, &ptregs->r12);
  186. REG_IN_ONE(scratch.r11, &ptregs->r11);
  187. REG_IN_ONE(scratch.r10, &ptregs->r10);
  188. REG_IN_ONE(scratch.r9, &ptregs->r9);
  189. REG_IN_ONE(scratch.r8, &ptregs->r8);
  190. REG_IN_ONE(scratch.r7, &ptregs->r7);
  191. REG_IN_ONE(scratch.r6, &ptregs->r6);
  192. REG_IN_ONE(scratch.r5, &ptregs->r5);
  193. REG_IN_ONE(scratch.r4, &ptregs->r4);
  194. REG_IN_ONE(scratch.r3, &ptregs->r3);
  195. REG_IN_ONE(scratch.r2, &ptregs->r2);
  196. REG_IN_ONE(scratch.r1, &ptregs->r1);
  197. REG_IN_ONE(scratch.r0, &ptregs->r0);
  198. REG_IN_ONE(scratch.sp, &ptregs->sp);
  199. REG_IGNORE_ONE(pad2);
  200. REG_IN_ONE(callee.r25, &cregs->r25);
  201. REG_IN_ONE(callee.r24, &cregs->r24);
  202. REG_IN_ONE(callee.r23, &cregs->r23);
  203. REG_IN_ONE(callee.r22, &cregs->r22);
  204. REG_IN_ONE(callee.r21, &cregs->r21);
  205. REG_IN_ONE(callee.r20, &cregs->r20);
  206. REG_IN_ONE(callee.r19, &cregs->r19);
  207. REG_IN_ONE(callee.r18, &cregs->r18);
  208. REG_IN_ONE(callee.r17, &cregs->r17);
  209. REG_IN_ONE(callee.r16, &cregs->r16);
  210. REG_IN_ONE(callee.r15, &cregs->r15);
  211. REG_IN_ONE(callee.r14, &cregs->r14);
  212. REG_IN_ONE(callee.r13, &cregs->r13);
  213. REG_IGNORE_ONE(efa); /* efa update invalid */
  214. REG_IGNORE_ONE(stop_pc); /* PC updated via @ret */
  215. return ret;
  216. }
  217. #ifdef CONFIG_ISA_ARCV2
  218. static int arcv2regs_get(struct task_struct *target,
  219. const struct user_regset *regset,
  220. struct membuf to)
  221. {
  222. const struct pt_regs *regs = task_pt_regs(target);
  223. if (IS_ENABLED(CONFIG_ARC_HAS_ACCL_REGS))
  224. /*
  225. * itemized copy not needed like above as layout of regs (r30,r58,r59)
  226. * is exactly same in kernel (pt_regs) and userspace (user_regs_arcv2)
  227. */
  228. return membuf_write(&to, &regs->r30, sizeof(struct user_regs_arcv2));
  229. membuf_write(&to, &regs->r30, 4); /* r30 only */
  230. return membuf_zero(&to, sizeof(struct user_regs_arcv2) - 4);
  231. }
  232. static int arcv2regs_set(struct task_struct *target,
  233. const struct user_regset *regset,
  234. unsigned int pos, unsigned int count,
  235. const void *kbuf, const void __user *ubuf)
  236. {
  237. const struct pt_regs *regs = task_pt_regs(target);
  238. int ret, copy_sz;
  239. if (IS_ENABLED(CONFIG_ARC_HAS_ACCL_REGS))
  240. copy_sz = sizeof(struct user_regs_arcv2);
  241. else
  242. copy_sz = 4; /* r30 only */
  243. ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, (void *)&regs->r30,
  244. 0, copy_sz);
  245. return ret;
  246. }
  247. #endif
  248. enum arc_getset {
  249. REGSET_CMN,
  250. REGSET_ARCV2,
  251. };
  252. static const struct user_regset arc_regsets[] = {
  253. [REGSET_CMN] = {
  254. .core_note_type = NT_PRSTATUS,
  255. .n = ELF_NGREG,
  256. .size = sizeof(unsigned long),
  257. .align = sizeof(unsigned long),
  258. .regset_get = genregs_get,
  259. .set = genregs_set,
  260. },
  261. #ifdef CONFIG_ISA_ARCV2
  262. [REGSET_ARCV2] = {
  263. .core_note_type = NT_ARC_V2,
  264. .n = ELF_ARCV2REG,
  265. .size = sizeof(unsigned long),
  266. .align = sizeof(unsigned long),
  267. .regset_get = arcv2regs_get,
  268. .set = arcv2regs_set,
  269. },
  270. #endif
  271. };
  272. static const struct user_regset_view user_arc_view = {
  273. .name = "arc",
  274. .e_machine = EM_ARC_INUSE,
  275. .regsets = arc_regsets,
  276. .n = ARRAY_SIZE(arc_regsets)
  277. };
  278. const struct user_regset_view *task_user_regset_view(struct task_struct *task)
  279. {
  280. return &user_arc_view;
  281. }
  282. void ptrace_disable(struct task_struct *child)
  283. {
  284. }
  285. long arch_ptrace(struct task_struct *child, long request,
  286. unsigned long addr, unsigned long data)
  287. {
  288. int ret = -EIO;
  289. pr_debug("REQ=%ld: ADDR =0x%lx, DATA=0x%lx)\n", request, addr, data);
  290. switch (request) {
  291. case PTRACE_GET_THREAD_AREA:
  292. ret = put_user(task_thread_info(child)->thr_ptr,
  293. (unsigned long __user *)data);
  294. break;
  295. default:
  296. ret = ptrace_request(child, request, addr, data);
  297. break;
  298. }
  299. return ret;
  300. }
  301. asmlinkage int syscall_trace_entry(struct pt_regs *regs)
  302. {
  303. if (test_thread_flag(TIF_SYSCALL_TRACE))
  304. if (ptrace_report_syscall_entry(regs))
  305. return ULONG_MAX;
  306. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
  307. if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
  308. trace_sys_enter(regs, syscall_get_nr(current, regs));
  309. #endif
  310. return regs->r8;
  311. }
  312. asmlinkage void syscall_trace_exit(struct pt_regs *regs)
  313. {
  314. if (test_thread_flag(TIF_SYSCALL_TRACE))
  315. ptrace_report_syscall_exit(regs, 0);
  316. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
  317. if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
  318. trace_sys_exit(regs, regs_return_value(regs));
  319. #endif
  320. }
  321. int regs_query_register_offset(const char *name)
  322. {
  323. const struct pt_regs_offset *roff;
  324. for (roff = regoffset_table; roff->name != NULL; roff++)
  325. if (!strcmp(roff->name, name))
  326. return roff->offset;
  327. return -EINVAL;
  328. }
  329. const char *regs_query_register_name(unsigned int offset)
  330. {
  331. const struct pt_regs_offset *roff;
  332. for (roff = regoffset_table; roff->name != NULL; roff++)
  333. if (roff->offset == offset)
  334. return roff->name;
  335. return NULL;
  336. }
  337. bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
  338. {
  339. return (addr & ~(THREAD_SIZE - 1)) ==
  340. (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1));
  341. }
  342. unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
  343. {
  344. unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
  345. addr += n;
  346. if (regs_within_kernel_stack(regs, (unsigned long)addr))
  347. return *addr;
  348. else
  349. return 0;
  350. }