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

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

Linux/Unix编程

开发平台：

Unix_Linux

ptrace.c：源码内容
  1. /* ptrace.c */
  2. /* By Ross Biro 1/23/92 */
  3. /*
  4.  * Pentium III FXSR, SSE support
  5.  * Gareth Hughes <gareth@valinux.com>, May 2000
  6.  */
  8. #include <linux/kernel.h>
  9. #include <linux/sched.h>
  10. #include <linux/mm.h>
  11. #include <linux/smp.h>
  12. #include <linux/smp_lock.h>
  13. #include <linux/errno.h>
  14. #include <linux/ptrace.h>
  15. #include <linux/user.h>
  17. #include <asm/uaccess.h>
  18. #include <asm/pgtable.h>
  19. #include <asm/system.h>
  20. #include <asm/processor.h>
  21. #include <asm/i387.h>
  22. #include <asm/debugreg.h>
  24. /*
  25.  * does not yet catch signals sent when the child dies.
  26.  * in exit.c or in signal.c.
  27.  */
  29. /* determines which flags the user has access to. */
  30. /* 1 = access 0 = no access */
  31. #define FLAG_MASK 0x00044dd5
  33. /* set's the trap flag. */
  34. #define TRAP_FLAG 0x100
  36. /*
  37.  * Offset of eflags on child stack..
  38.  */
  39. #define EFL_OFFSET ((EFL-2)*4-sizeof(struct pt_regs))
  41. /*
  42.  * this routine will get a word off of the processes privileged stack. 
  43.  * the offset is how far from the base addr as stored in the TSS.  
  44.  * this routine assumes that all the privileged stacks are in our
  45.  * data space.
  46.  */   
  47. static inline int get_stack_long(struct task_struct *task, int offset)
  48. {
  49. unsigned char *stack;
  51. stack = (unsigned char *)task->thread.esp0;
  52. stack += offset;
  53. return (*((int *)stack));
  54. }
  56. /*
  57.  * this routine will put a word on the processes privileged stack. 
  58.  * the offset is how far from the base addr as stored in the TSS.  
  59.  * this routine assumes that all the privileged stacks are in our
  60.  * data space.
  61.  */
  62. static inline int put_stack_long(struct task_struct *task, int offset,
  63. unsigned long data)
  64. {
  65. unsigned char * stack;
  67. stack = (unsigned char *) task->thread.esp0;
  68. stack += offset;
  69. *(unsigned long *) stack = data;
  70. return 0;
  71. }
  73. static int putreg(struct task_struct *child,
  74. unsigned long regno, unsigned long value)
  75. {
  76. switch (regno >> 2) {
  77. case FS:
  78. if (value && (value & 3) != 3)
  79. return -EIO;
  80. child->thread.fs = value;
  81. return 0;
  82. case GS:
  83. if (value && (value & 3) != 3)
  84. return -EIO;
  85. child->thread.gs = value;
  86. return 0;
  87. case DS:
  88. case ES:
  89. if (value && (value & 3) != 3)
  90. return -EIO;
  91. value &= 0xffff;
  92. break;
  93. case SS:
  94. case CS:
  95. if ((value & 3) != 3)
  96. return -EIO;
  97. value &= 0xffff;
  98. break;
  99. case EFL:
  100. value &= FLAG_MASK;
  101. value |= get_stack_long(child, EFL_OFFSET) & ~FLAG_MASK;
  102. break;
  103. }
  104. if (regno > GS*4)
  105. regno -= 2*4;
  106. put_stack_long(child, regno - sizeof(struct pt_regs), value);
  107. return 0;
  108. }
  110. static unsigned long getreg(struct task_struct *child,
  111. unsigned long regno)
  112. {
  113. unsigned long retval = ~0UL;
  115. switch (regno >> 2) {
  116. case FS:
  117. retval = child->thread.fs;
  118. break;
  119. case GS:
  120. retval = child->thread.gs;
  121. break;
  122. case DS:
  123. case ES:
  124. case SS:
  125. case CS:
  126. retval = 0xffff;
  127. /* fall through */
  128. default:
  129. if (regno > GS*4)
  130. regno -= 2*4;
  131. regno = regno - sizeof(struct pt_regs);
  132. retval &= get_stack_long(child, regno);
  133. }
  134. return retval;
  135. }
  137. /*
  138.  * Called by kernel/ptrace.c when detaching..
  139.  *
  140.  * Make sure the single step bit is not set.
  141.  */
  142. void ptrace_disable(struct task_struct *child)
  143. { 
  144. long tmp;
  146. tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
  147. put_stack_long(child, EFL_OFFSET, tmp);
  148. }
  150. asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
  151. {
  152. struct task_struct *child;
  153. struct user * dummy = NULL;
  154. int i, ret;
  156. lock_kernel();
  157. ret = -EPERM;
  158. if (request == PTRACE_TRACEME) {
  159. /* are we already being traced? */
  160. if (current->ptrace & PT_PTRACED)
  161. goto out;
  162. /* set the ptrace bit in the process flags. */
  163. current->ptrace |= PT_PTRACED;
  164. ret = 0;
  165. goto out;
  166. }
  167. ret = -ESRCH;
  168. read_lock(&tasklist_lock);
  169. child = find_task_by_pid(pid);
  170. if (child)
  171. get_task_struct(child);
  172. read_unlock(&tasklist_lock);
  173. if (!child)
  174. goto out;
  176. ret = -EPERM;
  177. if (pid == 1) /* you may not mess with init */
  178. goto out_tsk;
  180. if (request == PTRACE_ATTACH) {
  181. ret = ptrace_attach(child);
  182. goto out_tsk;
  183. }
  185. ret = ptrace_check_attach(child, request == PTRACE_KILL);
  186. if (ret < 0)
  187. goto out_tsk;
  189. switch (request) {
  190. /* when I and D space are separate, these will need to be fixed. */
  191. case PTRACE_PEEKTEXT: /* read word at location addr. */ 
  192. case PTRACE_PEEKDATA: {
  193. unsigned long tmp;
  194. int copied;
  196. copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
  197. ret = -EIO;
  198. if (copied != sizeof(tmp))
  199. break;
  200. ret = put_user(tmp,(unsigned long *) data);
  201. break;
  202. }
  204. /* read the word at location addr in the USER area. */
  205. case PTRACE_PEEKUSR: {
  206. unsigned long tmp;
  208. ret = -EIO;
  209. if ((addr & 3) || addr < 0 || 
  210.     addr > sizeof(struct user) - 3)
  211. break;
  213. tmp = 0;  /* Default return condition */
  214. if(addr < FRAME_SIZE*sizeof(long))
  215. tmp = getreg(child, addr);
  216. if(addr >= (long) &dummy->u_debugreg[0] &&
  217.    addr <= (long) &dummy->u_debugreg[7]){
  218. addr -= (long) &dummy->u_debugreg[0];
  219. addr = addr >> 2;
  220. tmp = child->thread.debugreg[addr];
  221. }
  222. ret = put_user(tmp,(unsigned long *) data);
  223. break;
  224. }
  226. /* when I and D space are separate, this will have to be fixed. */
  227. case PTRACE_POKETEXT: /* write the word at location addr. */
  228. case PTRACE_POKEDATA:
  229. ret = 0;
  230. if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
  231. break;
  232. ret = -EIO;
  233. break;
  235. case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
  236. ret = -EIO;
  237. if ((addr & 3) || addr < 0 || 
  238.     addr > sizeof(struct user) - 3)
  239. break;
  241. if (addr < FRAME_SIZE*sizeof(long)) {
  242. ret = putreg(child, addr, data);
  243. break;
  244. }
  245. /* We need to be very careful here.  We implicitly
  246.    want to modify a portion of the task_struct, and we
  247.    have to be selective about what portions we allow someone
  248.    to modify. */
  250.   ret = -EIO;
  251.   if(addr >= (long) &dummy->u_debugreg[0] &&
  252.      addr <= (long) &dummy->u_debugreg[7]){
  254.   if(addr == (long) &dummy->u_debugreg[4]) break;
  255.   if(addr == (long) &dummy->u_debugreg[5]) break;
  256.   if(addr < (long) &dummy->u_debugreg[4] &&
  257.      ((unsigned long) data) >= TASK_SIZE-3) break;
  258.   
  259.   if(addr == (long) &dummy->u_debugreg[7]) {
  260.   data &= ~DR_CONTROL_RESERVED;
  261.   for(i=0; i<4; i++)
  262.   if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
  263.   goto out_tsk;
  264.   }
  266.   addr -= (long) &dummy->u_debugreg;
  267.   addr = addr >> 2;
  268.   child->thread.debugreg[addr] = data;
  269.   ret = 0;
  270.   }
  271.   break;
  273. case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
  274. case PTRACE_CONT: { /* restart after signal. */
  275. long tmp;
  277. ret = -EIO;
  278. if ((unsigned long) data > _NSIG)
  279. break;
  280. if (request == PTRACE_SYSCALL)
  281. child->ptrace |= PT_TRACESYS;
  282. else
  283. child->ptrace &= ~PT_TRACESYS;
  284. child->exit_code = data;
  285. /* make sure the single step bit is not set. */
  286. tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
  287. put_stack_long(child, EFL_OFFSET,tmp);
  288. wake_up_process(child);
  289. ret = 0;
  290. break;
  291. }
  293. /*
  294.  * make the child exit.  Best I can do is send it a sigkill. 
  295.  * perhaps it should be put in the status that it wants to 
  296.  * exit.
  297.  */
  298. case PTRACE_KILL: {
  299. long tmp;
  301. ret = 0;
  302. if (child->state == TASK_ZOMBIE) /* already dead */
  303. break;
  304. child->exit_code = SIGKILL;
  305. /* make sure the single step bit is not set. */
  306. tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
  307. put_stack_long(child, EFL_OFFSET, tmp);
  308. wake_up_process(child);
  309. break;
  310. }
  312. case PTRACE_SINGLESTEP: {  /* set the trap flag. */
  313. long tmp;
  315. ret = -EIO;
  316. if ((unsigned long) data > _NSIG)
  317. break;
  318. child->ptrace &= ~PT_TRACESYS;
  319. if ((child->ptrace & PT_DTRACE) == 0) {
  320. /* Spurious delayed TF traps may occur */
  321. child->ptrace |= PT_DTRACE;
  322. }
  323. tmp = get_stack_long(child, EFL_OFFSET) | TRAP_FLAG;
  324. put_stack_long(child, EFL_OFFSET, tmp);
  325. child->exit_code = data;
  326. /* give it a chance to run. */
  327. wake_up_process(child);
  328. ret = 0;
  329. break;
  330. }
  332. case PTRACE_DETACH:
  333. /* detach a process that was attached. */
  334. ret = ptrace_detach(child, data);
  335. break;
  337. case PTRACE_GETREGS: { /* Get all gp regs from the child. */
  338.    if (!access_ok(VERIFY_WRITE, (unsigned *)data, FRAME_SIZE*sizeof(long))) {
  339. ret = -EIO;
  340. break;
  341. }
  342. for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) {
  343. __put_user(getreg(child, i),(unsigned long *) data);
  344. data += sizeof(long);
  345. }
  346. ret = 0;
  347. break;
  348. }
  350. case PTRACE_SETREGS: { /* Set all gp regs in the child. */
  351. unsigned long tmp;
  352.    if (!access_ok(VERIFY_READ, (unsigned *)data, FRAME_SIZE*sizeof(long))) {
  353. ret = -EIO;
  354. break;
  355. }
  356. for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) {
  357. __get_user(tmp, (unsigned long *) data);
  358. putreg(child, i, tmp);
  359. data += sizeof(long);
  360. }
  361. ret = 0;
  362. break;
  363. }
  365. case PTRACE_GETFPREGS: { /* Get the child FPU state. */
  366. if (!access_ok(VERIFY_WRITE, (unsigned *)data,
  367.        sizeof(struct user_i387_struct))) {
  368. ret = -EIO;
  369. break;
  370. }
  371. ret = 0;
  372. if ( !child->used_math )
  373. load_empty_fpu(child);
  374. get_fpregs((struct user_i387_struct *)data, child);
  375. break;
  376. }
  378. case PTRACE_SETFPREGS: { /* Set the child FPU state. */
  379. if (!access_ok(VERIFY_READ, (unsigned *)data,
  380.        sizeof(struct user_i387_struct))) {
  381. ret = -EIO;
  382. break;
  383. }
  384. child->used_math = 1;
  385. set_fpregs(child, (struct user_i387_struct *)data);
  386. ret = 0;
  387. break;
  388. }
  390. case PTRACE_GETFPXREGS: { /* Get the child extended FPU state. */
  391. if (!access_ok(VERIFY_WRITE, (unsigned *)data,
  392.        sizeof(struct user_fxsr_struct))) {
  393. ret = -EIO;
  394. break;
  395. }
  396. if ( !child->used_math )
  397. load_empty_fpu(child);
  398. ret = get_fpxregs((struct user_fxsr_struct *)data, child);
  399. break;
  400. }
  402. case PTRACE_SETFPXREGS: { /* Set the child extended FPU state. */
  403. if (!access_ok(VERIFY_READ, (unsigned *)data,
  404.        sizeof(struct user_fxsr_struct))) {
  405. ret = -EIO;
  406. break;
  407. }
  408. child->used_math = 1;
  409. ret = set_fpxregs(child, (struct user_fxsr_struct *)data);
  410. break;
  411. }
  413. case PTRACE_SETOPTIONS: {
  414. if (data & PTRACE_O_TRACESYSGOOD)
  415. child->ptrace |= PT_TRACESYSGOOD;
  416. else
  417. child->ptrace &= ~PT_TRACESYSGOOD;
  418. ret = 0;
  419. break;
  420. }
  422. default:
  423. ret = -EIO;
  424. break;
  425. }
  426. out_tsk:
  427. free_task_struct(child);
  428. out:
  429. unlock_kernel();
  430. return ret;
  431. }
  433. asmlinkage void syscall_trace(void)
  434. {
  435. if ((current->ptrace & (PT_PTRACED|PT_TRACESYS)) !=
  436. (PT_PTRACED|PT_TRACESYS))
  437. return;
  438. /* the 0x80 provides a way for the tracing parent to distinguish
  439.    between a syscall stop and SIGTRAP delivery */
  440. current->exit_code = SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
  441. ? 0x80 : 0);
  442. current->state = TASK_STOPPED;
  443. notify_parent(current, SIGCHLD);
  444. schedule();
  445. /*
  446.  * this isn't the same as continuing with a signal, but it will do
  447.  * for normal use.  strace only continues with a signal if the
  448.  * stopping signal is not SIGTRAP.  -brl
  449.  */
  450. if (current->exit_code) {
  451. send_sig(current->exit_code, current, 1);
  452. current->exit_code = 0;
  453. }
  454. }