开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ptrace.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ptrace.c：源码内容
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1992 Ross Biro
  7.  * Copyright (C) Linus Torvalds
  8.  * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle
  9.  * Copyright (C) 1996 David S. Miller
  10.  * Copyright (C) 2000 Ulf Carlsson
  11.  *
  12.  * At this time Linux/MIPS64 only supports syscall tracing, even for 32-bit
  13.  * binaries.
  14.  */
  15. #include <linux/config.h>
  16. #include <linux/kernel.h>
  17. #include <linux/sched.h>
  18. #include <linux/mm.h>
  19. #include <linux/errno.h>
  20. #include <linux/ptrace.h>
  21. #include <linux/smp.h>
  22. #include <linux/smp_lock.h>
  23. #include <linux/user.h>
  25. #include <asm/cpu.h>
  26. #include <asm/mipsregs.h>
  27. #include <asm/pgtable.h>
  28. #include <asm/page.h>
  29. #include <asm/system.h>
  30. #include <asm/uaccess.h>
  31. #include <asm/bootinfo.h>
  33. /*
  34.  * Called by kernel/ptrace.c when detaching..
  35.  *
  36.  * Make sure single step bits etc are not set.
  37.  */
  38. void ptrace_disable(struct task_struct *child)
  39. {
  40. /* Nothing to do.. */
  41. }
  43. /*
  44.  * Tracing a 32-bit process with a 64-bit strace and vice versa will not
  45.  * work.  I don't know how to fix this.
  46.  */
  47. asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
  48. {
  49. struct task_struct *child;
  50. int ret;
  52. lock_kernel();
  53. ret = -EPERM;
  54. if (request == PTRACE_TRACEME) {
  55. /* are we already being traced? */
  56. if (current->ptrace & PT_PTRACED)
  57. goto out;
  58. /* set the ptrace bit in the process flags. */
  59. current->ptrace |= PT_PTRACED;
  60. ret = 0;
  61. goto out;
  62. }
  63. ret = -ESRCH;
  64. read_lock(&tasklist_lock);
  65. child = find_task_by_pid(pid);
  66. if (child)
  67. get_task_struct(child);
  68. read_unlock(&tasklist_lock);
  69. if (!child)
  70. goto out;
  72. ret = -EPERM;
  73. if (pid == 1) /* you may not mess with init */
  74. goto out_tsk;
  76. if (request == PTRACE_ATTACH) {
  77. ret = ptrace_attach(child);
  78. goto out_tsk;
  79. }
  81. ret = ptrace_check_attach(child, request == PTRACE_KILL);
  82. if (ret < 0)
  83. goto out_tsk;
  85. switch (request) {
  86. /* when I and D space are separate, these will need to be fixed. */
  87. case PTRACE_PEEKTEXT: /* read word at location addr. */
  88. case PTRACE_PEEKDATA: {
  89. unsigned int tmp;
  90. int copied;
  92. copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
  93. ret = -EIO;
  94. if (copied != sizeof(tmp))
  95. break;
  96. ret = put_user(tmp, (unsigned int *) (unsigned long) data);
  97. break;
  98. }
  100. /* read the word at location addr in the USER area. */
  101. case PTRACE_PEEKUSR: {
  102. struct pt_regs *regs;
  103. unsigned int tmp;
  105. regs = (struct pt_regs *) ((unsigned long) child +
  106. KERNEL_STACK_SIZE - 32 - sizeof(struct pt_regs));
  107. ret = 0;
  109. switch (addr) {
  110. case 0 ... 31:
  111. tmp = regs->regs[addr];
  112. break;
  113. case FPR_BASE ... FPR_BASE + 31:
  114. if (child->used_math) {
  115. unsigned long long *fregs
  116. = (unsigned long long *)
  117.     &child->thread.fpu.hard.fp_regs[0];
  118. if (mips_cpu.options & MIPS_CPU_FPU) {
  119. #ifndef CONFIG_SMP
  120. if (last_task_used_math == child) {
  121. __enable_fpu();
  122. save_fp(child);
  123. __disable_fpu();
  124. last_task_used_math = NULL;
  125. }
  126. #endif
  127. } else {
  128. fregs = (unsigned long long *)
  129. child->thread.fpu.soft.regs;
  130. }
  132. /*
  133.  * The odd registers are actually the high
  134.  * order bits of the values stored in the even
  135.  * registers.
  136.  */
  137. if (addr & 1)
  138. tmp = (unsigned long) (fregs[((addr & ~1) - 32)] >> 32);
  139. else
  140. tmp = (unsigned long) (fregs[(addr - 32)] & 0xffffffff);
  141. } else {
  142. tmp = -EIO;
  143. }
  144. break;
  145. case PC:
  146. tmp = regs->cp0_epc;
  147. break;
  148. case CAUSE:
  149. tmp = regs->cp0_cause;
  150. break;
  151. case BADVADDR:
  152. tmp = regs->cp0_badvaddr;
  153. break;
  154. case MMHI:
  155. tmp = regs->hi;
  156. break;
  157. case MMLO:
  158. tmp = regs->lo;
  159. break;
  160. case FPC_CSR:
  161. if (mips_cpu.options & MIPS_CPU_FPU)
  162. tmp = child->thread.fpu.hard.control;
  163. else
  164. tmp = child->thread.fpu.soft.sr;
  165. break;
  166. case FPC_EIR: { /* implementation / version register */
  167. unsigned int flags;
  168. __save_flags(flags);
  169. __enable_fpu();
  170. __asm__ __volatile__("cfc1t%0,$0": "=r" (tmp));
  171. __restore_flags(flags);
  172. break;
  173. }
  174. default:
  175. tmp = 0;
  176. ret = -EIO;
  177. goto out_tsk;
  178. }
  179. ret = put_user(tmp, (unsigned *) (unsigned long) data);
  180. break;
  181. }
  182. /* when I and D space are separate, this will have to be fixed. */
  183. case PTRACE_POKETEXT: /* write the word at location addr. */
  184. case PTRACE_POKEDATA:
  185. ret = 0;
  186. if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
  187. break;
  188. ret = -EIO;
  189. break;
  191. case PTRACE_POKEUSR: {
  192. struct pt_regs *regs;
  193. ret = 0;
  194. regs = (struct pt_regs *) ((unsigned long) child +
  195. KERNEL_STACK_SIZE - 32 - sizeof(struct pt_regs));
  197. switch (addr) {
  198. case 0 ... 31:
  199. regs->regs[addr] = data;
  200. break;
  201. case FPR_BASE ... FPR_BASE + 31: {
  202. unsigned long long *fregs;
  203. fregs = (unsigned long long *)&child->thread.fpu.hard.fp_regs[0];
  204. if (child->used_math) {
  205. #ifndef CONFIG_SMP
  206. if (last_task_used_math == child)
  207. if (mips_cpu.options & MIPS_CPU_FPU) {
  208. __enable_fpu();
  209. save_fp(child);
  210. __disable_fpu();
  211. last_task_used_math = NULL;
  212. regs->cp0_status &= ~ST0_CU1;
  213. } else {
  214. fregs = (unsigned long long *)
  215. child->thread.fpu.soft.regs;
  216. }
  217. #endif
  218. } else {
  219. /* FP not yet used  */
  220. memset(&child->thread.fpu.hard, ~0,
  221.        sizeof(child->thread.fpu.hard));
  222. child->thread.fpu.hard.control = 0;
  223. }
  224. /*
  225.  * The odd registers are actually the high order bits
  226.  * of the values stored in the even registers - unless
  227.  * we're using r2k_switch.S.
  228.  */
  229. if (addr & 1) {
  230. fregs[(addr & ~1) - FPR_BASE] &= 0xffffffff;
  231. fregs[(addr & ~1) - FPR_BASE] |= ((unsigned long) data) << 32;
  232. } else {
  233. fregs[addr - FPR_BASE] &= ~0xffffffffLL;
  234. fregs[addr - FPR_BASE] |= data;
  235. }
  236. break;
  237. }
  238. case PC:
  239. regs->cp0_epc = data;
  240. break;
  241. case MMHI:
  242. regs->hi = data;
  243. break;
  244. case MMLO:
  245. regs->lo = data;
  246. break;
  247. case FPC_CSR:
  248. if (mips_cpu.options & MIPS_CPU_FPU)
  249. child->thread.fpu.hard.control = data;
  250. else
  251. child->thread.fpu.soft.sr = data;
  252. break;
  253. default:
  254. /* The rest are not allowed. */
  255. ret = -EIO;
  256. break;
  257. }
  258. goto out;
  259. }
  260. case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
  261. case PTRACE_CONT: { /* restart after signal. */
  262. ret = -EIO;
  263. if ((unsigned int) data > _NSIG)
  264. break;
  265. if (request == PTRACE_SYSCALL)
  266. child->ptrace |= PT_TRACESYS;
  267. else
  268. child->ptrace &= ~PT_TRACESYS;
  269. child->exit_code = data;
  270. wake_up_process(child);
  271. ret = 0;
  272. break;
  273. }
  275. /*
  276.  * make the child exit.  Best I can do is send it a sigkill.
  277.  * perhaps it should be put in the status that it wants to
  278.  * exit.
  279.  */
  280. case PTRACE_KILL: {
  281. if (child->state == TASK_ZOMBIE) /* already dead */
  282. break;
  283. child->exit_code = SIGKILL;
  284. wake_up_process(child);
  285. break;
  286. }
  288. case PTRACE_DETACH: /* detach a process that was attached. */
  289. ret = ptrace_detach(child, data);
  290. break;
  292. case PTRACE_SETOPTIONS: {
  293. if (data & PTRACE_O_TRACESYSGOOD)
  294. child->ptrace |= PT_TRACESYSGOOD;
  295. else
  296. child->ptrace &= ~PT_TRACESYSGOOD;
  297. ret = 0;
  298. break;
  299. }
  301. default:
  302. ret = -EIO;
  303. break;
  304. }
  306. out_tsk:
  307. free_task_struct(child);
  308. out:
  309. unlock_kernel();
  310. return ret;
  311. }
  313. asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
  314. {
  315. struct task_struct *child;
  316. int ret;
  318. lock_kernel();
  319. #if 0
  320. printk("ptrace(r=%d,pid=%d,addr=%08lx,data=%08lx)n",
  321.        (int) request, (int) pid, (unsigned long) addr,
  322.        (unsigned long) data);
  323. #endif
  324. ret = -EPERM;
  325. if (request == PTRACE_TRACEME) {
  326. /* are we already being traced? */
  327. if (current->ptrace & PT_PTRACED)
  328. goto out;
  329. /* set the ptrace bit in the process flags. */
  330. current->ptrace |= PT_PTRACED;
  331. ret = 0;
  332. goto out;
  333. }
  334. ret = -ESRCH;
  335. read_lock(&tasklist_lock);
  336. child = find_task_by_pid(pid);
  337. if (child)
  338. get_task_struct(child);
  339. read_unlock(&tasklist_lock);
  340. if (!child)
  341. goto out;
  343. ret = -EPERM;
  344. if (pid == 1) /* you may not mess with init */
  345. goto out;
  347. if (request == PTRACE_ATTACH) {
  348. ret = ptrace_attach(child);
  349. goto out_tsk;
  350. }
  352. ret = ptrace_check_attach(child, request == PTRACE_KILL);
  353. if (ret < 0)
  354. goto out_tsk;
  356. switch (request) {
  357. /* when I and D space are separate, these will need to be fixed. */
  358. case PTRACE_PEEKTEXT: /* read word at location addr. */
  359. case PTRACE_PEEKDATA: {
  360. unsigned long tmp;
  361. int copied;
  363. copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
  364. ret = -EIO;
  365. if (copied != sizeof(tmp))
  366. break;
  367. ret = put_user(tmp,(unsigned long *) data);
  368. break;
  369. }
  371. /* read the word at location addr in the USER area. */
  372. case PTRACE_PEEKUSR: {
  373. struct pt_regs *regs;
  374. unsigned long tmp;
  376. regs = (struct pt_regs *) ((unsigned long) child +
  377. KERNEL_STACK_SIZE - 32 - sizeof(struct pt_regs));
  378. ret = 0;
  380. switch (addr) {
  381. case 0 ... 31:
  382. tmp = regs->regs[addr];
  383. break;
  384. case FPR_BASE ... FPR_BASE + 31:
  385. if (child->used_math) {
  386. unsigned long long *fregs
  387. = (unsigned long long *)
  388. &child->thread.fpu.hard.fp_regs[0];
  389. if (mips_cpu.options & MIPS_CPU_FPU) {
  390. #ifndef CONFIG_SMP
  391. if (last_task_used_math == child) {
  392. __enable_fpu();
  393. save_fp(child);
  394. __disable_fpu();
  395. last_task_used_math = NULL;
  396. }
  397. #endif
  398. } else {
  399. fregs = (unsigned long long *)
  400. child->thread.fpu.soft.regs;
  401. }
  403. /*
  404.  * The odd registers are actually the high
  405.  * order bits of the values stored in the even
  406.  * registers.
  407.  */
  408. if (addr & 1)
  409. tmp = (unsigned long) (fregs[((addr & ~1) - 32)] >> 32);
  410. else
  411. tmp = (unsigned long) (fregs[(addr - 32)] & 0xffffffff);
  412. } else {
  413. tmp = -EIO;
  414. }
  415. break;
  416. case PC:
  417. tmp = regs->cp0_epc;
  418. break;
  419. case CAUSE:
  420. tmp = regs->cp0_cause;
  421. break;
  422. case BADVADDR:
  423. tmp = regs->cp0_badvaddr;
  424. break;
  425. case MMHI:
  426. tmp = regs->hi;
  427. break;
  428. case MMLO:
  429. tmp = regs->lo;
  430. break;
  431. case FPC_CSR:
  432. if (mips_cpu.options & MIPS_CPU_FPU)
  433. tmp = child->thread.fpu.hard.control;
  434. else
  435. tmp = child->thread.fpu.soft.sr;
  436. break;
  437. case FPC_EIR: { /* implementation / version register */
  438. unsigned int flags;
  439. __save_flags(flags);
  440. __enable_fpu();
  441. __asm__ __volatile__("cfc1t%0,$0": "=r" (tmp));
  442. __restore_flags(flags);
  443. break;
  444. }
  445. default:
  446. tmp = 0;
  447. ret = -EIO;
  448. goto out_tsk;
  449. }
  450. ret = put_user(tmp, (unsigned long *) data);
  451. break;
  452. }
  453. /* when I and D space are separate, this will have to be fixed. */
  454. case PTRACE_POKETEXT: /* write the word at location addr. */
  455. case PTRACE_POKEDATA:
  456. ret = 0;
  457. if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
  458. break;
  459. ret = -EIO;
  460. break;
  462. case PTRACE_POKEUSR: {
  463. struct pt_regs *regs;
  464. ret = 0;
  465. regs = (struct pt_regs *) ((unsigned long) child +
  466. KERNEL_STACK_SIZE - 32 - sizeof(struct pt_regs));
  468. switch (addr) {
  469. case 0 ... 31:
  470. regs->regs[addr] = data;
  471. break;
  472. case FPR_BASE ... FPR_BASE + 31: {
  473. unsigned long long *fregs = (unsigned long long *)
  474. &child->thread.fpu.hard.fp_regs[0];
  476. if (child->used_math) {
  477. #ifndef CONFIG_SMP
  478. if (mips_cpu.options & MIPS_CPU_FPU) {
  479. if (last_task_used_math == child) {
  480. __enable_fpu();
  481. save_fp(child);
  482. __disable_fpu();
  483. last_task_used_math = NULL;
  484. regs->cp0_status &= ~ST0_CU1;
  485. } else {
  486. fregs = (unsigned long long *)
  487. child->thread.fpu.soft.regs;
  488. }
  489. }
  490. #endif
  491. } else {
  492. /* FP not yet used  */
  493. memset(&child->thread.fpu.hard, ~0,
  494.        sizeof(child->thread.fpu.hard));
  495. child->thread.fpu.hard.control = 0;
  496. }
  497. /*
  498.  * The odd registers are actually the high order bits
  499.  * of the values stored in the even registers - unless
  500.  * we're using r2k_switch.S.
  501.  */
  502. if (addr & 1) {
  503. fregs[(addr & ~1) - FPR_BASE] &= 0xffffffff;
  504. fregs[(addr & ~1) - FPR_BASE] |= ((unsigned long) data) << 32;
  505. } else {
  506. fregs[addr - FPR_BASE] &= ~0xffffffffLL;
  507. fregs[addr - FPR_BASE] |= data;
  508. }
  509. break;
  510. }
  511. case PC:
  512. regs->cp0_epc = data;
  513. break;
  514. case MMHI:
  515. regs->hi = data;
  516. break;
  517. case MMLO:
  518. regs->lo = data;
  519. break;
  520. case FPC_CSR:
  521. if (mips_cpu.options & MIPS_CPU_FPU)
  522. child->thread.fpu.hard.control = data;
  523. else
  524. child->thread.fpu.soft.sr = data;
  525. break;
  526. default:
  527. /* The rest are not allowed. */
  528. ret = -EIO;
  529. break;
  530. }
  531. goto out;
  532. }
  533. case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
  534. case PTRACE_CONT: { /* restart after signal. */
  535. ret = -EIO;
  536. if ((unsigned long) data > _NSIG)
  537. break;
  538. if (request == PTRACE_SYSCALL)
  539. child->ptrace |= PT_TRACESYS;
  540. else
  541. child->ptrace &= ~PT_TRACESYS;
  542. child->exit_code = data;
  543. wake_up_process(child);
  544. ret = 0;
  545. break;
  546. }
  548. /*
  549.  * make the child exit.  Best I can do is send it a sigkill.
  550.  * perhaps it should be put in the status that it wants to
  551.  * exit.
  552.  */
  553. case PTRACE_KILL: {
  554. if (child->state == TASK_ZOMBIE) /* already dead */
  555. break;
  556. child->exit_code = SIGKILL;
  557. wake_up_process(child);
  558. break;
  559. }
  561. case PTRACE_DETACH: /* detach a process that was attached. */
  562. ret = ptrace_detach(child, data);
  563. break;
  565. case PTRACE_SETOPTIONS: {
  566. if (data & PTRACE_O_TRACESYSGOOD)
  567. child->ptrace |= PT_TRACESYSGOOD;
  568. else
  569. child->ptrace &= ~PT_TRACESYSGOOD;
  570. ret = 0;
  571. break;
  572. }
  574. default:
  575. ret = -EIO;
  576. break;
  577. }
  579. out_tsk:
  580. free_task_struct(child);
  581. out:
  582. unlock_kernel();
  583. return ret;
  584. }
  586. asmlinkage void syscall_trace(void)
  587. {
  588. if ((current->ptrace & (PT_PTRACED|PT_TRACESYS))
  589.     != (PT_PTRACED|PT_TRACESYS))
  590. return;
  592. /* The 0x80 provides a way for the tracing parent to distinguish
  593.    between a syscall stop and SIGTRAP delivery */
  594. current->exit_code = SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
  595.                                 ? 0x80 : 0);
  596. current->state = TASK_STOPPED;
  597. notify_parent(current, SIGCHLD);
  598. schedule();
  599. /*
  600.  * this isn't the same as continuing with a signal, but it will do
  601.  * for normal use.  strace only continues with a signal if the
  602.  * stopping signal is not SIGTRAP.  -brl
  603.  */
  604. if (current->exit_code) {
  605. send_sig(current->exit_code, current, 1);
  606. current->exit_code = 0;
  607. }
  608. }