Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Licensed under the GPL |
| 4 | */ |
| 5 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | #include "linux/audit.h" |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 7 | #include "linux/ptrace.h" |
| 8 | #include "linux/sched.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | #include "asm/uaccess.h" |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 10 | #ifdef CONFIG_PROC_MM |
| 11 | #include "proc_mm.h" |
| 12 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include "skas_ptrace.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
Bodo Stroesser | 82c1c11 | 2005-05-06 21:30:46 -0700 | [diff] [blame] | 15 | static inline void set_singlestepping(struct task_struct *child, int on) |
| 16 | { |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 17 | if (on) |
| 18 | child->ptrace |= PT_DTRACE; |
| 19 | else |
| 20 | child->ptrace &= ~PT_DTRACE; |
| 21 | child->thread.singlestep_syscall = 0; |
Bodo Stroesser | 82c1c11 | 2005-05-06 21:30:46 -0700 | [diff] [blame] | 22 | |
| 23 | #ifdef SUBARCH_SET_SINGLESTEPPING |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 24 | SUBARCH_SET_SINGLESTEPPING(child, on); |
Bodo Stroesser | 82c1c11 | 2005-05-06 21:30:46 -0700 | [diff] [blame] | 25 | #endif |
Jeff Dike | ba9950c | 2005-05-20 13:59:07 -0700 | [diff] [blame] | 26 | } |
Bodo Stroesser | 82c1c11 | 2005-05-06 21:30:46 -0700 | [diff] [blame] | 27 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | /* |
| 29 | * Called by kernel/ptrace.c when detaching.. |
| 30 | */ |
| 31 | void ptrace_disable(struct task_struct *child) |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 32 | { |
| 33 | set_singlestepping(child,0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | } |
| 35 | |
Bodo Stroesser | 82c1c11 | 2005-05-06 21:30:46 -0700 | [diff] [blame] | 36 | extern int peek_user(struct task_struct * child, long addr, long data); |
| 37 | extern int poke_user(struct task_struct * child, long addr, long data); |
| 38 | |
Christoph Hellwig | 481bed4 | 2005-11-07 00:59:47 -0800 | [diff] [blame] | 39 | long arch_ptrace(struct task_struct *child, long request, long addr, long data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | int i, ret; |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 42 | unsigned long __user *p = (void __user *)(unsigned long)data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | switch (request) { |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 45 | /* read word at location addr. */ |
| 46 | case PTRACE_PEEKTEXT: |
Alexey Dobriyan | 7664732 | 2007-07-17 04:03:43 -0700 | [diff] [blame] | 47 | case PTRACE_PEEKDATA: |
| 48 | ret = generic_ptrace_peekdata(child, addr, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
| 51 | /* read the word at location addr in the USER area. */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 52 | case PTRACE_PEEKUSR: |
| 53 | ret = peek_user(child, addr, data); |
| 54 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 56 | /* write the word at location addr. */ |
| 57 | case PTRACE_POKETEXT: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | case PTRACE_POKEDATA: |
Alexey Dobriyan | f284ce7 | 2007-07-17 04:03:44 -0700 | [diff] [blame] | 59 | ret = generic_ptrace_pokedata(child, addr, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | break; |
| 61 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 62 | /* write the word at location addr in the USER area */ |
| 63 | case PTRACE_POKEUSR: |
| 64 | ret = poke_user(child, addr, data); |
| 65 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 67 | /* continue and stop at next (return from) syscall */ |
| 68 | case PTRACE_SYSCALL: |
| 69 | /* restart after signal. */ |
| 70 | case PTRACE_CONT: { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | ret = -EIO; |
Jesper Juhl | 7ed20e1 | 2005-05-01 08:59:14 -0700 | [diff] [blame] | 72 | if (!valid_signal(data)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | break; |
| 74 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 75 | set_singlestepping(child, 0); |
| 76 | if (request == PTRACE_SYSCALL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 78 | else clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | child->exit_code = data; |
| 80 | wake_up_process(child); |
| 81 | ret = 0; |
| 82 | break; |
| 83 | } |
| 84 | |
| 85 | /* |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 86 | * make the child exit. Best I can do is send it a sigkill. |
| 87 | * perhaps it should be put in the status that it wants to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | * exit. |
| 89 | */ |
| 90 | case PTRACE_KILL: { |
| 91 | ret = 0; |
| 92 | if (child->exit_state == EXIT_ZOMBIE) /* already dead */ |
| 93 | break; |
| 94 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 95 | set_singlestepping(child, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | child->exit_code = SIGKILL; |
| 97 | wake_up_process(child); |
| 98 | break; |
| 99 | } |
| 100 | |
| 101 | case PTRACE_SINGLESTEP: { /* set the trap flag. */ |
| 102 | ret = -EIO; |
Jesper Juhl | 7ed20e1 | 2005-05-01 08:59:14 -0700 | [diff] [blame] | 103 | if (!valid_signal(data)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | break; |
| 105 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 106 | set_singlestepping(child, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | child->exit_code = data; |
| 108 | /* give it a chance to run. */ |
| 109 | wake_up_process(child); |
| 110 | ret = 0; |
| 111 | break; |
| 112 | } |
| 113 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | #ifdef PTRACE_GETREGS |
| 115 | case PTRACE_GETREGS: { /* Get all gp regs from the child. */ |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 116 | if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | ret = -EIO; |
| 118 | break; |
| 119 | } |
| 120 | for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 121 | __put_user(getreg(child, i), p); |
| 122 | p++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | } |
| 124 | ret = 0; |
| 125 | break; |
| 126 | } |
| 127 | #endif |
| 128 | #ifdef PTRACE_SETREGS |
| 129 | case PTRACE_SETREGS: { /* Set all gp regs in the child. */ |
| 130 | unsigned long tmp = 0; |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 131 | if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | ret = -EIO; |
| 133 | break; |
| 134 | } |
| 135 | for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 136 | __get_user(tmp, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | putreg(child, i, tmp); |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 138 | p++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | } |
| 140 | ret = 0; |
| 141 | break; |
| 142 | } |
| 143 | #endif |
| 144 | #ifdef PTRACE_GETFPREGS |
| 145 | case PTRACE_GETFPREGS: /* Get the child FPU state. */ |
Jeff Dike | e8012b5 | 2007-10-16 01:27:16 -0700 | [diff] [blame] | 146 | ret = get_fpregs((struct user_i387_struct __user *) data, |
| 147 | child); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | break; |
| 149 | #endif |
| 150 | #ifdef PTRACE_SETFPREGS |
| 151 | case PTRACE_SETFPREGS: /* Set the child FPU state. */ |
Jeff Dike | e8012b5 | 2007-10-16 01:27:16 -0700 | [diff] [blame] | 152 | ret = set_fpregs((struct user_i387_struct __user *) data, |
| 153 | child); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | break; |
| 155 | #endif |
Paolo 'Blaisorblade' Giarrusso | aa6758d | 2006-03-31 02:30:22 -0800 | [diff] [blame] | 156 | case PTRACE_GET_THREAD_AREA: |
| 157 | ret = ptrace_get_thread_area(child, addr, |
| 158 | (struct user_desc __user *) data); |
| 159 | break; |
| 160 | |
| 161 | case PTRACE_SET_THREAD_AREA: |
| 162 | ret = ptrace_set_thread_area(child, addr, |
| 163 | (struct user_desc __user *) data); |
| 164 | break; |
| 165 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | case PTRACE_FAULTINFO: { |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 167 | /* |
| 168 | * Take the info from thread->arch->faultinfo, |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 169 | * but transfer max. sizeof(struct ptrace_faultinfo). |
| 170 | * On i386, ptrace_faultinfo is smaller! |
| 171 | */ |
| 172 | ret = copy_to_user(p, &child->thread.arch.faultinfo, |
| 173 | sizeof(struct ptrace_faultinfo)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | break; |
| 175 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | |
Bodo Stroesser | c578455 | 2005-05-05 16:15:31 -0700 | [diff] [blame] | 177 | #ifdef PTRACE_LDT |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | case PTRACE_LDT: { |
| 179 | struct ptrace_ldt ldt; |
| 180 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 181 | if (copy_from_user(&ldt, p, sizeof(ldt))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | ret = -EIO; |
| 183 | break; |
| 184 | } |
| 185 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 186 | /* |
| 187 | * This one is confusing, so just punt and return -EIO for |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | * now |
| 189 | */ |
| 190 | ret = -EIO; |
| 191 | break; |
| 192 | } |
Bodo Stroesser | c578455 | 2005-05-05 16:15:31 -0700 | [diff] [blame] | 193 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | #ifdef CONFIG_PROC_MM |
| 195 | case PTRACE_SWITCH_MM: { |
| 196 | struct mm_struct *old = child->mm; |
| 197 | struct mm_struct *new = proc_mm_get_mm(data); |
| 198 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 199 | if (IS_ERR(new)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | ret = PTR_ERR(new); |
| 201 | break; |
| 202 | } |
| 203 | |
| 204 | atomic_inc(&new->mm_users); |
| 205 | child->mm = new; |
| 206 | child->active_mm = new; |
| 207 | mmput(old); |
| 208 | ret = 0; |
| 209 | break; |
| 210 | } |
| 211 | #endif |
Jeff Dike | 6e6d74c | 2007-02-10 01:44:30 -0800 | [diff] [blame] | 212 | #ifdef PTRACE_ARCH_PRCTL |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 213 | case PTRACE_ARCH_PRCTL: |
| 214 | /* XXX Calls ptrace on the host - needs some SMP thinking */ |
| 215 | ret = arch_prctl(child, data, (void *) addr); |
| 216 | break; |
Jeff Dike | 6e6d74c | 2007-02-10 01:44:30 -0800 | [diff] [blame] | 217 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | default: |
| 219 | ret = ptrace_request(child, request, addr, data); |
Jeff Dike | e8012b5 | 2007-10-16 01:27:16 -0700 | [diff] [blame] | 220 | if (ret == -EIO) |
| 221 | ret = subarch_ptrace(child, request, addr, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | break; |
| 223 | } |
Christoph Hellwig | 481bed4 | 2005-11-07 00:59:47 -0800 | [diff] [blame] | 224 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | return ret; |
| 226 | } |
| 227 | |
Jeff Dike | 77bf440 | 2007-10-16 01:26:58 -0700 | [diff] [blame] | 228 | void send_sigtrap(struct task_struct *tsk, struct uml_pt_regs *regs, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | int error_code) |
| 230 | { |
| 231 | struct siginfo info; |
| 232 | |
| 233 | memset(&info, 0, sizeof(info)); |
| 234 | info.si_signo = SIGTRAP; |
| 235 | info.si_code = TRAP_BRKPT; |
| 236 | |
| 237 | /* User-mode eip? */ |
| 238 | info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL; |
| 239 | |
Simon Arlott | b60745b | 2007-10-20 01:23:03 +0200 | [diff] [blame] | 240 | /* Send us the fake SIGTRAP */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | force_sig_info(SIGTRAP, &info, tsk); |
| 242 | } |
| 243 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 244 | /* |
| 245 | * XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check |
| 247 | */ |
Jeff Dike | 77bf440 | 2007-10-16 01:26:58 -0700 | [diff] [blame] | 248 | void syscall_trace(struct uml_pt_regs *regs, int entryexit) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | { |
| 250 | int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit; |
| 251 | int tracesysgood; |
| 252 | |
| 253 | if (unlikely(current->audit_context)) { |
| 254 | if (!entryexit) |
Al Viro | 5411be5 | 2006-03-29 20:23:36 -0500 | [diff] [blame] | 255 | audit_syscall_entry(HOST_AUDIT_ARCH, |
Jeff Dike | 79d20b1 | 2005-05-03 07:54:51 +0100 | [diff] [blame] | 256 | UPT_SYSCALL_NR(regs), |
| 257 | UPT_SYSCALL_ARG1(regs), |
| 258 | UPT_SYSCALL_ARG2(regs), |
| 259 | UPT_SYSCALL_ARG3(regs), |
| 260 | UPT_SYSCALL_ARG4(regs)); |
Al Viro | 5411be5 | 2006-03-29 20:23:36 -0500 | [diff] [blame] | 261 | else audit_syscall_exit(AUDITSC_RESULT(UPT_SYSCALL_RET(regs)), |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 262 | UPT_SYSCALL_RET(regs)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | /* Fake a debug trap */ |
| 266 | if (is_singlestep) |
| 267 | send_sigtrap(current, regs, 0); |
| 268 | |
| 269 | if (!test_thread_flag(TIF_SYSCALL_TRACE)) |
| 270 | return; |
| 271 | |
| 272 | if (!(current->ptrace & PT_PTRACED)) |
| 273 | return; |
| 274 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 275 | /* |
| 276 | * the 0x80 provides a way for the tracing parent to distinguish |
| 277 | * between a syscall stop and SIGTRAP delivery |
| 278 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | tracesysgood = (current->ptrace & PT_TRACESYSGOOD); |
| 280 | ptrace_notify(SIGTRAP | (tracesysgood ? 0x80 : 0)); |
| 281 | |
| 282 | if (entryexit) /* force do_signal() --> is_syscall() */ |
| 283 | set_thread_flag(TIF_SIGPENDING); |
| 284 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 285 | /* |
| 286 | * this isn't the same as continuing with a signal, but it will do |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | * for normal use. strace only continues with a signal if the |
| 288 | * stopping signal is not SIGTRAP. -brl |
| 289 | */ |
| 290 | if (current->exit_code) { |
| 291 | send_sig(current->exit_code, current, 1); |
| 292 | current->exit_code = 0; |
| 293 | } |
| 294 | } |