ptrace_32.c 10 KB

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