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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ptrace.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ptrace.c：源码内容
  1. /*
  2.  *  linux/arch/arm/kernel/ptrace.c
  3.  *
  4.  *  By Ross Biro 1/23/92
  5.  * edited by Linus Torvalds
  6.  * ARM modifications Copyright (C) 2000 Russell King
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License version 2 as
  10.  * published by the Free Software Foundation.
  11.  */
  12. #include <linux/kernel.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/smp.h>
  16. #include <linux/smp_lock.h>
  17. #include <linux/ptrace.h>
  18. #include <linux/user.h>
  20. #include <asm/uaccess.h>
  21. #include <asm/pgtable.h>
  22. #include <asm/system.h>
  24. #include "ptrace.h"
  26. #define REG_PC 15
  27. #define REG_PSR 16
  28. /*
  29.  * does not yet catch signals sent when the child dies.
  30.  * in exit.c or in signal.c.
  31.  */
  33. /*
  34.  * Breakpoint SWI instruction: SWI &9F0001
  35.  */
  36. #define BREAKINST_ARM 0xef9f0001
  37. /* fill this in later */
  38. #define BREAKINST_THUMB 0xdf00
  40. /*
  41.  * Get the address of the live pt_regs for the specified task.
  42.  * These are saved onto the top kernel stack when the process
  43.  * is not running.
  44.  */
  45. static inline struct pt_regs *
  46. get_user_regs(struct task_struct *task)
  47. {
  48. return (struct pt_regs *)
  49. ((unsigned long)task + 8192 - 8 - sizeof(struct pt_regs));
  50. }
  52. /*
  53.  * this routine will get a word off of the processes privileged stack.
  54.  * the offset is how far from the base addr as stored in the THREAD.
  55.  * this routine assumes that all the privileged stacks are in our
  56.  * data space.
  57.  */
  58. static inline long get_stack_long(struct task_struct *task, int offset)
  59. {
  60. return get_user_regs(task)->uregs[offset];
  61. }
  63. /*
  64.  * this routine will put a word on the processes privileged stack.
  65.  * the offset is how far from the base addr as stored in the THREAD.
  66.  * this routine assumes that all the privileged stacks are in our
  67.  * data space.
  68.  */
  69. static inline int
  70. put_stack_long(struct task_struct *task, int offset, long data)
  71. {
  72. struct pt_regs newregs, *regs = get_user_regs(task);
  73. int ret = -EINVAL;
  75. newregs = *regs;
  76. newregs.uregs[offset] = data;
  78. if (valid_user_regs(&newregs)) {
  79. regs->uregs[offset] = data;
  80. ret = 0;
  81. }
  83. return ret;
  84. }
  86. #ifdef CONFIG_ARM_THUMB
  87. static inline int
  88. read_tsk16(struct task_struct *child, unsigned long addr, unsigned short *res)
  89. {
  90. int copied;
  92. copied = access_process_vm(child, addr, res, sizeof(*res), 0);
  94. return copied != sizeof(*res) ? -EIO : 0;
  95. }
  97. static inline int
  98. write_tsk16(struct task_struct *child, unsigned long addr, unsigned short val)
  99. {
  100. int copied;
  102. copied = access_process_vm(child, addr, &val, sizeof(val), 1);
  104. return copied != sizeof(val) ? -EIO : 0;
  105. }
  107. static int
  108. add_breakpoint_thumb(struct task_struct *child, struct debug_info *dbg, u32 addr)
  109. {
  110. int nr = dbg->nsaved;
  111. int res = -EINVAL;
  113. if (nr < 2) {
  114. u16 insn;
  116. res = read_tsk16(child, addr, &insn);
  117. if (res == 0)
  118. res = write_tsk16(child, addr, BREAKINST_THUMB);
  120. if (res == 0) {
  121. dbg->bp[nr].address = addr;
  122. dbg->bp[nr].insn = insn;
  123. dbg->nsaved += 1;
  124. }
  125. } else
  126. printk(KERN_ERR "ptrace: too many breakpointsn");
  128. return res;
  129. }
  130. #endif
  132. static inline int
  133. read_tsk_long(struct task_struct *child, unsigned long addr, unsigned long *res)
  134. {
  135. int copied;
  137. copied = access_process_vm(child, addr, res, sizeof(*res), 0);
  139. return copied != sizeof(*res) ? -EIO : 0;
  140. }
  142. static inline int
  143. write_tsk_long(struct task_struct *child, unsigned long addr, unsigned long val)
  144. {
  145. int copied;
  147. copied = access_process_vm(child, addr, &val, sizeof(val), 1);
  149. return copied != sizeof(val) ? -EIO : 0;
  150. }
  152. /*
  153.  * Get value of register `rn' (in the instruction)
  154.  */
  155. static unsigned long
  156. ptrace_getrn(struct task_struct *child, unsigned long insn)
  157. {
  158. unsigned int reg = (insn >> 16) & 15;
  159. unsigned long val;
  161. val = get_stack_long(child, reg);
  162. if (reg == 15)
  163. val = pc_pointer(val + 8);
  165. return val;
  166. }
  168. /*
  169.  * Get value of operand 2 (in an ALU instruction)
  170.  */
  171. static unsigned long
  172. ptrace_getaluop2(struct task_struct *child, unsigned long insn)
  173. {
  174. unsigned long val;
  175. int shift;
  176. int type;
  178. if (insn & 1 << 25) {
  179. val = insn & 255;
  180. shift = (insn >> 8) & 15;
  181. type = 3;
  182. } else {
  183. val = get_stack_long (child, insn & 15);
  185. if (insn & (1 << 4))
  186. shift = (int)get_stack_long (child, (insn >> 8) & 15);
  187. else
  188. shift = (insn >> 7) & 31;
  190. type = (insn >> 5) & 3;
  191. }
  193. switch (type) {
  194. case 0: val <<= shift; break;
  195. case 1: val >>= shift; break;
  196. case 2:
  197. val = (((signed long)val) >> shift);
  198. break;
  199. case 3:
  200.   val = (val >> shift) | (val << (32 - shift));
  201. break;
  202. }
  203. return val;
  204. }
  206. /*
  207.  * Get value of operand 2 (in a LDR instruction)
  208.  */
  209. static unsigned long
  210. ptrace_getldrop2(struct task_struct *child, unsigned long insn)
  211. {
  212. unsigned long val;
  213. int shift;
  214. int type;
  216. val = get_stack_long(child, insn & 15);
  217. shift = (insn >> 7) & 31;
  218. type = (insn >> 5) & 3;
  220. switch (type) {
  221. case 0: val <<= shift; break;
  222. case 1: val >>= shift; break;
  223. case 2:
  224. val = (((signed long)val) >> shift);
  225. break;
  226. case 3:
  227.   val = (val >> shift) | (val << (32 - shift));
  228. break;
  229. }
  230. return val;
  231. }
  233. #define OP_MASK 0x01e00000
  234. #define OP_AND 0x00000000
  235. #define OP_EOR 0x00200000
  236. #define OP_SUB 0x00400000
  237. #define OP_RSB 0x00600000
  238. #define OP_ADD 0x00800000
  239. #define OP_ADC 0x00a00000
  240. #define OP_SBC 0x00c00000
  241. #define OP_RSC 0x00e00000
  242. #define OP_ORR 0x01800000
  243. #define OP_MOV 0x01a00000
  244. #define OP_BIC 0x01c00000
  245. #define OP_MVN 0x01e00000
  247. static unsigned long
  248. get_branch_address(struct task_struct *child, unsigned long pc, unsigned long insn)
  249. {
  250. unsigned long alt = 0;
  252. switch (insn & 0x0e000000) {
  253. case 0x00000000:
  254. case 0x02000000: {
  255. /*
  256.  * data processing
  257.  */
  258. long aluop1, aluop2, ccbit;
  260. if ((insn & 0xf000) != 0xf000)
  261. break;
  263. aluop1 = ptrace_getrn(child, insn);
  264. aluop2 = ptrace_getaluop2(child, insn);
  265. ccbit  = get_stack_long(child, REG_PSR) & CC_C_BIT ? 1 : 0;
  267. switch (insn & OP_MASK) {
  268. case OP_AND: alt = aluop1 & aluop2; break;
  269. case OP_EOR: alt = aluop1 ^ aluop2; break;
  270. case OP_SUB: alt = aluop1 - aluop2; break;
  271. case OP_RSB: alt = aluop2 - aluop1; break;
  272. case OP_ADD: alt = aluop1 + aluop2; break;
  273. case OP_ADC: alt = aluop1 + aluop2 + ccbit; break;
  274. case OP_SBC: alt = aluop1 - aluop2 + ccbit; break;
  275. case OP_RSC: alt = aluop2 - aluop1 + ccbit; break;
  276. case OP_ORR: alt = aluop1 | aluop2; break;
  277. case OP_MOV: alt = aluop2; break;
  278. case OP_BIC: alt = aluop1 & ~aluop2; break;
  279. case OP_MVN: alt = ~aluop2; break;
  280. }
  281. break;
  282. }
  284. case 0x04000000:
  285. case 0x06000000:
  286. /*
  287.  * ldr
  288.  */
  289. if ((insn & 0x0010f000) == 0x0010f000) {
  290. unsigned long base;
  292. base = ptrace_getrn(child, insn);
  293. if (insn & 1 << 24) {
  294. long aluop2;
  296. if (insn & 0x02000000)
  297. aluop2 = ptrace_getldrop2(child, insn);
  298. else
  299. aluop2 = insn & 0xfff;
  301. if (insn & 1 << 23)
  302. base += aluop2;
  303. else
  304. base -= aluop2;
  305. }
  306. if (read_tsk_long(child, base, &alt) == 0)
  307. alt = pc_pointer(alt);
  308. }
  309. break;
  311. case 0x08000000:
  312. /*
  313.  * ldm
  314.  */
  315. if ((insn & 0x00108000) == 0x00108000) {
  316. unsigned long base;
  317. unsigned int nr_regs;
  319. if (insn & (1 << 23)) {
  320. nr_regs = insn & 65535;
  322. nr_regs = (nr_regs & 0x5555) + ((nr_regs & 0xaaaa) >> 1);
  323. nr_regs = (nr_regs & 0x3333) + ((nr_regs & 0xcccc) >> 2);
  324. nr_regs = (nr_regs & 0x0707) + ((nr_regs & 0x7070) >> 4);
  325. nr_regs = (nr_regs & 0x000f) + ((nr_regs & 0x0f00) >> 8);
  326. nr_regs <<= 2;
  328. if (!(insn & (1 << 24)))
  329. nr_regs -= 4;
  330. } else {
  331. if (insn & (1 << 24))
  332. nr_regs = -4;
  333. else
  334. nr_regs = 0;
  335. }
  337. base = ptrace_getrn(child, insn);
  339. if (read_tsk_long(child, base + nr_regs, &alt) == 0)
  340. alt = pc_pointer(alt);
  341. break;
  342. }
  343. break;
  345. case 0x0a000000: {
  346. /*
  347.  * bl or b
  348.  */
  349. signed long displ;
  350. /* It's a branch/branch link: instead of trying to
  351.  * figure out whether the branch will be taken or not,
  352.  * we'll put a breakpoint at both locations.  This is
  353.  * simpler, more reliable, and probably not a whole lot
  354.  * slower than the alternative approach of emulating the
  355.  * branch.
  356.  */
  357. displ = (insn & 0x00ffffff) << 8;
  358. displ = (displ >> 6) + 8;
  359. if (displ != 0 && displ != 4)
  360. alt = pc + displ;
  361.     }
  362.     break;
  363. }
  365. return alt;
  366. }
  368. static int
  369. add_breakpoint_arm(struct task_struct *child, struct debug_info *dbg, unsigned long addr)
  370. {
  371. int nr = dbg->nsaved;
  372. int res = -EINVAL;
  374. if (nr < 2) {
  375. res = read_tsk_long(child, addr, &dbg->bp[nr].insn);
  376. if (res == 0)
  377. res = write_tsk_long(child, addr, BREAKINST_ARM);
  379. if (res == 0) {
  380. dbg->bp[nr].address = addr;
  381. dbg->nsaved += 1;
  382. }
  383. } else
  384. printk(KERN_ERR "ptrace: too many breakpointsn");
  386. return res;
  387. }
  389. int ptrace_set_bpt(struct task_struct *child)
  390. {
  391. struct pt_regs *regs;
  392. unsigned long pc, insn;
  393. int res;
  395. regs = get_user_regs(child);
  396. pc = instruction_pointer(regs);
  398. res = read_tsk_long(child, pc, &insn);
  399. if (!res) {
  400. struct debug_info *dbg = &child->thread.debug;
  401. unsigned long alt;
  403. dbg->nsaved = 0;
  405. alt = get_branch_address(child, pc, insn);
  406. if (alt)
  407. res = add_breakpoint_arm(child, dbg, alt);
  409. /*
  410.  * Note that we ignore the result of setting the above
  411.  * breakpoint since it may fail.  When it does, this is
  412.  * not so much an error, but a forewarning that we may
  413.  * be receiving a prefetch abort shortly.
  414.  *
  415.  * If we don't set this breakpoint here, then we can
  416.  * loose control of the thread during single stepping.
  417.  */
  418. if (!alt || predicate(insn) != PREDICATE_ALWAYS)
  419. res = add_breakpoint_arm(child, dbg, pc + 4);
  420. }
  422. return res;
  423. }
  425. /*
  426.  * Ensure no single-step breakpoint is pending.  Returns non-zero
  427.  * value if child was being single-stepped.
  428.  */
  429. void __ptrace_cancel_bpt(struct task_struct *child)
  430. {
  431. struct debug_info *dbg = &child->thread.debug;
  432. int i, nsaved = dbg->nsaved;
  434. dbg->nsaved = 0;
  436. if (nsaved > 2) {
  437. printk("ptrace_cancel_bpt: bogus nsaved: %d!n", nsaved);
  438. nsaved = 2;
  439. }
  441. for (i = 0; i < nsaved; i++) {
  442. unsigned long tmp;
  444. read_tsk_long(child, dbg->bp[i].address, &tmp);
  445. write_tsk_long(child, dbg->bp[i].address, dbg->bp[i].insn);
  446. if (tmp != BREAKINST_ARM)
  447. printk(KERN_ERR "ptrace_cancel_bpt: weirdnessn");
  448. }
  449. }
  451. /*
  452.  * Called by kernel/ptrace.c when detaching..
  453.  *
  454.  * Make sure the single step bit is not set.
  455.  */
  456. void ptrace_disable(struct task_struct *child)
  457. {
  458. __ptrace_cancel_bpt(child);
  459. }
  461. static int do_ptrace(int request, struct task_struct *child, long addr, long data)
  462. {
  463. unsigned long tmp;
  464. int ret;
  466. switch (request) {
  467. /*
  468.  * read word at location "addr" in the child process.
  469.  */
  470. case PTRACE_PEEKTEXT:
  471. case PTRACE_PEEKDATA:
  472. ret = read_tsk_long(child, addr, &tmp);
  473. if (!ret)
  474. ret = put_user(tmp, (unsigned long *) data);
  475. break;
  477. /*
  478.  * read the word at location "addr" in the user registers.
  479.  */
  480. case PTRACE_PEEKUSR:
  481. ret = -EIO;
  482. if ((addr & 3) || addr < 0 || addr >= sizeof(struct user))
  483. break;
  485. tmp = 0;  /* Default return condition */
  486. if (addr < sizeof(struct pt_regs))
  487. tmp = get_stack_long(child, (int)addr >> 2);
  488. ret = put_user(tmp, (unsigned long *)data);
  489. break;
  491. /*
  492.  * write the word at location addr.
  493.  */
  494. case PTRACE_POKETEXT:
  495. case PTRACE_POKEDATA:
  496. ret = write_tsk_long(child, addr, data);
  497. break;
  499. /*
  500.  * write the word at location addr in the user registers.
  501.  */
  502. case PTRACE_POKEUSR:
  503. ret = -EIO;
  504. if ((addr & 3) || addr < 0 || addr >= sizeof(struct user))
  505. break;
  507. if (addr < sizeof(struct pt_regs))
  508. ret = put_stack_long(child, (int)addr >> 2, data);
  509. break;
  511. /*
  512.  * continue/restart and stop at next (return from) syscall
  513.  */
  514. case PTRACE_SYSCALL:
  515. case PTRACE_CONT:
  516. ret = -EIO;
  517. if ((unsigned long) data > _NSIG)
  518. break;
  519. if (request == PTRACE_SYSCALL)
  520. child->ptrace |= PT_TRACESYS;
  521. else
  522. child->ptrace &= ~PT_TRACESYS;
  523. child->exit_code = data;
  524. /* make sure single-step breakpoint is gone. */
  525. __ptrace_cancel_bpt(child);
  526. wake_up_process(child);
  527. ret = 0;
  528. break;
  530. /*
  531.  * make the child exit.  Best I can do is send it a sigkill.
  532.  * perhaps it should be put in the status that it wants to
  533.  * exit.
  534.  */
  535. case PTRACE_KILL:
  536. /* already dead */
  537. ret = 0;
  538. if (child->state == TASK_ZOMBIE)
  539. break;
  540. child->exit_code = SIGKILL;
  541. /* make sure single-step breakpoint is gone. */
  542. __ptrace_cancel_bpt(child);
  543. wake_up_process(child);
  544. ret = 0;
  545. break;
  547. /*
  548.  * execute single instruction.
  549.  */
  550. case PTRACE_SINGLESTEP:
  551. ret = -EIO;
  552. if ((unsigned long) data > _NSIG)
  553. break;
  554. child->thread.debug.nsaved = -1;
  555. child->ptrace &= ~PT_TRACESYS;
  556. child->exit_code = data;
  557. /* give it a chance to run. */
  558. wake_up_process(child);
  559. ret = 0;
  560. break;
  562. /*
  563.  * detach a process that was attached.
  564.  */
  565. case PTRACE_DETACH:
  566. ret = ptrace_detach(child, data);
  567. break;
  569. /*
  570.  * Get all gp regs from the child.
  571.  */
  572. case PTRACE_GETREGS: {
  573. struct pt_regs *regs = get_user_regs(child);
  575. ret = 0;
  576. if (copy_to_user((void *)data, regs,
  577.  sizeof(struct pt_regs)))
  578. ret = -EFAULT;
  580. break;
  581. }
  583. /*
  584.  * Set all gp regs in the child.
  585.  */
  586. case PTRACE_SETREGS: {
  587. struct pt_regs newregs;
  589. ret = -EFAULT;
  590. if (copy_from_user(&newregs, (void *)data,
  591.    sizeof(struct pt_regs)) == 0) {
  592. struct pt_regs *regs = get_user_regs(child);
  594. ret = -EINVAL;
  595. if (valid_user_regs(&newregs)) {
  596. *regs = newregs;
  597. ret = 0;
  598. }
  599. }
  600. break;
  601. }
  603. /*
  604.  * Get the child FPU state.
  605.  */
  606. case PTRACE_GETFPREGS:
  607. ret = -EIO;
  608. if (!access_ok(VERIFY_WRITE, (void *)data, sizeof(struct user_fp)))
  609. break;
  611. /* we should check child->used_math here */
  612. ret = __copy_to_user((void *)data, &child->thread.fpstate,
  613.      sizeof(struct user_fp)) ? -EFAULT : 0;
  614. break;
  616. /*
  617.  * Set the child FPU state.
  618.  */
  619. case PTRACE_SETFPREGS:
  620. ret = -EIO;
  621. if (!access_ok(VERIFY_READ, (void *)data, sizeof(struct user_fp)))
  622. break;
  624. child->used_math = 1;
  625. ret = __copy_from_user(&child->thread.fpstate, (void *)data,
  626.    sizeof(struct user_fp)) ? -EFAULT : 0;
  627. break;
  629. default:
  630. ret = -EIO;
  631. break;
  632. }
  634. return ret;
  635. }
  637. asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
  638. {
  639. struct task_struct *child;
  640. int ret;
  642. lock_kernel();
  643. ret = -EPERM;
  644. if (request == PTRACE_TRACEME) {
  645. /* are we already being traced? */
  646. if (current->ptrace & PT_PTRACED)
  647. goto out;
  648. /* set the ptrace bit in the process flags. */
  649. current->ptrace |= PT_PTRACED;
  650. ret = 0;
  651. goto out;
  652. }
  653. ret = -ESRCH;
  654. read_lock(&tasklist_lock);
  655. child = find_task_by_pid(pid);
  656. if (child)
  657. get_task_struct(child);
  658. read_unlock(&tasklist_lock);
  659. if (!child)
  660. goto out;
  662. ret = -EPERM;
  663. if (pid == 1) /* you may not mess with init */
  664. goto out_tsk;
  666. if (request == PTRACE_ATTACH) {
  667. ret = ptrace_attach(child);
  668. goto out_tsk;
  669. }
  670. ret = -ESRCH;
  671. if (!(child->ptrace & PT_PTRACED))
  672. goto out_tsk;
  673. if (child->state != TASK_STOPPED && request != PTRACE_KILL)
  674. goto out_tsk;
  675. if (child->p_pptr != current)
  676. goto out_tsk;
  678. ret = do_ptrace(request, child, addr, data);
  680. out_tsk:
  681. free_task_struct(child);
  682. out:
  683. unlock_kernel();
  684. return ret;
  685. }
  687. asmlinkage void syscall_trace(int why, struct pt_regs *regs)
  688. {
  689. unsigned long ip;
  691. if ((current->ptrace & (PT_PTRACED|PT_TRACESYS))
  692. != (PT_PTRACED|PT_TRACESYS))
  693. return;
  695. /*
  696.  * Save IP.  IP is used to denote syscall entry/exit:
  697.  *  IP = 0 -> entry, = 1 -> exit
  698.  */
  699. ip = regs->ARM_ip;
  700. regs->ARM_ip = why;
  702. /* the 0x80 provides a way for the tracing parent to distinguish
  703.    between a syscall stop and SIGTRAP delivery */
  704. current->exit_code = SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
  705. ? 0x80 : 0);
  706. current->state = TASK_STOPPED;
  707. notify_parent(current, SIGCHLD);
  708. schedule();
  709. /*
  710.  * this isn't the same as continuing with a signal, but it will do
  711.  * for normal use.  strace only continues with a signal if the
  712.  * stopping signal is not SIGTRAP.  -brl
  713.  */
  714. if (current->exit_code) {
  715. send_sig(current->exit_code, current, 1);
  716. current->exit_code = 0;
  717. }
  718. regs->ARM_ip = ip;
  719. }