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

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

Linux/Unix编程

开发平台：

Unix_Linux

ptrace32.c：源码内容
  1. /* 
  2.  * 32bit ptrace for x86-64.
  3.  *
  4.  * Copyright 2001,2002 Andi Kleen, SuSE Labs.
  5.  * Some parts copied from arch/i386/kernel/ptrace.c. See that file for earlier 
  6.  * copyright.
  7.  * 
  8.  * This allows to access 64bit processes too; but there is no way to see the extended 
  9.  * register contents.
  10.  *
  11.  * $Id: ptrace32.c,v 1.13 2002/07/18 13:44:12 ak Exp $
  12.  */ 
  14. #include <linux/kernel.h>
  15. #include <linux/stddef.h>
  16. #include <linux/sched.h>
  17. #include <linux/mm.h>
  18. #include <asm/ptrace.h>
  19. #include <asm/uaccess.h>
  20. #include <asm/user32.h>
  21. #include <asm/user.h>
  22. #include <asm/errno.h>
  23. #include <asm/debugreg.h>
  24. #include <asm/i387.h>
  25. #include <asm/fpu32.h>
  26. #include <linux/mm.h>
  28. #define R32(l,q) 
  29. case offsetof(struct user32, regs.l): stack[offsetof(struct pt_regs, q)/8] = val; break
  31. static int putreg32(struct task_struct *child, unsigned regno, u32 val)
  32. {
  33. int i;
  34. __u64 *stack = (__u64 *)(child->thread.rsp0 - sizeof(struct pt_regs)); 
  36. switch (regno) {
  37. case offsetof(struct user32, regs.fs):
  38.         if (val && (val & 3) != 3) return -EIO;
  39.         child->thread.fs = val & 0xffff; 
  40. break;
  41. case offsetof(struct user32, regs.gs):
  42.     if (val && (val & 3) != 3) return -EIO;
  43. child->thread.gs = val & 0xffff;
  44. break;
  45. case offsetof(struct user32, regs.ds):
  46. if (val && (val & 3) != 3) return -EIO; 
  47. child->thread.ds = val & 0xffff;
  48. break;
  49. case offsetof(struct user32, regs.es):
  50. child->thread.es = val & 0xffff;
  51. break;
  52.     case offsetof(struct user32, regs.ss):
  53. if ((val & 3) != 3) return -EIO; 
  54.         stack[offsetof(struct pt_regs, ss)/8] = val & 0xffff;
  55.         break;
  56. case offsetof(struct user32, regs.cs):
  57. if ((val & 3) != 3) return -EIO;
  58. stack[offsetof(struct pt_regs, cs)/8] = val & 0xffff;
  59. break;
  61. R32(ebx, rbx); 
  62. R32(ecx, rcx);
  63. R32(edx, rdx);
  64. R32(edi, rdi);
  65. R32(esi, rsi);
  66. R32(ebp, rbp);
  67. R32(eax, rax);
  68. R32(orig_eax, orig_rax);
  69. R32(eip, rip);
  70. R32(esp, rsp);
  72. case offsetof(struct user32, regs.eflags): 
  73. stack[offsetof(struct pt_regs, eflags)/8] = val & 0x44dd5; 
  74. break;
  76. case offsetof(struct user32, u_debugreg[0]) ... offsetof(struct user32, u_debugreg[6]):
  77. child->thread.debugreg[(regno-offsetof(struct user32, u_debugreg[0]))/4] = val; 
  78. break; 
  80. case offsetof(struct user32, u_debugreg[7]):
  81. val &= ~DR_CONTROL_RESERVED;
  82. /* You are not expected to understand this ... I don't neither. */
  83. for(i=0; i<4; i++)
  84. if ((0x5454 >> ((val >> (16 + 4*i)) & 0xf)) & 1)
  85.        return -EIO;
  86. child->thread.debugreg[7] = val; 
  87. break; 
  88.     
  89. default:
  90. if (regno > sizeof(struct user32) || (regno & 3))
  91. return -EIO;
  92.        
  93. /* Other dummy fields in the virtual user structure are ignored */ 
  94. break; 
  95. }
  96. return 0;
  97. }
  99. #undef R32
  101. #define R32(l,q) 
  102. case offsetof(struct user32, regs.l): *val = stack[offsetof(struct pt_regs, q)/8]; break
  104. static int getreg32(struct task_struct *child, unsigned regno, u32 *val)
  105. {
  106. __u64 *stack = (__u64 *)(child->thread.rsp0 - sizeof(struct pt_regs)); 
  108. switch (regno) {
  109. case offsetof(struct user32, regs.fs):
  110.         *val = child->thread.fs; 
  111. break;
  112. case offsetof(struct user32, regs.gs):
  113. *val = child->thread.gs;
  114. break;
  115. case offsetof(struct user32, regs.ds):
  116. *val = child->thread.ds;
  117. break;
  118. case offsetof(struct user32, regs.es):
  119. *val = child->thread.es;
  120. break;
  122. R32(cs, cs);
  123. R32(ss, ss);
  124. R32(ebx, rbx); 
  125. R32(ecx, rcx);
  126. R32(edx, rdx);
  127. R32(edi, rdi);
  128. R32(esi, rsi);
  129. R32(ebp, rbp);
  130. R32(eax, rax);
  131. R32(orig_eax, orig_rax);
  132. R32(eip, rip);
  133. R32(eflags, eflags);
  134. R32(esp, rsp);
  136. case offsetof(struct user32, u_debugreg[0]) ... offsetof(struct user32, u_debugreg[7]):
  137. *val = child->thread.debugreg[(regno-offsetof(struct user32, u_debugreg[0]))/4]; 
  138. break; 
  139.     
  140. default:
  141. if (regno > sizeof(struct user32) || (regno & 3))
  142. return -EIO;
  144. /* Other dummy fields in the virtual user structure are ignored */ 
  145. *val = 0;
  146. break; 
  147. }
  148. return 0;
  149. }
  151. #undef R32
  153. static struct task_struct *find_target(int request, int pid, int *err)
  154. { 
  155. struct task_struct *child;
  157. *err = -EPERM; 
  158. if (pid == 1)
  159. return NULL; 
  161. *err = -ESRCH;
  162. read_lock(&tasklist_lock);
  163. child = find_task_by_pid(pid);
  164. if (child)
  165. get_task_struct(child);
  166. read_unlock(&tasklist_lock);
  167. if (child) { 
  168. *err = -ESRCH;
  169. if (!(child->ptrace & PT_PTRACED))
  170. goto out;
  171. if (child->state != TASK_STOPPED) {
  172. if (request != PTRACE_KILL)
  173. goto out;
  174. }
  175. if (child->p_pptr != current)
  176. goto out;
  178. return child; 
  179. } 
  180.  out:
  181. free_task_struct(child);
  182. return NULL; 
  184. } 
  186. extern asmlinkage long sys_ptrace(long request, long pid, unsigned long addr, unsigned long data);
  188. asmlinkage long sys32_ptrace(long request, u32 pid, u32 addr, u32 data)
  189. {
  190. struct task_struct *child;
  191. struct pt_regs *childregs; 
  192. int ret;
  193. __u32 val;
  195. switch (request) { 
  196. case PTRACE_TRACEME:
  197. case PTRACE_ATTACH:
  198. case PTRACE_SYSCALL:
  199. case PTRACE_CONT:
  200. case PTRACE_KILL:
  201. case PTRACE_SINGLESTEP:
  202. case PTRACE_DETACH:
  203. case PTRACE_SETOPTIONS:
  204. ret = sys_ptrace(request, pid, addr, data); 
  205. return ret;
  207. case PTRACE_PEEKTEXT:
  208. case PTRACE_PEEKDATA:
  209. case PTRACE_POKEDATA:
  210. case PTRACE_POKETEXT:
  211. case PTRACE_POKEUSR:       
  212. case PTRACE_PEEKUSR:
  213. case PTRACE_GETREGS:
  214. case PTRACE_SETREGS:
  215. case PTRACE_SETFPREGS:
  216. case PTRACE_GETFPREGS:
  217. case PTRACE_SETFPXREGS:
  218. case PTRACE_GETFPXREGS:
  219. break;
  221. default:
  222. return -EIO;
  223. } 
  225. child = find_target(request, pid, &ret);
  226. if (!child)
  227. return ret;
  229. childregs = (struct pt_regs *)(child->thread.rsp0 - sizeof(struct pt_regs)); 
  231. switch (request) {
  232. case PTRACE_PEEKDATA:
  233. case PTRACE_PEEKTEXT:
  234. ret = 0;
  235. if (access_process_vm(child, addr, &val, sizeof(u32), 0)!=sizeof(u32))
  236. ret = -EIO;
  237. else
  238. ret = put_user(val, (unsigned int *)(u64)data); 
  239. break; 
  241. case PTRACE_POKEDATA:
  242. case PTRACE_POKETEXT:
  243. ret = 0;
  244. if (access_process_vm(child, addr, &data, sizeof(u32), 1)!=sizeof(u32))
  245. ret = -EIO; 
  246. break;
  248. case PTRACE_PEEKUSR:
  249. ret = getreg32(child, addr, &val);
  250. if (ret == 0)
  251. ret = put_user(val, (__u32 *)(unsigned long) data);
  252. break;
  254. case PTRACE_POKEUSR:
  255. ret = putreg32(child, addr, data);
  256. break;
  258. case PTRACE_GETREGS: { /* Get all gp regs from the child. */
  259. int i;
  260.    if (!access_ok(VERIFY_WRITE, (unsigned *)(unsigned long)data, 16*4)) {
  261. ret = -EIO;
  262. break;
  263. }
  264. ret = 0;
  265. for ( i = 0; i <= 16*4 ; i += sizeof(__u32) ) {
  266. getreg32(child, i, &val);
  267. ret |= __put_user(val,(u32 *) (unsigned long) data);
  268. data += sizeof(u32);
  269. }
  270. break;
  271. }
  273. case PTRACE_SETREGS: { /* Set all gp regs in the child. */
  274. unsigned long tmp;
  275. int i;
  276.    if (!access_ok(VERIFY_READ, (unsigned *)(unsigned long)data, 16*4)) {
  277. ret = -EIO;
  278. break;
  279. }
  280. empty_fpu(child); 
  281. ret = 0; 
  282. for ( i = 0; i <= 16*4; i += sizeof(u32) ) {
  283. ret |= __get_user(tmp, (u32 *) (unsigned long) data);
  284. putreg32(child, i, tmp);
  285. data += sizeof(u32);
  286. }
  287. break;
  288. }
  290. case PTRACE_SETFPREGS:
  291. empty_fpu(child); 
  292. save_i387_ia32(child, (void *)(u64)data, childregs, 1);
  293. ret = 0; 
  294. break;
  296. case PTRACE_GETFPREGS:
  297. empty_fpu(child); 
  298. restore_i387_ia32(child, (void *)(u64)data, 1);
  299. ret = 0;
  300. break;
  302. case PTRACE_GETFPXREGS: { 
  303. struct user32_fxsr_struct *u = (void *)(u64)data; 
  304. empty_fpu(child); 
  305. ret = copy_to_user(u, &child->thread.i387.fxsave, sizeof(*u));
  306. ret |= __put_user(childregs->cs, &u->fcs);
  307. ret |= __put_user(child->thread.ds, &u->fos); 
  308. if (ret) 
  309. ret = -EFAULT;
  310. break; 
  311. } 
  312. case PTRACE_SETFPXREGS: { 
  313. struct user32_fxsr_struct *u = (void *)(u64)data; 
  314. empty_fpu(child); 
  315. /* no error checking to be bug to bug compatible with i386 */ 
  316. copy_from_user(&child->thread.i387.fxsave, u, sizeof(*u));
  317.         child->thread.i387.fxsave.mxcsr &= 0xffbf;
  318. ret = 0; 
  319. break; 
  320. } 
  322. default:
  323. ret = -EINVAL;
  324. break;
  325. }
  327. free_task_struct(child);
  328. return ret;
  329. }