This source file includes following definitions.
- get_task
- get_stack_long
- put_stack_long
- get_long
- put_long
- find_extend_vma
- read_long
- write_long
- sys_ptrace
- syscall_trace
1
2
3
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 #include <linux/user.h>
12
13 #include <asm/segment.h>
14 #include <asm/system.h>
15 #include <linux/debugreg.h>
16
17
18
19
20
21
22
23
24 #define FLAG_MASK 0x00044dd5
25
26
27 #define TRAP_FLAG 0x100
28
29
30
31
32
33 #define MAGICNUMBER 68
34
35
36 static inline struct task_struct * get_task(int pid)
37 {
38 int i;
39
40 for (i = 1; i < NR_TASKS; i++) {
41 if (task[i] != NULL && (task[i]->pid == pid))
42 return task[i];
43 }
44 return NULL;
45 }
46
47
48
49
50
51
52
53 static inline int get_stack_long(struct task_struct *task, int offset)
54 {
55 unsigned char *stack;
56
57 stack = (unsigned char *)task->tss.esp0;
58 stack += offset;
59 return (*((int *)stack));
60 }
61
62
63
64
65
66
67
68 static inline int put_stack_long(struct task_struct *task, int offset,
69 unsigned long data)
70 {
71 unsigned char * stack;
72
73 stack = (unsigned char *) task->tss.esp0;
74 stack += offset;
75 *(unsigned long *) stack = data;
76 return 0;
77 }
78
79
80
81
82
83
84
85 static unsigned long get_long(struct vm_area_struct * vma, unsigned long addr)
86 {
87 pgd_t * pgdir;
88 pte_t * pgtable;
89 unsigned long page;
90
91 repeat:
92 pgdir = PAGE_DIR_OFFSET(vma->vm_task, addr);
93 if (pgd_none(*pgdir)) {
94 do_no_page(vma, addr, 0);
95 goto repeat;
96 }
97 if (pgd_bad(*pgdir)) {
98 printk("ptrace: bad page directory %08lx\n", pgd_val(*pgdir));
99 pgd_clear(pgdir);
100 return 0;
101 }
102 pgtable = (pte_t *) (PAGE_PTR(addr) + pgd_page(*pgdir));
103 if (!pte_present(*pgtable)) {
104 do_no_page(vma, addr, 0);
105 goto repeat;
106 }
107 page = pte_page(*pgtable);
108
109 if (page >= high_memory)
110 return 0;
111 page += addr & ~PAGE_MASK;
112 return *(unsigned long *) page;
113 }
114
115
116
117
118
119
120
121
122
123
124 static void put_long(struct vm_area_struct * vma, unsigned long addr,
125 unsigned long data)
126 {
127 pgd_t *pgdir;
128 pte_t *pgtable;
129 unsigned long page;
130
131 repeat:
132 pgdir = PAGE_DIR_OFFSET(vma->vm_task, addr);
133 if (!pgd_present(*pgdir)) {
134 do_no_page(vma, addr, 1);
135 goto repeat;
136 }
137 if (pgd_bad(*pgdir)) {
138 printk("ptrace: bad page directory %08lx\n", pgd_val(*pgdir));
139 pgd_clear(pgdir);
140 return;
141 }
142 pgtable = (pte_t *) (PAGE_PTR(addr) + pgd_page(*pgdir));
143 if (!pte_present(*pgtable)) {
144 do_no_page(vma, addr, 1);
145 goto repeat;
146 }
147 page = pte_page(*pgtable);
148 if (!pte_write(*pgtable)) {
149 do_wp_page(vma, addr, 1);
150 goto repeat;
151 }
152
153 if (page < high_memory) {
154 page += addr & ~PAGE_MASK;
155 *(unsigned long *) page = data;
156 }
157
158
159 *pgtable = pte_mkdirty(mk_pte(page, vma->vm_page_prot));
160 invalidate();
161 }
162
163 static struct vm_area_struct * find_extend_vma(struct task_struct * tsk, unsigned long addr)
164 {
165 struct vm_area_struct * vma;
166
167 addr &= PAGE_MASK;
168 vma = find_vma(tsk,addr);
169 if (!vma)
170 return NULL;
171 if (vma->vm_start <= addr)
172 return vma;
173 if (!(vma->vm_flags & VM_GROWSDOWN))
174 return NULL;
175 if (vma->vm_end - addr > tsk->rlim[RLIMIT_STACK].rlim_cur)
176 return NULL;
177 vma->vm_offset -= vma->vm_start - addr;
178 vma->vm_start = addr;
179 return vma;
180 }
181
182
183
184
185
186 static int read_long(struct task_struct * tsk, unsigned long addr,
187 unsigned long * result)
188 {
189 struct vm_area_struct * vma = find_extend_vma(tsk, addr);
190
191 if (!vma)
192 return -EIO;
193 if ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
194 unsigned long low,high;
195 struct vm_area_struct * vma_high = vma;
196
197 if (addr + sizeof(long) >= vma->vm_end) {
198 vma_high = vma->vm_next;
199 if (!vma_high || vma_high->vm_start != vma->vm_end)
200 return -EIO;
201 }
202 low = get_long(vma, addr & ~(sizeof(long)-1));
203 high = get_long(vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1));
204 switch (addr & (sizeof(long)-1)) {
205 case 1:
206 low >>= 8;
207 low |= high << 24;
208 break;
209 case 2:
210 low >>= 16;
211 low |= high << 16;
212 break;
213 case 3:
214 low >>= 24;
215 low |= high << 8;
216 break;
217 }
218 *result = low;
219 } else
220 *result = get_long(vma, addr);
221 return 0;
222 }
223
224
225
226
227
228 static int write_long(struct task_struct * tsk, unsigned long addr,
229 unsigned long data)
230 {
231 struct vm_area_struct * vma = find_extend_vma(tsk, addr);
232
233 if (!vma)
234 return -EIO;
235 if ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
236 unsigned long low,high;
237 struct vm_area_struct * vma_high = vma;
238
239 if (addr + sizeof(long) >= vma->vm_end) {
240 vma_high = vma->vm_next;
241 if (!vma_high || vma_high->vm_start != vma->vm_end)
242 return -EIO;
243 }
244 low = get_long(vma, addr & ~(sizeof(long)-1));
245 high = get_long(vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1));
246 switch (addr & (sizeof(long)-1)) {
247 case 0:
248 low = data;
249 break;
250 case 1:
251 low &= 0x000000ff;
252 low |= data << 8;
253 high &= ~0xff;
254 high |= data >> 24;
255 break;
256 case 2:
257 low &= 0x0000ffff;
258 low |= data << 16;
259 high &= ~0xffff;
260 high |= data >> 16;
261 break;
262 case 3:
263 low &= 0x00ffffff;
264 low |= data << 24;
265 high &= ~0xffffff;
266 high |= data >> 8;
267 break;
268 }
269 put_long(vma, addr & ~(sizeof(long)-1),low);
270 put_long(vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1),high);
271 } else
272 put_long(vma, addr, data);
273 return 0;
274 }
275
276 asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
277 {
278 struct task_struct *child;
279 struct user * dummy;
280 int i;
281
282 dummy = NULL;
283
284 if (request == PTRACE_TRACEME) {
285
286 if (current->flags & PF_PTRACED)
287 return -EPERM;
288
289 current->flags |= PF_PTRACED;
290 return 0;
291 }
292 if (pid == 1)
293 return -EPERM;
294 if (!(child = get_task(pid)))
295 return -ESRCH;
296 if (request == PTRACE_ATTACH) {
297 if (child == current)
298 return -EPERM;
299 if ((!child->dumpable ||
300 (current->uid != child->euid) ||
301 (current->uid != child->uid) ||
302 (current->gid != child->egid) ||
303 (current->gid != child->gid)) && !suser())
304 return -EPERM;
305
306 if (child->flags & PF_PTRACED)
307 return -EPERM;
308 child->flags |= PF_PTRACED;
309 if (child->p_pptr != current) {
310 REMOVE_LINKS(child);
311 child->p_pptr = current;
312 SET_LINKS(child);
313 }
314 send_sig(SIGSTOP, child, 1);
315 return 0;
316 }
317 if (!(child->flags & PF_PTRACED))
318 return -ESRCH;
319 if (child->state != TASK_STOPPED) {
320 if (request != PTRACE_KILL)
321 return -ESRCH;
322 }
323 if (child->p_pptr != current)
324 return -ESRCH;
325
326 switch (request) {
327
328 case PTRACE_PEEKTEXT:
329 case PTRACE_PEEKDATA: {
330 unsigned long tmp;
331 int res;
332
333 res = read_long(child, addr, &tmp);
334 if (res < 0)
335 return res;
336 res = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
337 if (!res)
338 put_fs_long(tmp,(unsigned long *) data);
339 return res;
340 }
341
342
343 case PTRACE_PEEKUSR: {
344 unsigned long tmp;
345 int res;
346
347 if ((addr & 3) || addr < 0 ||
348 addr > sizeof(struct user) - 3)
349 return -EIO;
350
351 res = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
352 if (res)
353 return res;
354 tmp = 0;
355 if(addr < 17*sizeof(long)) {
356 addr = addr >> 2;
357
358 tmp = get_stack_long(child, sizeof(long)*addr - MAGICNUMBER);
359 if (addr == DS || addr == ES ||
360 addr == FS || addr == GS ||
361 addr == CS || addr == SS)
362 tmp &= 0xffff;
363 };
364 if(addr >= (long) &dummy->u_debugreg[0] &&
365 addr <= (long) &dummy->u_debugreg[7]){
366 addr -= (long) &dummy->u_debugreg[0];
367 addr = addr >> 2;
368 tmp = child->debugreg[addr];
369 };
370 put_fs_long(tmp,(unsigned long *) data);
371 return 0;
372 }
373
374
375 case PTRACE_POKETEXT:
376 case PTRACE_POKEDATA:
377 return write_long(child,addr,data);
378
379 case PTRACE_POKEUSR:
380 if ((addr & 3) || addr < 0 ||
381 addr > sizeof(struct user) - 3)
382 return -EIO;
383
384 addr = addr >> 2;
385
386 if (addr == ORIG_EAX)
387 return -EIO;
388 if (addr == DS || addr == ES ||
389 addr == FS || addr == GS ||
390 addr == CS || addr == SS) {
391 data &= 0xffff;
392 if (data && (data & 3) != 3)
393 return -EIO;
394 }
395 if (addr == EFL) {
396 data &= FLAG_MASK;
397 data |= get_stack_long(child, EFL*sizeof(long)-MAGICNUMBER) & ~FLAG_MASK;
398 }
399
400
401 if(addr < 17){
402 if (put_stack_long(child, sizeof(long)*addr-MAGICNUMBER, data))
403 return -EIO;
404 return 0;
405 };
406
407
408
409
410
411
412 addr = addr << 2;
413 if(addr >= (long) &dummy->u_debugreg[0] &&
414 addr <= (long) &dummy->u_debugreg[7]){
415
416 if(addr == (long) &dummy->u_debugreg[4]) return -EIO;
417 if(addr == (long) &dummy->u_debugreg[5]) return -EIO;
418 if(addr < (long) &dummy->u_debugreg[4] &&
419 ((unsigned long) data) >= 0xbffffffd) return -EIO;
420
421 if(addr == (long) &dummy->u_debugreg[7]) {
422 data &= ~DR_CONTROL_RESERVED;
423 for(i=0; i<4; i++)
424 if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
425 return -EIO;
426 };
427
428 addr -= (long) &dummy->u_debugreg;
429 addr = addr >> 2;
430 child->debugreg[addr] = data;
431 return 0;
432 };
433 return -EIO;
434
435 case PTRACE_SYSCALL:
436 case PTRACE_CONT: {
437 long tmp;
438
439 if ((unsigned long) data > NSIG)
440 return -EIO;
441 if (request == PTRACE_SYSCALL)
442 child->flags |= PF_TRACESYS;
443 else
444 child->flags &= ~PF_TRACESYS;
445 child->exit_code = data;
446 child->state = TASK_RUNNING;
447
448 tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
449 put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
450 return 0;
451 }
452
453
454
455
456
457
458 case PTRACE_KILL: {
459 long tmp;
460
461 child->state = TASK_RUNNING;
462 child->exit_code = SIGKILL;
463
464 tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
465 put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
466 return 0;
467 }
468
469 case PTRACE_SINGLESTEP: {
470 long tmp;
471
472 if ((unsigned long) data > NSIG)
473 return -EIO;
474 child->flags &= ~PF_TRACESYS;
475 tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) | TRAP_FLAG;
476 put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
477 child->state = TASK_RUNNING;
478 child->exit_code = data;
479
480 return 0;
481 }
482
483 case PTRACE_DETACH: {
484 long tmp;
485
486 if ((unsigned long) data > NSIG)
487 return -EIO;
488 child->flags &= ~(PF_PTRACED|PF_TRACESYS);
489 child->state = TASK_RUNNING;
490 child->exit_code = data;
491 REMOVE_LINKS(child);
492 child->p_pptr = child->p_opptr;
493 SET_LINKS(child);
494
495 tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
496 put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
497 return 0;
498 }
499
500 default:
501 return -EIO;
502 }
503 }
504
505 asmlinkage void syscall_trace(void)
506 {
507 if ((current->flags & (PF_PTRACED|PF_TRACESYS))
508 != (PF_PTRACED|PF_TRACESYS))
509 return;
510 current->exit_code = SIGTRAP;
511 current->state = TASK_STOPPED;
512 notify_parent(current);
513 schedule();
514
515
516
517
518
519 if (current->exit_code)
520 current->signal |= (1 << (current->exit_code - 1));
521 current->exit_code = 0;
522 }