ptrace.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769
  1. /*
  2. * arch/s390/kernel/ptrace.c
  3. *
  4. * S390 version
  5. * Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6. * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
  7. * Martin Schwidefsky (schwidefsky@de.ibm.com)
  8. *
  9. * Based on PowerPC version
  10. * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
  11. *
  12. * Derived from "arch/m68k/kernel/ptrace.c"
  13. * Copyright (C) 1994 by Hamish Macdonald
  14. * Taken from linux/kernel/ptrace.c and modified for M680x0.
  15. * linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
  16. *
  17. * Modified by Cort Dougan (cort@cs.nmt.edu)
  18. *
  19. *
  20. * This file is subject to the terms and conditions of the GNU General
  21. * Public License. See the file README.legal in the main directory of
  22. * this archive for more details.
  23. */
  24. #include <linux/kernel.h>
  25. #include <linux/sched.h>
  26. #include <linux/mm.h>
  27. #include <linux/smp.h>
  28. #include <linux/smp_lock.h>
  29. #include <linux/errno.h>
  30. #include <linux/ptrace.h>
  31. #include <linux/user.h>
  32. #include <linux/security.h>
  33. #include <linux/audit.h>
  34. #include <linux/signal.h>
  35. #include <asm/segment.h>
  36. #include <asm/page.h>
  37. #include <asm/pgtable.h>
  38. #include <asm/pgalloc.h>
  39. #include <asm/system.h>
  40. #include <asm/uaccess.h>
  41. #include <asm/unistd.h>
  42. #ifdef CONFIG_COMPAT
  43. #include "compat_ptrace.h"
  44. #endif
  45. static void
  46. FixPerRegisters(struct task_struct *task)
  47. {
  48. struct pt_regs *regs;
  49. per_struct *per_info;
  50. regs = task_pt_regs(task);
  51. per_info = (per_struct *) &task->thread.per_info;
  52. per_info->control_regs.bits.em_instruction_fetch =
  53. per_info->single_step | per_info->instruction_fetch;
  54. if (per_info->single_step) {
  55. per_info->control_regs.bits.starting_addr = 0;
  56. #ifdef CONFIG_COMPAT
  57. if (test_thread_flag(TIF_31BIT))
  58. per_info->control_regs.bits.ending_addr = 0x7fffffffUL;
  59. else
  60. #endif
  61. per_info->control_regs.bits.ending_addr = PSW_ADDR_INSN;
  62. } else {
  63. per_info->control_regs.bits.starting_addr =
  64. per_info->starting_addr;
  65. per_info->control_regs.bits.ending_addr =
  66. per_info->ending_addr;
  67. }
  68. /*
  69. * if any of the control reg tracing bits are on
  70. * we switch on per in the psw
  71. */
  72. if (per_info->control_regs.words.cr[0] & PER_EM_MASK)
  73. regs->psw.mask |= PSW_MASK_PER;
  74. else
  75. regs->psw.mask &= ~PSW_MASK_PER;
  76. if (per_info->control_regs.bits.em_storage_alteration)
  77. per_info->control_regs.bits.storage_alt_space_ctl = 1;
  78. else
  79. per_info->control_regs.bits.storage_alt_space_ctl = 0;
  80. }
  81. static void set_single_step(struct task_struct *task)
  82. {
  83. task->thread.per_info.single_step = 1;
  84. FixPerRegisters(task);
  85. }
  86. static void clear_single_step(struct task_struct *task)
  87. {
  88. task->thread.per_info.single_step = 0;
  89. FixPerRegisters(task);
  90. }
  91. /*
  92. * Called by kernel/ptrace.c when detaching..
  93. *
  94. * Make sure single step bits etc are not set.
  95. */
  96. void
  97. ptrace_disable(struct task_struct *child)
  98. {
  99. /* make sure the single step bit is not set. */
  100. clear_single_step(child);
  101. }
  102. #ifndef CONFIG_64BIT
  103. # define __ADDR_MASK 3
  104. #else
  105. # define __ADDR_MASK 7
  106. #endif
  107. /*
  108. * Read the word at offset addr from the user area of a process. The
  109. * trouble here is that the information is littered over different
  110. * locations. The process registers are found on the kernel stack,
  111. * the floating point stuff and the trace settings are stored in
  112. * the task structure. In addition the different structures in
  113. * struct user contain pad bytes that should be read as zeroes.
  114. * Lovely...
  115. */
  116. static int
  117. peek_user(struct task_struct *child, addr_t addr, addr_t data)
  118. {
  119. struct user *dummy = NULL;
  120. addr_t offset, tmp, mask;
  121. /*
  122. * Stupid gdb peeks/pokes the access registers in 64 bit with
  123. * an alignment of 4. Programmers from hell...
  124. */
  125. mask = __ADDR_MASK;
  126. #ifdef CONFIG_64BIT
  127. if (addr >= (addr_t) &dummy->regs.acrs &&
  128. addr < (addr_t) &dummy->regs.orig_gpr2)
  129. mask = 3;
  130. #endif
  131. if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
  132. return -EIO;
  133. if (addr < (addr_t) &dummy->regs.acrs) {
  134. /*
  135. * psw and gprs are stored on the stack
  136. */
  137. tmp = *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr);
  138. if (addr == (addr_t) &dummy->regs.psw.mask)
  139. /* Remove per bit from user psw. */
  140. tmp &= ~PSW_MASK_PER;
  141. } else if (addr < (addr_t) &dummy->regs.orig_gpr2) {
  142. /*
  143. * access registers are stored in the thread structure
  144. */
  145. offset = addr - (addr_t) &dummy->regs.acrs;
  146. #ifdef CONFIG_64BIT
  147. /*
  148. * Very special case: old & broken 64 bit gdb reading
  149. * from acrs[15]. Result is a 64 bit value. Read the
  150. * 32 bit acrs[15] value and shift it by 32. Sick...
  151. */
  152. if (addr == (addr_t) &dummy->regs.acrs[15])
  153. tmp = ((unsigned long) child->thread.acrs[15]) << 32;
  154. else
  155. #endif
  156. tmp = *(addr_t *)((addr_t) &child->thread.acrs + offset);
  157. } else if (addr == (addr_t) &dummy->regs.orig_gpr2) {
  158. /*
  159. * orig_gpr2 is stored on the kernel stack
  160. */
  161. tmp = (addr_t) task_pt_regs(child)->orig_gpr2;
  162. } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) {
  163. /*
  164. * floating point regs. are stored in the thread structure
  165. */
  166. offset = addr - (addr_t) &dummy->regs.fp_regs;
  167. tmp = *(addr_t *)((addr_t) &child->thread.fp_regs + offset);
  168. if (addr == (addr_t) &dummy->regs.fp_regs.fpc)
  169. tmp &= (unsigned long) FPC_VALID_MASK
  170. << (BITS_PER_LONG - 32);
  171. } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) {
  172. /*
  173. * per_info is found in the thread structure
  174. */
  175. offset = addr - (addr_t) &dummy->regs.per_info;
  176. tmp = *(addr_t *)((addr_t) &child->thread.per_info + offset);
  177. } else
  178. tmp = 0;
  179. return put_user(tmp, (addr_t __user *) data);
  180. }
  181. /*
  182. * Write a word to the user area of a process at location addr. This
  183. * operation does have an additional problem compared to peek_user.
  184. * Stores to the program status word and on the floating point
  185. * control register needs to get checked for validity.
  186. */
  187. static int
  188. poke_user(struct task_struct *child, addr_t addr, addr_t data)
  189. {
  190. struct user *dummy = NULL;
  191. addr_t offset, mask;
  192. /*
  193. * Stupid gdb peeks/pokes the access registers in 64 bit with
  194. * an alignment of 4. Programmers from hell indeed...
  195. */
  196. mask = __ADDR_MASK;
  197. #ifdef CONFIG_64BIT
  198. if (addr >= (addr_t) &dummy->regs.acrs &&
  199. addr < (addr_t) &dummy->regs.orig_gpr2)
  200. mask = 3;
  201. #endif
  202. if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
  203. return -EIO;
  204. if (addr < (addr_t) &dummy->regs.acrs) {
  205. /*
  206. * psw and gprs are stored on the stack
  207. */
  208. if (addr == (addr_t) &dummy->regs.psw.mask &&
  209. #ifdef CONFIG_COMPAT
  210. data != PSW_MASK_MERGE(psw_user32_bits, data) &&
  211. #endif
  212. data != PSW_MASK_MERGE(psw_user_bits, data))
  213. /* Invalid psw mask. */
  214. return -EINVAL;
  215. #ifndef CONFIG_64BIT
  216. if (addr == (addr_t) &dummy->regs.psw.addr)
  217. /* I'd like to reject addresses without the
  218. high order bit but older gdb's rely on it */
  219. data |= PSW_ADDR_AMODE;
  220. #endif
  221. *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr) = data;
  222. } else if (addr < (addr_t) (&dummy->regs.orig_gpr2)) {
  223. /*
  224. * access registers are stored in the thread structure
  225. */
  226. offset = addr - (addr_t) &dummy->regs.acrs;
  227. #ifdef CONFIG_64BIT
  228. /*
  229. * Very special case: old & broken 64 bit gdb writing
  230. * to acrs[15] with a 64 bit value. Ignore the lower
  231. * half of the value and write the upper 32 bit to
  232. * acrs[15]. Sick...
  233. */
  234. if (addr == (addr_t) &dummy->regs.acrs[15])
  235. child->thread.acrs[15] = (unsigned int) (data >> 32);
  236. else
  237. #endif
  238. *(addr_t *)((addr_t) &child->thread.acrs + offset) = data;
  239. } else if (addr == (addr_t) &dummy->regs.orig_gpr2) {
  240. /*
  241. * orig_gpr2 is stored on the kernel stack
  242. */
  243. task_pt_regs(child)->orig_gpr2 = data;
  244. } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) {
  245. /*
  246. * floating point regs. are stored in the thread structure
  247. */
  248. if (addr == (addr_t) &dummy->regs.fp_regs.fpc &&
  249. (data & ~((unsigned long) FPC_VALID_MASK
  250. << (BITS_PER_LONG - 32))) != 0)
  251. return -EINVAL;
  252. offset = addr - (addr_t) &dummy->regs.fp_regs;
  253. *(addr_t *)((addr_t) &child->thread.fp_regs + offset) = data;
  254. } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) {
  255. /*
  256. * per_info is found in the thread structure
  257. */
  258. offset = addr - (addr_t) &dummy->regs.per_info;
  259. *(addr_t *)((addr_t) &child->thread.per_info + offset) = data;
  260. }
  261. FixPerRegisters(child);
  262. return 0;
  263. }
  264. static int
  265. do_ptrace_normal(struct task_struct *child, long request, long addr, long data)
  266. {
  267. unsigned long tmp;
  268. ptrace_area parea;
  269. int copied, ret;
  270. switch (request) {
  271. case PTRACE_PEEKTEXT:
  272. case PTRACE_PEEKDATA:
  273. /* Remove high order bit from address (only for 31 bit). */
  274. addr &= PSW_ADDR_INSN;
  275. /* read word at location addr. */
  276. copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
  277. if (copied != sizeof(tmp))
  278. return -EIO;
  279. return put_user(tmp, (unsigned long __force __user *) data);
  280. case PTRACE_PEEKUSR:
  281. /* read the word at location addr in the USER area. */
  282. return peek_user(child, addr, data);
  283. case PTRACE_POKETEXT:
  284. case PTRACE_POKEDATA:
  285. /* Remove high order bit from address (only for 31 bit). */
  286. addr &= PSW_ADDR_INSN;
  287. /* write the word at location addr. */
  288. copied = access_process_vm(child, addr, &data, sizeof(data),1);
  289. if (copied != sizeof(data))
  290. return -EIO;
  291. return 0;
  292. case PTRACE_POKEUSR:
  293. /* write the word at location addr in the USER area */
  294. return poke_user(child, addr, data);
  295. case PTRACE_PEEKUSR_AREA:
  296. case PTRACE_POKEUSR_AREA:
  297. if (copy_from_user(&parea, (void __force __user *) addr,
  298. sizeof(parea)))
  299. return -EFAULT;
  300. addr = parea.kernel_addr;
  301. data = parea.process_addr;
  302. copied = 0;
  303. while (copied < parea.len) {
  304. if (request == PTRACE_PEEKUSR_AREA)
  305. ret = peek_user(child, addr, data);
  306. else {
  307. addr_t utmp;
  308. if (get_user(utmp,
  309. (addr_t __force __user *) data))
  310. return -EFAULT;
  311. ret = poke_user(child, addr, utmp);
  312. }
  313. if (ret)
  314. return ret;
  315. addr += sizeof(unsigned long);
  316. data += sizeof(unsigned long);
  317. copied += sizeof(unsigned long);
  318. }
  319. return 0;
  320. }
  321. return ptrace_request(child, request, addr, data);
  322. }
  323. #ifdef CONFIG_COMPAT
  324. /*
  325. * Now the fun part starts... a 31 bit program running in the
  326. * 31 bit emulation tracing another program. PTRACE_PEEKTEXT,
  327. * PTRACE_PEEKDATA, PTRACE_POKETEXT and PTRACE_POKEDATA are easy
  328. * to handle, the difference to the 64 bit versions of the requests
  329. * is that the access is done in multiples of 4 byte instead of
  330. * 8 bytes (sizeof(unsigned long) on 31/64 bit).
  331. * The ugly part are PTRACE_PEEKUSR, PTRACE_PEEKUSR_AREA,
  332. * PTRACE_POKEUSR and PTRACE_POKEUSR_AREA. If the traced program
  333. * is a 31 bit program too, the content of struct user can be
  334. * emulated. A 31 bit program peeking into the struct user of
  335. * a 64 bit program is a no-no.
  336. */
  337. /*
  338. * Same as peek_user but for a 31 bit program.
  339. */
  340. static int
  341. peek_user_emu31(struct task_struct *child, addr_t addr, addr_t data)
  342. {
  343. struct user32 *dummy32 = NULL;
  344. per_struct32 *dummy_per32 = NULL;
  345. addr_t offset;
  346. __u32 tmp;
  347. if (!test_thread_flag(TIF_31BIT) ||
  348. (addr & 3) || addr > sizeof(struct user) - 3)
  349. return -EIO;
  350. if (addr < (addr_t) &dummy32->regs.acrs) {
  351. /*
  352. * psw and gprs are stored on the stack
  353. */
  354. if (addr == (addr_t) &dummy32->regs.psw.mask) {
  355. /* Fake a 31 bit psw mask. */
  356. tmp = (__u32)(task_pt_regs(child)->psw.mask >> 32);
  357. tmp = PSW32_MASK_MERGE(psw32_user_bits, tmp);
  358. } else if (addr == (addr_t) &dummy32->regs.psw.addr) {
  359. /* Fake a 31 bit psw address. */
  360. tmp = (__u32) task_pt_regs(child)->psw.addr |
  361. PSW32_ADDR_AMODE31;
  362. } else {
  363. /* gpr 0-15 */
  364. tmp = *(__u32 *)((addr_t) &task_pt_regs(child)->psw +
  365. addr*2 + 4);
  366. }
  367. } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) {
  368. /*
  369. * access registers are stored in the thread structure
  370. */
  371. offset = addr - (addr_t) &dummy32->regs.acrs;
  372. tmp = *(__u32*)((addr_t) &child->thread.acrs + offset);
  373. } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) {
  374. /*
  375. * orig_gpr2 is stored on the kernel stack
  376. */
  377. tmp = *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4);
  378. } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) {
  379. /*
  380. * floating point regs. are stored in the thread structure
  381. */
  382. offset = addr - (addr_t) &dummy32->regs.fp_regs;
  383. tmp = *(__u32 *)((addr_t) &child->thread.fp_regs + offset);
  384. } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) {
  385. /*
  386. * per_info is found in the thread structure
  387. */
  388. offset = addr - (addr_t) &dummy32->regs.per_info;
  389. /* This is magic. See per_struct and per_struct32. */
  390. if ((offset >= (addr_t) &dummy_per32->control_regs &&
  391. offset < (addr_t) (&dummy_per32->control_regs + 1)) ||
  392. (offset >= (addr_t) &dummy_per32->starting_addr &&
  393. offset <= (addr_t) &dummy_per32->ending_addr) ||
  394. offset == (addr_t) &dummy_per32->lowcore.words.address)
  395. offset = offset*2 + 4;
  396. else
  397. offset = offset*2;
  398. tmp = *(__u32 *)((addr_t) &child->thread.per_info + offset);
  399. } else
  400. tmp = 0;
  401. return put_user(tmp, (__u32 __user *) data);
  402. }
  403. /*
  404. * Same as poke_user but for a 31 bit program.
  405. */
  406. static int
  407. poke_user_emu31(struct task_struct *child, addr_t addr, addr_t data)
  408. {
  409. struct user32 *dummy32 = NULL;
  410. per_struct32 *dummy_per32 = NULL;
  411. addr_t offset;
  412. __u32 tmp;
  413. if (!test_thread_flag(TIF_31BIT) ||
  414. (addr & 3) || addr > sizeof(struct user32) - 3)
  415. return -EIO;
  416. tmp = (__u32) data;
  417. if (addr < (addr_t) &dummy32->regs.acrs) {
  418. /*
  419. * psw, gprs, acrs and orig_gpr2 are stored on the stack
  420. */
  421. if (addr == (addr_t) &dummy32->regs.psw.mask) {
  422. /* Build a 64 bit psw mask from 31 bit mask. */
  423. if (tmp != PSW32_MASK_MERGE(psw32_user_bits, tmp))
  424. /* Invalid psw mask. */
  425. return -EINVAL;
  426. task_pt_regs(child)->psw.mask =
  427. PSW_MASK_MERGE(psw_user32_bits, (__u64) tmp << 32);
  428. } else if (addr == (addr_t) &dummy32->regs.psw.addr) {
  429. /* Build a 64 bit psw address from 31 bit address. */
  430. task_pt_regs(child)->psw.addr =
  431. (__u64) tmp & PSW32_ADDR_INSN;
  432. } else {
  433. /* gpr 0-15 */
  434. *(__u32*)((addr_t) &task_pt_regs(child)->psw
  435. + addr*2 + 4) = tmp;
  436. }
  437. } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) {
  438. /*
  439. * access registers are stored in the thread structure
  440. */
  441. offset = addr - (addr_t) &dummy32->regs.acrs;
  442. *(__u32*)((addr_t) &child->thread.acrs + offset) = tmp;
  443. } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) {
  444. /*
  445. * orig_gpr2 is stored on the kernel stack
  446. */
  447. *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4) = tmp;
  448. } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) {
  449. /*
  450. * floating point regs. are stored in the thread structure
  451. */
  452. if (addr == (addr_t) &dummy32->regs.fp_regs.fpc &&
  453. (tmp & ~FPC_VALID_MASK) != 0)
  454. /* Invalid floating point control. */
  455. return -EINVAL;
  456. offset = addr - (addr_t) &dummy32->regs.fp_regs;
  457. *(__u32 *)((addr_t) &child->thread.fp_regs + offset) = tmp;
  458. } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) {
  459. /*
  460. * per_info is found in the thread structure.
  461. */
  462. offset = addr - (addr_t) &dummy32->regs.per_info;
  463. /*
  464. * This is magic. See per_struct and per_struct32.
  465. * By incident the offsets in per_struct are exactly
  466. * twice the offsets in per_struct32 for all fields.
  467. * The 8 byte fields need special handling though,
  468. * because the second half (bytes 4-7) is needed and
  469. * not the first half.
  470. */
  471. if ((offset >= (addr_t) &dummy_per32->control_regs &&
  472. offset < (addr_t) (&dummy_per32->control_regs + 1)) ||
  473. (offset >= (addr_t) &dummy_per32->starting_addr &&
  474. offset <= (addr_t) &dummy_per32->ending_addr) ||
  475. offset == (addr_t) &dummy_per32->lowcore.words.address)
  476. offset = offset*2 + 4;
  477. else
  478. offset = offset*2;
  479. *(__u32 *)((addr_t) &child->thread.per_info + offset) = tmp;
  480. }
  481. FixPerRegisters(child);
  482. return 0;
  483. }
  484. static int
  485. do_ptrace_emu31(struct task_struct *child, long request, long addr, long data)
  486. {
  487. unsigned int tmp; /* 4 bytes !! */
  488. ptrace_area_emu31 parea;
  489. int copied, ret;
  490. switch (request) {
  491. case PTRACE_PEEKTEXT:
  492. case PTRACE_PEEKDATA:
  493. /* read word at location addr. */
  494. copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
  495. if (copied != sizeof(tmp))
  496. return -EIO;
  497. return put_user(tmp, (unsigned int __force __user *) data);
  498. case PTRACE_PEEKUSR:
  499. /* read the word at location addr in the USER area. */
  500. return peek_user_emu31(child, addr, data);
  501. case PTRACE_POKETEXT:
  502. case PTRACE_POKEDATA:
  503. /* write the word at location addr. */
  504. tmp = data;
  505. copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 1);
  506. if (copied != sizeof(tmp))
  507. return -EIO;
  508. return 0;
  509. case PTRACE_POKEUSR:
  510. /* write the word at location addr in the USER area */
  511. return poke_user_emu31(child, addr, data);
  512. case PTRACE_PEEKUSR_AREA:
  513. case PTRACE_POKEUSR_AREA:
  514. if (copy_from_user(&parea, (void __force __user *) addr,
  515. sizeof(parea)))
  516. return -EFAULT;
  517. addr = parea.kernel_addr;
  518. data = parea.process_addr;
  519. copied = 0;
  520. while (copied < parea.len) {
  521. if (request == PTRACE_PEEKUSR_AREA)
  522. ret = peek_user_emu31(child, addr, data);
  523. else {
  524. __u32 utmp;
  525. if (get_user(utmp,
  526. (__u32 __force __user *) data))
  527. return -EFAULT;
  528. ret = poke_user_emu31(child, addr, utmp);
  529. }
  530. if (ret)
  531. return ret;
  532. addr += sizeof(unsigned int);
  533. data += sizeof(unsigned int);
  534. copied += sizeof(unsigned int);
  535. }
  536. return 0;
  537. case PTRACE_GETEVENTMSG:
  538. return put_user((__u32) child->ptrace_message,
  539. (unsigned int __force __user *) data);
  540. case PTRACE_GETSIGINFO:
  541. if (child->last_siginfo == NULL)
  542. return -EINVAL;
  543. return copy_siginfo_to_user32((compat_siginfo_t
  544. __force __user *) data,
  545. child->last_siginfo);
  546. case PTRACE_SETSIGINFO:
  547. if (child->last_siginfo == NULL)
  548. return -EINVAL;
  549. return copy_siginfo_from_user32(child->last_siginfo,
  550. (compat_siginfo_t
  551. __force __user *) data);
  552. }
  553. return ptrace_request(child, request, addr, data);
  554. }
  555. #endif
  556. #define PT32_IEEE_IP 0x13c
  557. static int
  558. do_ptrace(struct task_struct *child, long request, long addr, long data)
  559. {
  560. int ret;
  561. if (request == PTRACE_ATTACH)
  562. return ptrace_attach(child);
  563. /*
  564. * Special cases to get/store the ieee instructions pointer.
  565. */
  566. if (child == current) {
  567. if (request == PTRACE_PEEKUSR && addr == PT_IEEE_IP)
  568. return peek_user(child, addr, data);
  569. if (request == PTRACE_POKEUSR && addr == PT_IEEE_IP)
  570. return poke_user(child, addr, data);
  571. #ifdef CONFIG_COMPAT
  572. if (request == PTRACE_PEEKUSR &&
  573. addr == PT32_IEEE_IP && test_thread_flag(TIF_31BIT))
  574. return peek_user_emu31(child, addr, data);
  575. if (request == PTRACE_POKEUSR &&
  576. addr == PT32_IEEE_IP && test_thread_flag(TIF_31BIT))
  577. return poke_user_emu31(child, addr, data);
  578. #endif
  579. }
  580. ret = ptrace_check_attach(child, request == PTRACE_KILL);
  581. if (ret < 0)
  582. return ret;
  583. switch (request) {
  584. case PTRACE_SYSCALL:
  585. /* continue and stop at next (return from) syscall */
  586. case PTRACE_CONT:
  587. /* restart after signal. */
  588. if (!valid_signal(data))
  589. return -EIO;
  590. if (request == PTRACE_SYSCALL)
  591. set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
  592. else
  593. clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
  594. child->exit_code = data;
  595. /* make sure the single step bit is not set. */
  596. clear_single_step(child);
  597. wake_up_process(child);
  598. return 0;
  599. case PTRACE_KILL:
  600. /*
  601. * make the child exit. Best I can do is send it a sigkill.
  602. * perhaps it should be put in the status that it wants to
  603. * exit.
  604. */
  605. if (child->exit_state == EXIT_ZOMBIE) /* already dead */
  606. return 0;
  607. child->exit_code = SIGKILL;
  608. /* make sure the single step bit is not set. */
  609. clear_single_step(child);
  610. wake_up_process(child);
  611. return 0;
  612. case PTRACE_SINGLESTEP:
  613. /* set the trap flag. */
  614. if (!valid_signal(data))
  615. return -EIO;
  616. clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
  617. child->exit_code = data;
  618. if (data)
  619. set_tsk_thread_flag(child, TIF_SINGLE_STEP);
  620. else
  621. set_single_step(child);
  622. /* give it a chance to run. */
  623. wake_up_process(child);
  624. return 0;
  625. case PTRACE_DETACH:
  626. /* detach a process that was attached. */
  627. return ptrace_detach(child, data);
  628. /* Do requests that differ for 31/64 bit */
  629. default:
  630. #ifdef CONFIG_COMPAT
  631. if (test_thread_flag(TIF_31BIT))
  632. return do_ptrace_emu31(child, request, addr, data);
  633. #endif
  634. return do_ptrace_normal(child, request, addr, data);
  635. }
  636. /* Not reached. */
  637. return -EIO;
  638. }
  639. asmlinkage long
  640. sys_ptrace(long request, long pid, long addr, long data)
  641. {
  642. struct task_struct *child;
  643. int ret;
  644. lock_kernel();
  645. if (request == PTRACE_TRACEME) {
  646. ret = ptrace_traceme();
  647. goto out;
  648. }
  649. child = ptrace_get_task_struct(pid);
  650. if (IS_ERR(child)) {
  651. ret = PTR_ERR(child);
  652. goto out;
  653. }
  654. ret = do_ptrace(child, request, addr, data);
  655. put_task_struct(child);
  656. out:
  657. unlock_kernel();
  658. return ret;
  659. }
  660. asmlinkage void
  661. syscall_trace(struct pt_regs *regs, int entryexit)
  662. {
  663. if (unlikely(current->audit_context) && entryexit)
  664. audit_syscall_exit(AUDITSC_RESULT(regs->gprs[2]), regs->gprs[2]);
  665. if (!test_thread_flag(TIF_SYSCALL_TRACE))
  666. goto out;
  667. if (!(current->ptrace & PT_PTRACED))
  668. goto out;
  669. ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
  670. ? 0x80 : 0));
  671. /*
  672. * If the debuffer has set an invalid system call number,
  673. * we prepare to skip the system call restart handling.
  674. */
  675. if (!entryexit && regs->gprs[2] >= NR_syscalls)
  676. regs->trap = -1;
  677. /*
  678. * this isn't the same as continuing with a signal, but it will do
  679. * for normal use. strace only continues with a signal if the
  680. * stopping signal is not SIGTRAP. -brl
  681. */
  682. if (current->exit_code) {
  683. send_sig(current->exit_code, current, 1);
  684. current->exit_code = 0;
  685. }
  686. out:
  687. if (unlikely(current->audit_context) && !entryexit)
  688. audit_syscall_entry(test_thread_flag(TIF_31BIT)?AUDIT_ARCH_S390:AUDIT_ARCH_S390X,
  689. regs->gprs[2], regs->orig_gpr2, regs->gprs[3],
  690. regs->gprs[4], regs->gprs[5]);
  691. }