![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /* ptrace.c */
2 /* By Ross Biro 1/23/92 */
3 /* edited by Linus Torvalds */
4
5 #include <linux/head.h>
6 #include <linux/kernel.h>
7 #include <linux/sched.h>
8 #include <linux/mm.h>
9 #include <linux/errno.h>
10 #include <linux/ptrace.h>
11
12 #include <asm/segment.h>
13 #include <asm/system.h>
14
15 /*
16 * does not yet catch signals sent when the child dies.
17 * in exit.c or in signal.c.
18 */
19
20 /* determines which flags the user has access to. */
21 /* 1 = access 0 = no access */
22 #define FLAG_MASK 0x00000dd9
23
24 /* set's the trap flag. */
25 #define TRAP_FLAG 0x100
26
27 /*
28 * this is the number to subtract from the top of the stack. To find
29 * the local frame.
30 */
31 #define MAGICNUMBER 68
32
33 /* change a pid into a task struct. */
34 static inline struct task_struct * get_task(int pid)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
35 {
36 int i;
37
38 for (i = 1; i < NR_TASKS; i++) {
39 if (task[i] != NULL && (task[i]->pid == pid))
40 return task[i];
41 }
42 return NULL;
43 }
44
45 /*
46 * this routine will get a word off of the processes priviledged stack.
47 * the offset is how far from the base addr as stored in the TSS.
48 * this routine assumes that all the priviledged stacks are in our
49 * data space.
50 */
51 static inline int get_stack_long(struct task_struct *task, int offset)
/* ![[previous]](../icons/left.png)
*/
52 {
53 unsigned char *stack;
54
55 stack = (unsigned char *)task->tss.esp0;
56 stack += offset;
57 return (*((int *)stack));
58 }
59
60 /*
61 * this routine will put a word on the processes priviledged stack.
62 * the offset is how far from the base addr as stored in the TSS.
63 * this routine assumes that all the priviledged stacks are in our
64 * data space.
65 */
66 static inline int put_stack_long(struct task_struct *task, int offset,
/* */
67 unsigned long data)
68 {
69 unsigned char * stack;
70
71 stack = (unsigned char *) task->tss.esp0;
72 stack += offset;
73 *(unsigned long *) stack = data;
74 return 0;
75 }
76
77 /*
78 * This routine gets a long from any process space by following the page
79 * tables. NOTE! You should check that the long isn't on a page boundary,
80 * and that it is in the task area before calling this: this routine does
81 * no checking.
82 *
83 * NOTE2! This uses "tsk->tss.cr3" even though we know it's currently always
84 * zero. This routine shouldn't have to change when we make a better mm.
85 */
86 static unsigned long get_long(struct task_struct * tsk,
/* */
87 unsigned long addr)
88 {
89 unsigned long page;
90
91 repeat:
92 page = tsk->tss.cr3 + ((addr >> 20) & 0xffc);
93 page = *(unsigned long *) page;
94 if (page & PAGE_PRESENT) {
95 page &= 0xfffff000;
96 page += (addr >> 10) & 0xffc;
97 page = *((unsigned long *) page);
98 }
99 if (!(page & PAGE_PRESENT)) {
100 do_no_page(0,addr,tsk,0);
101 goto repeat;
102 }
103 page &= 0xfffff000;
104 page += addr & 0xfff;
105 return *(unsigned long *) page;
106 }
107
108 /*
109 * This routine puts a long into any process space by following the page
110 * tables. NOTE! You should check that the long isn't on a page boundary,
111 * and that it is in the task area before calling this: this routine does
112 * no checking.
113 */
114 static void put_long(struct task_struct * tsk, unsigned long addr,
/* */
115 unsigned long data)
116 {
117 unsigned long page;
118
119 repeat:
120 page = tsk->tss.cr3 + ((addr >> 20) & 0xffc);
121 page = *(unsigned long *) page;
122 if (page & PAGE_PRESENT) {
123 page &= 0xfffff000;
124 page += (addr >> 10) & 0xffc;
125 /* we're bypassing pagetables, so we have to set the dirty bit ourselves */
126 *(unsigned long *) page |= PAGE_DIRTY;
127 page = *((unsigned long *) page);
128 }
129 if (!(page & PAGE_PRESENT)) {
130 do_no_page(0,addr,tsk,0);
131 goto repeat;
132 }
133 if (!(page & PAGE_RW)) {
134 do_wp_page(0,addr,tsk,0);
135 goto repeat;
136 }
137 page &= 0xfffff000;
138 page += addr & 0xfff;
139 *(unsigned long *) page = data;
140 }
141
142 /*
143 * This routine checks the page boundaries, and that the offset is
144 * within the task area. It then calls get_long() to read a long.
145 */
146 static int read_long(struct task_struct * tsk, unsigned long addr,
/* */
147 unsigned long * result)
148 {
149 unsigned long low,high;
150
151 if (addr > TASK_SIZE-4)
152 return -EIO;
153 if ((addr & 0xfff) > PAGE_SIZE-4) {
154 low = get_long(tsk,addr & 0xfffffffc);
155 high = get_long(tsk,(addr+4) & 0xfffffffc);
156 switch (addr & 3) {
157 case 1:
158 low >>= 8;
159 low |= high << 24;
160 break;
161 case 2:
162 low >>= 16;
163 low |= high << 16;
164 break;
165 case 3:
166 low >>= 24;
167 low |= high << 8;
168 break;
169 }
170 *result = low;
171 } else
172 *result = get_long(tsk,addr);
173 return 0;
174 }
175
176 /*
177 * This routine checks the page boundaries, and that the offset is
178 * within the task area. It then calls put_long() to write a long.
179 */
180 static int write_long(struct task_struct * tsk, unsigned long addr,
/* */
181 unsigned long data)
182 {
183 unsigned long low,high;
184
185 if (addr > TASK_SIZE-4)
186 return -EIO;
187 if ((addr & 0xfff) > PAGE_SIZE-4) {
188 low = get_long(tsk,addr & 0xfffffffc);
189 high = get_long(tsk,(addr+4) & 0xfffffffc);
190 switch (addr & 3) {
191 case 0: /* shouldn't happen, but safety first */
192 low = data;
193 break;
194 case 1:
195 low &= 0x000000ff;
196 low |= data << 8;
197 high &= 0xffffff00;
198 high |= data >> 24;
199 break;
200 case 2:
201 low &= 0x0000ffff;
202 low |= data << 16;
203 high &= 0xffff0000;
204 high |= data >> 16;
205 break;
206 case 3:
207 low &= 0x00ffffff;
208 low |= data << 24;
209 high &= 0xff000000;
210 high |= data >> 8;
211 break;
212 }
213 put_long(tsk,addr & 0xfffffffc,low);
214 put_long(tsk,(addr+4) & 0xfffffffc,high);
215 } else
216 put_long(tsk,addr,data);
217 return 0;
218 }
219
220 int sys_ptrace(long request, long pid, long addr, long data)
/* ![[last]](../icons/n_last.png)
*/
221 {
222 struct task_struct *child;
223
224 if (request == PTRACE_TRACEME) {
225 /* are we already being traced? */
226 if (current->flags & PF_PTRACED)
227 return -EPERM;
228 /* set the ptrace bit in the proccess flags. */
229 current->flags |= PF_PTRACED;
230 return 0;
231 }
232 if (pid == 1) /* you may not mess with init */
233 return -EPERM;
234 if (!(child = get_task(pid)))
235 return -ESRCH;
236 if (request == PTRACE_ATTACH) {
237 long tmp;
238
239 if (child == current)
240 return -EPERM;
241 if ((!child->dumpable || (current->uid != child->euid) ||
242 (current->gid != child->egid)) && !suser())
243 return -EPERM;
244 /* the same process cannot be attached many times */
245 if (child->flags & PF_PTRACED)
246 return -EPERM;
247 child->flags |= PF_PTRACED;
248 if (child->p_pptr != current) {
249 REMOVE_LINKS(child);
250 child->p_pptr = current;
251 SET_LINKS(child);
252 }
253 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) | TRAP_FLAG;
254 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
255 if (child->state == TASK_INTERRUPTIBLE ||
256 child->state == TASK_STOPPED)
257 child->state = TASK_RUNNING;
258 child->signal = 0;
259 return 0;
260 }
261 if (!(child->flags & PF_PTRACED) || child->state != TASK_STOPPED)
262 return -ESRCH;
263 if (child->p_pptr != current)
264 return -ESRCH;
265
266 switch (request) {
267 /* when I and D space are seperate, these will need to be fixed. */
268 case PTRACE_PEEKTEXT: /* read word at location addr. */
269 case PTRACE_PEEKDATA: {
270 int tmp,res;
271
272 res = read_long(child, addr, &tmp);
273 if (res < 0)
274 return res;
275 verify_area((void *) data, 4);
276 put_fs_long(tmp,(unsigned long *) data);
277 return 0;
278 }
279
280 /* read the word at location addr in the USER area. */
281 case PTRACE_PEEKUSR: {
282 int tmp;
283 addr = addr >> 2; /* temporary hack. */
284 if (addr < 0 || addr >= 17)
285 return -EIO;
286 verify_area((void *) data, 4);
287 tmp = get_stack_long(child, 4*addr - MAGICNUMBER);
288 put_fs_long(tmp,(unsigned long *) data);
289 return 0;
290 }
291
292 /* when I and D space are seperate, this will have to be fixed. */
293 case PTRACE_POKETEXT: /* write the word at location addr. */
294 case PTRACE_POKEDATA:
295 return write_long(child,addr,data);
296
297 case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
298 addr = addr >> 2; /* temproary hack. */
299 if (addr < 0 || addr >= 17)
300 return -EIO;
301 if (addr == ORIG_EAX)
302 return -EIO;
303 if (addr == EFL) { /* flags. */
304 data &= FLAG_MASK;
305 data |= get_stack_long(child, EFL*4-MAGICNUMBER) & ~FLAG_MASK;
306 }
307 if (put_stack_long(child, 4*addr-MAGICNUMBER, data))
308 return -EIO;
309 return 0;
310
311 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
312 case PTRACE_CONT: { /* restart after signal. */
313 long tmp;
314
315 if (request == PTRACE_SYSCALL)
316 child->flags |= PF_TRACESYS;
317 else
318 child->flags &= ~PF_TRACESYS;
319 child->signal = 0;
320 if (data > 0 && data <= NSIG)
321 child->signal = 1<<(data-1);
322 child->state = TASK_RUNNING;
323 /* make sure the single step bit is not set. */
324 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) & ~TRAP_FLAG;
325 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
326 return 0;
327 }
328
329 /*
330 * make the child exit. Best I can do is send it a sigkill.
331 * perhaps it should be put in the status that it want's to
332 * exit.
333 */
334 case PTRACE_KILL: {
335 long tmp;
336
337 child->state = TASK_RUNNING;
338 child->signal = 1 << (SIGKILL-1);
339 /* make sure the single step bit is not set. */
340 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) & ~TRAP_FLAG;
341 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
342 return 0;
343 }
344
345 case PTRACE_SINGLESTEP: { /* set the trap flag. */
346 long tmp;
347
348 child->flags &= ~PF_TRACESYS;
349 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) | TRAP_FLAG;
350 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
351 child->state = TASK_RUNNING;
352 child->signal = 0;
353 if (data > 0 && data <= NSIG)
354 child->signal= 1<<(data-1);
355 /* give it a chance to run. */
356 return 0;
357 }
358
359 case PTRACE_DETACH: { /* detach a process that was attached. */
360 long tmp;
361
362 child->flags &= ~(PF_PTRACED|PF_TRACESYS);
363 child->signal=0;
364 child->state = 0;
365 REMOVE_LINKS(child);
366 child->p_pptr = child->p_opptr;
367 SET_LINKS(child);
368 /* make sure the single step bit is not set. */
369 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) & ~TRAP_FLAG;
370 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
371 return 0;
372 }
373
374 default:
375 return -EIO;
376 }
377 }
![[bottom]](../icons/n_bottom.png){kind=icon}
*/