2 * Copyright (C) 2002- 2004 Jeff Dike (jdike@addtoit.com)
3 * Licensed under the GPL
12 #include "ptrace_user.h"
17 #include <asm/unistd.h>
18 #include <asm/types.h>
20 #include "sysdep/ptrace.h"
21 #include "user_util.h"
22 #include "kern_util.h"
24 #include "stub-data.h"
26 #include "sysdep/sigcontext.h"
27 #include "sysdep/stub.h"
30 #include "skas_ptrace.h"
31 #include "chan_user.h"
32 #include "registers.h"
34 #include "uml-config.h"
38 int is_skas_winch(int pid
, int fd
, void *data
)
40 if(pid
!= os_getpgrp())
43 register_winch_irq(-1, fd
, -1, data
);
47 void wait_stub_done(int pid
, int sig
, char * fname
)
53 err
= ptrace(PTRACE_CONT
, pid
, 0, sig
);
55 panic("%s : continue failed, errno = %d\n",
60 CATCH_EINTR(n
= waitpid(pid
, &status
, WUNTRACED
));
61 } while((n
>= 0) && WIFSTOPPED(status
) &&
62 ((WSTOPSIG(status
) == SIGVTALRM
) ||
63 /* running UML inside a detached screen can cause
66 (WSTOPSIG(status
) == SIGWINCH
)));
68 if((n
< 0) || !WIFSTOPPED(status
) ||
69 (WSTOPSIG(status
) != SIGUSR1
&& WSTOPSIG(status
) != SIGTRAP
)){
70 unsigned long regs
[HOST_FRAME_SIZE
];
72 if(ptrace(PTRACE_GETREGS
, pid
, 0, regs
) < 0)
73 printk("Failed to get registers from stub, "
74 "errno = %d\n", errno
);
78 printk("Stub registers -\n");
79 for(i
= 0; i
< HOST_FRAME_SIZE
; i
++)
80 printk("\t%d - %lx\n", i
, regs
[i
]);
82 panic("%s : failed to wait for SIGUSR1/SIGTRAP, "
83 "pid = %d, n = %d, errno = %d, status = 0x%x\n",
84 fname
, pid
, n
, errno
, status
);
88 extern unsigned long current_stub_stack(void);
90 void get_skas_faultinfo(int pid
, struct faultinfo
* fi
)
95 err
= ptrace(PTRACE_FAULTINFO
, pid
, 0, fi
);
97 panic("get_skas_faultinfo - PTRACE_FAULTINFO failed, "
98 "errno = %d\n", errno
);
100 /* Special handling for i386, which has different structs */
101 if (sizeof(struct ptrace_faultinfo
) < sizeof(struct faultinfo
))
102 memset((char *)fi
+ sizeof(struct ptrace_faultinfo
), 0,
103 sizeof(struct faultinfo
) -
104 sizeof(struct ptrace_faultinfo
));
107 wait_stub_done(pid
, SIGSEGV
, "get_skas_faultinfo");
109 /* faultinfo is prepared by the stub-segv-handler at start of
110 * the stub stack page. We just have to copy it.
112 memcpy(fi
, (void *)current_stub_stack(), sizeof(*fi
));
116 static void handle_segv(int pid
, union uml_pt_regs
* regs
)
118 get_skas_faultinfo(pid
, ®s
->skas
.faultinfo
);
119 segv(regs
->skas
.faultinfo
, 0, 1, NULL
);
122 /*To use the same value of using_sysemu as the caller, ask it that value (in local_using_sysemu)*/
123 static void handle_trap(int pid
, union uml_pt_regs
*regs
, int local_using_sysemu
)
127 /* Mark this as a syscall */
128 UPT_SYSCALL_NR(regs
) = PT_SYSCALL_NR(regs
->skas
.regs
);
130 if (!local_using_sysemu
)
132 err
= ptrace(PTRACE_POKEUSR
, pid
, PT_SYSCALL_NR_OFFSET
,
135 panic("handle_trap - nullifying syscall failed errno = %d\n",
138 err
= ptrace(PTRACE_SYSCALL
, pid
, 0, 0);
140 panic("handle_trap - continuing to end of syscall failed, "
141 "errno = %d\n", errno
);
143 CATCH_EINTR(err
= waitpid(pid
, &status
, WUNTRACED
));
144 if((err
< 0) || !WIFSTOPPED(status
) ||
145 (WSTOPSIG(status
) != SIGTRAP
+ 0x80))
146 panic("handle_trap - failed to wait at end of syscall, "
147 "errno = %d, status = %d\n", errno
, status
);
150 handle_syscall(regs
);
153 extern int __syscall_stub_start
;
155 static int userspace_tramp(void *stack
)
159 ptrace(PTRACE_TRACEME
, 0, 0, 0);
161 init_new_thread_signals();
165 /* This has a pte, but it can't be mapped in with the usual
166 * tlb_flush mechanism because this is part of that mechanism
170 fd
= phys_mapping(to_phys(&__syscall_stub_start
), &offset
);
171 addr
= mmap64((void *) UML_CONFIG_STUB_CODE
, page_size(),
172 PROT_EXEC
, MAP_FIXED
| MAP_PRIVATE
, fd
, offset
);
173 if(addr
== MAP_FAILED
){
174 printk("mapping mmap stub failed, errno = %d\n",
180 fd
= phys_mapping(to_phys(stack
), &offset
);
181 addr
= mmap((void *) UML_CONFIG_STUB_DATA
, page_size(),
182 PROT_READ
| PROT_WRITE
,
183 MAP_FIXED
| MAP_SHARED
, fd
, offset
);
184 if(addr
== MAP_FAILED
){
185 printk("mapping segfault stack failed, "
186 "errno = %d\n", errno
);
191 if(!ptrace_faultinfo
&& (stack
!= NULL
)){
192 unsigned long v
= UML_CONFIG_STUB_CODE
+
193 (unsigned long) stub_segv_handler
-
194 (unsigned long) &__syscall_stub_start
;
196 set_sigstack((void *) UML_CONFIG_STUB_DATA
, page_size());
197 set_handler(SIGSEGV
, (void *) v
, SA_ONSTACK
,
198 SIGIO
, SIGWINCH
, SIGALRM
, SIGVTALRM
,
202 os_stop_process(os_getpid());
206 /* Each element set once, and only accessed by a single processor anyway */
209 int userspace_pid
[NR_CPUS
];
211 int start_userspace(unsigned long stub_stack
)
215 int pid
, status
, n
, flags
;
217 stack
= mmap(NULL
, PAGE_SIZE
, PROT_READ
| PROT_WRITE
| PROT_EXEC
,
218 MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0);
219 if(stack
== MAP_FAILED
)
220 panic("start_userspace : mmap failed, errno = %d", errno
);
221 sp
= (unsigned long) stack
+ PAGE_SIZE
- sizeof(void *);
223 flags
= CLONE_FILES
| SIGCHLD
;
224 if(proc_mm
) flags
|= CLONE_VM
;
225 pid
= clone(userspace_tramp
, (void *) sp
, flags
, (void *) stub_stack
);
227 panic("start_userspace : clone failed, errno = %d", errno
);
230 CATCH_EINTR(n
= waitpid(pid
, &status
, WUNTRACED
));
232 panic("start_userspace : wait failed, errno = %d",
234 } while(WIFSTOPPED(status
) && (WSTOPSIG(status
) == SIGVTALRM
));
236 if(!WIFSTOPPED(status
) || (WSTOPSIG(status
) != SIGSTOP
))
237 panic("start_userspace : expected SIGSTOP, got status = %d",
240 if (ptrace(PTRACE_OLDSETOPTIONS
, pid
, NULL
, (void *)PTRACE_O_TRACESYSGOOD
) < 0)
241 panic("start_userspace : PTRACE_OLDSETOPTIONS failed, errno=%d\n",
244 if(munmap(stack
, PAGE_SIZE
) < 0)
245 panic("start_userspace : munmap failed, errno = %d\n", errno
);
250 void userspace(union uml_pt_regs
*regs
)
252 int err
, status
, op
, pid
= userspace_pid
[0];
253 int local_using_sysemu
; /*To prevent races if using_sysemu changes under us.*/
256 restore_registers(pid
, regs
);
258 /* Now we set local_using_sysemu to be used for one loop */
259 local_using_sysemu
= get_using_sysemu();
261 op
= SELECT_PTRACE_OPERATION(local_using_sysemu
, singlestepping(NULL
));
263 err
= ptrace(op
, pid
, 0, 0);
265 panic("userspace - could not resume userspace process, "
266 "pid=%d, ptrace operation = %d, errno = %d\n",
269 CATCH_EINTR(err
= waitpid(pid
, &status
, WUNTRACED
));
271 panic("userspace - waitpid failed, errno = %d\n",
274 regs
->skas
.is_user
= 1;
275 save_registers(pid
, regs
);
276 UPT_SYSCALL_NR(regs
) = -1; /* Assume: It's not a syscall */
278 if(WIFSTOPPED(status
)){
279 switch(WSTOPSIG(status
)){
281 if(PTRACE_FULL_FAULTINFO
|| !ptrace_faultinfo
)
282 user_signal(SIGSEGV
, regs
, pid
);
283 else handle_segv(pid
, regs
);
286 handle_trap(pid
, regs
, local_using_sysemu
);
289 relay_signal(SIGTRAP
, regs
);
297 user_signal(WSTOPSIG(status
), regs
, pid
);
300 printk("userspace - child stopped with signal "
301 "%d\n", WSTOPSIG(status
));
303 pid
= userspace_pid
[0];
306 /* Avoid -ERESTARTSYS handling in host */
307 if(PT_SYSCALL_NR_OFFSET
!= PT_SYSCALL_RET_OFFSET
)
308 PT_SYSCALL_NR(regs
->skas
.regs
) = -1;
313 int copy_context_skas0(unsigned long new_stack
, int pid
)
316 unsigned long regs
[HOST_FRAME_SIZE
];
317 unsigned long fp_regs
[HOST_FP_SIZE
];
318 unsigned long current_stack
= current_stub_stack();
319 struct stub_data
*data
= (struct stub_data
*) current_stack
;
320 struct stub_data
*child_data
= (struct stub_data
*) new_stack
;
322 int new_fd
= phys_mapping(to_phys((void *)new_stack
), &new_offset
);
324 /* prepare offset and fd of child's stack as argument for parent's
325 * and child's mmap2 calls
327 *data
= ((struct stub_data
) { .offset
= MMAP_OFFSET(new_offset
),
329 .timer
= ((struct itimerval
)
330 { { 0, 1000000 / hz() },
331 { 0, 1000000 / hz() }})});
332 get_safe_registers(regs
, fp_regs
);
334 /* Set parent's instruction pointer to start of clone-stub */
335 regs
[REGS_IP_INDEX
] = UML_CONFIG_STUB_CODE
+
336 (unsigned long) stub_clone_handler
-
337 (unsigned long) &__syscall_stub_start
;
338 regs
[REGS_SP_INDEX
] = UML_CONFIG_STUB_DATA
+ PAGE_SIZE
-
340 #ifdef __SIGNAL_FRAMESIZE
341 regs
[REGS_SP_INDEX
] -= __SIGNAL_FRAMESIZE
;
343 err
= ptrace_setregs(pid
, regs
);
345 panic("copy_context_skas0 : PTRACE_SETREGS failed, "
346 "pid = %d, errno = %d\n", pid
, -err
);
348 err
= ptrace_setfpregs(pid
, fp_regs
);
350 panic("copy_context_skas0 : PTRACE_SETFPREGS failed, "
351 "pid = %d, errno = %d\n", pid
, -err
);
353 /* set a well known return code for detection of child write failure */
354 child_data
->err
= 12345678;
356 /* Wait, until parent has finished its work: read child's pid from
357 * parent's stack, and check, if bad result.
359 wait_stub_done(pid
, 0, "copy_context_skas0");
363 panic("copy_context_skas0 - stub-parent reports error %d\n",
366 /* Wait, until child has finished too: read child's result from
367 * child's stack and check it.
369 wait_stub_done(pid
, -1, "copy_context_skas0");
370 if (child_data
->err
!= UML_CONFIG_STUB_DATA
)
371 panic("copy_context_skas0 - stub-child reports error %ld\n",
374 if (ptrace(PTRACE_OLDSETOPTIONS
, pid
, NULL
,
375 (void *)PTRACE_O_TRACESYSGOOD
) < 0)
376 panic("copy_context_skas0 : PTRACE_OLDSETOPTIONS failed, "
377 "errno = %d\n", errno
);
383 * This is used only, if stub pages are needed, while proc_mm is
384 * availabl. Opening /proc/mm creates a new mm_context, which lacks
385 * the stub-pages. Thus, we map them using /proc/mm-fd
387 void map_stub_pages(int fd
, unsigned long code
,
388 unsigned long data
, unsigned long stack
)
390 struct proc_mm_op mmop
;
393 int code_fd
= phys_mapping(to_phys((void *) &__syscall_stub_start
),
396 mmop
= ((struct proc_mm_op
) { .op
= MM_MMAP
,
402 .flags
= MAP_FIXED
| MAP_PRIVATE
,
404 .offset
= code_offset
406 n
= os_write_file(fd
, &mmop
, sizeof(mmop
));
407 if(n
!= sizeof(mmop
))
408 panic("map_stub_pages : /proc/mm map for code failed, "
413 int map_fd
= phys_mapping(to_phys((void *)stack
), &map_offset
);
414 mmop
= ((struct proc_mm_op
)
420 .prot
= PROT_READ
| PROT_WRITE
,
421 .flags
= MAP_FIXED
| MAP_SHARED
,
425 n
= os_write_file(fd
, &mmop
, sizeof(mmop
));
426 if(n
!= sizeof(mmop
))
427 panic("map_stub_pages : /proc/mm map for data failed, "
432 void new_thread(void *stack
, void **switch_buf_ptr
, void **fork_buf_ptr
,
433 void (*handler
)(int))
436 jmp_buf switch_buf
, fork_buf
;
438 *switch_buf_ptr
= &switch_buf
;
439 *fork_buf_ptr
= &fork_buf
;
441 /* Somewhat subtle - siglongjmp restores the signal mask before doing
442 * the longjmp. This means that when jumping from one stack to another
443 * when the target stack has interrupts enabled, an interrupt may occur
444 * on the source stack. This is bad when starting up a process because
445 * it's not supposed to get timer ticks until it has been scheduled.
446 * So, we disable interrupts around the sigsetjmp to ensure that
447 * they can't happen until we get back here where they are safe.
449 flags
= get_signals();
451 if(UML_SETJMP(&fork_buf
) == 0)
452 new_thread_proc(stack
, handler
);
459 #define INIT_JMP_NEW_THREAD 0
460 #define INIT_JMP_REMOVE_SIGSTACK 1
461 #define INIT_JMP_CALLBACK 2
462 #define INIT_JMP_HALT 3
463 #define INIT_JMP_REBOOT 4
465 void thread_wait(void *sw
, void *fb
)
467 jmp_buf buf
, **switch_buf
= sw
, *fork_buf
;
471 if(UML_SETJMP(&buf
) == 0)
472 UML_LONGJMP(fork_buf
, INIT_JMP_REMOVE_SIGSTACK
);
475 void switch_threads(void *me
, void *next
)
477 jmp_buf my_buf
, **me_ptr
= me
, *next_buf
= next
;
480 if(UML_SETJMP(&my_buf
) == 0)
481 UML_LONGJMP(next_buf
, 1);
484 static jmp_buf initial_jmpbuf
;
486 /* XXX Make these percpu */
487 static void (*cb_proc
)(void *arg
);
489 static jmp_buf *cb_back
;
491 int start_idle_thread(void *stack
, void *switch_buf_ptr
, void **fork_buf_ptr
)
493 jmp_buf **switch_buf
= switch_buf_ptr
;
496 set_handler(SIGWINCH
, (__sighandler_t
) sig_handler
,
497 SA_ONSTACK
| SA_RESTART
, SIGUSR1
, SIGIO
, SIGALRM
,
500 *fork_buf_ptr
= &initial_jmpbuf
;
501 n
= UML_SETJMP(&initial_jmpbuf
);
503 case INIT_JMP_NEW_THREAD
:
504 new_thread_proc((void *) stack
, new_thread_handler
);
506 case INIT_JMP_REMOVE_SIGSTACK
:
509 case INIT_JMP_CALLBACK
:
511 UML_LONGJMP(cb_back
, 1);
516 case INIT_JMP_REBOOT
:
520 panic("Bad sigsetjmp return in start_idle_thread - %d\n", n
);
522 UML_LONGJMP(*switch_buf
, 1);
525 void initial_thread_cb_skas(void (*proc
)(void *), void *arg
)
534 if(UML_SETJMP(&here
) == 0)
535 UML_LONGJMP(&initial_jmpbuf
, INIT_JMP_CALLBACK
);
546 UML_LONGJMP(&initial_jmpbuf
, INIT_JMP_HALT
);
549 void reboot_skas(void)
552 UML_LONGJMP(&initial_jmpbuf
, INIT_JMP_REBOOT
);
555 void switch_mm_skas(struct mm_id
*mm_idp
)
559 #warning need cpu pid in switch_mm_skas
561 err
= ptrace(PTRACE_SWITCH_MM
, userspace_pid
[0], 0,
564 panic("switch_mm_skas - PTRACE_SWITCH_MM failed, "
565 "errno = %d\n", errno
);
567 else userspace_pid
[0] = mm_idp
->u
.pid
;