![[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 page = *((unsigned long *) page);
126 }
127 if (!(page & PAGE_PRESENT)) {
128 do_no_page(0,addr,tsk,0);
129 goto repeat;
130 }
131 if (!(page & PAGE_RW)) {
132 do_wp_page(0,addr,tsk,0);
133 goto repeat;
134 }
135 page &= 0xfffff000;
136 page += addr & 0xfff;
137 *(unsigned long *) page = data;
138 }
139
140 /*
141 * This routine checks the page boundaries, and that the offset is
142 * within the task area. It then calls get_long() to read a long.
143 */
144 static int read_long(struct task_struct * tsk, unsigned long addr,
/* */
145 unsigned long * result)
146 {
147 unsigned long low,high;
148
149 if (addr > TASK_SIZE-4)
150 return -EIO;
151 if ((addr & 0xfff) > PAGE_SIZE-4) {
152 low = get_long(tsk,addr & 0xfffffffc);
153 high = get_long(tsk,(addr+4) & 0xfffffffc);
154 switch (addr & 3) {
155 case 1:
156 low >>= 8;
157 low |= high << 24;
158 break;
159 case 2:
160 low >>= 16;
161 low |= high << 16;
162 break;
163 case 3:
164 low >>= 24;
165 low |= high << 8;
166 break;
167 }
168 *result = low;
169 } else
170 *result = get_long(tsk,addr);
171 return 0;
172 }
173
174 /*
175 * This routine checks the page boundaries, and that the offset is
176 * within the task area. It then calls put_long() to write a long.
177 */
178 static int write_long(struct task_struct * tsk, unsigned long addr,
/* */
179 unsigned long data)
180 {
181 unsigned long low,high;
182
183 if (addr > TASK_SIZE-4)
184 return -EIO;
185 if ((addr & 0xfff) > PAGE_SIZE-4) {
186 low = get_long(tsk,addr & 0xfffffffc);
187 high = get_long(tsk,(addr+4) & 0xfffffffc);
188 switch (addr & 3) {
189 case 0: /* shouldn't happen, but safety first */
190 low = data;
191 break;
192 case 1:
193 low &= 0x000000ff;
194 low |= data << 8;
195 high &= 0xffffff00;
196 high |= data >> 24;
197 break;
198 case 2:
199 low &= 0x0000ffff;
200 low |= data << 16;
201 high &= 0xffff0000;
202 high |= data >> 16;
203 break;
204 case 3:
205 low &= 0x00ffffff;
206 low |= data << 24;
207 high &= 0xff000000;
208 high |= data >> 8;
209 break;
210 }
211 put_long(tsk,addr & 0xfffffffc,low);
212 put_long(tsk,(addr+4) & 0xfffffffc,high);
213 } else
214 put_long(tsk,addr,data);
215 return 0;
216 }
217
218 int sys_ptrace(long request, long pid, long addr, long data)
/* ![[last]](../icons/n_last.png)
*/
219 {
220 struct task_struct *child;
221
222 if (request == PTRACE_TRACEME) {
223 /* are we already being traced? */
224 if (current->flags & PF_PTRACED)
225 return -EPERM;
226 /* set the ptrace bit in the proccess flags. */
227 current->flags |= PF_PTRACED;
228 return 0;
229 }
230 if (!(child = get_task(pid)))
231 return -ESRCH;
232 if (request == PTRACE_ATTACH) {
233 long tmp;
234
235 if (child == current)
236 return -EPERM;
237 if ((!child->dumpable || (current->uid != child->euid) ||
238 (current->gid != child->egid)) && !suser())
239 return -EPERM;
240 /* the same process cannot be attached many times */
241 if (child->flags & PF_PTRACED)
242 return -EPERM;
243 child->flags |= PF_PTRACED;
244 if (child->p_pptr != current) {
245 REMOVE_LINKS(child);
246 child->p_pptr = current;
247 SET_LINKS(child);
248 }
249 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) | TRAP_FLAG;
250 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
251 if (child->state == TASK_INTERRUPTIBLE ||
252 child->state == TASK_STOPPED)
253 child->state = TASK_RUNNING;
254 child->signal = 0;
255 return 0;
256 }
257 if (!(child->flags & PF_PTRACED) || child->state != TASK_STOPPED)
258 return -ESRCH;
259 if (child->p_pptr != current)
260 return -ESRCH;
261
262 switch (request) {
263 /* when I and D space are seperate, these will need to be fixed. */
264 case PTRACE_PEEKTEXT: /* read word at location addr. */
265 case PTRACE_PEEKDATA: {
266 int tmp,res;
267
268 res = read_long(child, addr, &tmp);
269 if (res < 0)
270 return res;
271 verify_area((void *) data, 4);
272 put_fs_long(tmp,(unsigned long *) data);
273 return 0;
274 }
275
276 /* read the word at location addr in the USER area. */
277 case PTRACE_PEEKUSR: {
278 int tmp;
279 addr = addr >> 2; /* temporary hack. */
280 if (addr < 0 || addr >= 17)
281 return -EIO;
282 verify_area((void *) data, 4);
283 tmp = get_stack_long(child, 4*addr - MAGICNUMBER);
284 put_fs_long(tmp,(unsigned long *) data);
285 return 0;
286 }
287
288 /* when I and D space are seperate, this will have to be fixed. */
289 case PTRACE_POKETEXT: /* write the word at location addr. */
290 case PTRACE_POKEDATA:
291 return write_long(child,addr,data);
292
293 case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
294 addr = addr >> 2; /* temproary hack. */
295 if (addr < 0 || addr >= 17)
296 return -EIO;
297 if (addr == ORIG_EAX)
298 return -EIO;
299 if (addr == EFL) { /* flags. */
300 data &= FLAG_MASK;
301 data |= get_stack_long(child, EFL*4-MAGICNUMBER) & ~FLAG_MASK;
302 }
303 if (put_stack_long(child, 4*addr-MAGICNUMBER, data))
304 return -EIO;
305 return 0;
306
307 case PTRACE_CONT: { /* restart after signal. */
308 long tmp;
309
310 child->signal = 0;
311 if (data > 0 && data <= NSIG)
312 child->signal = 1<<(data-1);
313 child->state = TASK_RUNNING;
314 /* make sure the single step bit is not set. */
315 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) & ~TRAP_FLAG;
316 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
317 return 0;
318 }
319
320 /*
321 * make the child exit. Best I can do is send it a sigkill.
322 * perhaps it should be put in the status that it want's to
323 * exit.
324 */
325 case PTRACE_KILL: {
326 long tmp;
327
328 child->state = TASK_RUNNING;
329 child->signal = 1 << (SIGKILL-1);
330 /* make sure the single step bit is not set. */
331 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) & ~TRAP_FLAG;
332 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
333 return 0;
334 }
335
336 case PTRACE_SINGLESTEP: { /* set the trap flag. */
337 long tmp;
338
339 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) | TRAP_FLAG;
340 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
341 child->state = TASK_RUNNING;
342 child->signal = 0;
343 if (data > 0 && data <= NSIG)
344 child->signal= 1<<(data-1);
345 /* give it a chance to run. */
346 return 0;
347 }
348
349 case PTRACE_DETACH: { /* detach a process that was attached. */
350 long tmp;
351
352 child->flags &= ~PF_PTRACED;
353 child->signal=0;
354 child->state = 0;
355 REMOVE_LINKS(child);
356 child->p_pptr = child->p_opptr;
357 SET_LINKS(child);
358 /* make sure the single step bit is not set. */
359 tmp = get_stack_long(child, 4*EFL-MAGICNUMBER) & ~TRAP_FLAG;
360 put_stack_long(child, 4*EFL-MAGICNUMBER,tmp);
361 return 0;
362 }
363
364 default:
365 return -EIO;
366 }
367 }
![[bottom]](../icons/n_bottom.png){kind=icon}
*/