2 * Copyright (C) 2002- 2004 Jeff Dike (jdike@addtoit.com)
3 * Licensed under the GPL
17 #include <asm/unistd.h>
18 #include <asm/types.h>
20 #include "ptrace_user.h"
21 #include "time_user.h"
22 #include "sysdep/ptrace.h"
23 #include "user_util.h"
24 #include "kern_util.h"
26 #include "stub-data.h"
28 #include "sysdep/sigcontext.h"
29 #include "sysdep/stub.h"
32 #include "skas_ptrace.h"
33 #include "chan_user.h"
34 #include "signal_user.h"
35 #include "registers.h"
37 #include "uml-config.h"
40 int is_skas_winch(int pid
, int fd
, void *data
)
42 if(pid
!= os_getpgrp())
45 register_winch_irq(-1, fd
, -1, data
);
49 void wait_stub_done(int pid
, int sig
, char * fname
)
55 err
= ptrace(PTRACE_CONT
, pid
, 0, sig
);
57 panic("%s : continue failed, errno = %d\n",
62 CATCH_EINTR(n
= waitpid(pid
, &status
, WUNTRACED
));
63 } while((n
>= 0) && WIFSTOPPED(status
) &&
64 (WSTOPSIG(status
) == SIGVTALRM
));
66 if((n
< 0) || !WIFSTOPPED(status
) ||
67 (WSTOPSIG(status
) != SIGUSR1
&& WSTOPSIG(status
) != SIGTRAP
)){
68 panic("%s : failed to wait for SIGUSR1/SIGTRAP, "
69 "pid = %d, n = %d, errno = %d, status = 0x%x\n",
70 fname
, pid
, n
, errno
, status
);
74 void get_skas_faultinfo(int pid
, struct faultinfo
* fi
)
79 err
= ptrace(PTRACE_FAULTINFO
, pid
, 0, fi
);
81 panic("get_skas_faultinfo - PTRACE_FAULTINFO failed, "
82 "errno = %d\n", errno
);
84 /* Special handling for i386, which has different structs */
85 if (sizeof(struct ptrace_faultinfo
) < sizeof(struct faultinfo
))
86 memset((char *)fi
+ sizeof(struct ptrace_faultinfo
), 0,
87 sizeof(struct faultinfo
) -
88 sizeof(struct ptrace_faultinfo
));
91 wait_stub_done(pid
, SIGSEGV
, "get_skas_faultinfo");
93 /* faultinfo is prepared by the stub-segv-handler at start of
94 * the stub stack page. We just have to copy it.
96 memcpy(fi
, (void *)current_stub_stack(), sizeof(*fi
));
100 static void handle_segv(int pid
, union uml_pt_regs
* regs
)
102 get_skas_faultinfo(pid
, ®s
->skas
.faultinfo
);
103 segv(regs
->skas
.faultinfo
, 0, 1, NULL
);
106 /*To use the same value of using_sysemu as the caller, ask it that value (in local_using_sysemu)*/
107 static void handle_trap(int pid
, union uml_pt_regs
*regs
, int local_using_sysemu
)
111 /* Mark this as a syscall */
112 UPT_SYSCALL_NR(regs
) = PT_SYSCALL_NR(regs
->skas
.regs
);
114 if (!local_using_sysemu
)
116 err
= ptrace(PTRACE_POKEUSR
, pid
, PT_SYSCALL_NR_OFFSET
, __NR_getpid
);
118 panic("handle_trap - nullifying syscall failed errno = %d\n",
121 err
= ptrace(PTRACE_SYSCALL
, pid
, 0, 0);
123 panic("handle_trap - continuing to end of syscall failed, "
124 "errno = %d\n", errno
);
126 CATCH_EINTR(err
= waitpid(pid
, &status
, WUNTRACED
));
127 if((err
< 0) || !WIFSTOPPED(status
) ||
128 (WSTOPSIG(status
) != SIGTRAP
+ 0x80))
129 panic("handle_trap - failed to wait at end of syscall, "
130 "errno = %d, status = %d\n", errno
, status
);
133 handle_syscall(regs
);
136 extern int __syscall_stub_start
;
138 static int userspace_tramp(void *stack
)
142 ptrace(PTRACE_TRACEME
, 0, 0, 0);
144 init_new_thread_signals(1);
148 /* This has a pte, but it can't be mapped in with the usual
149 * tlb_flush mechanism because this is part of that mechanism
154 fd
= phys_mapping(to_phys(&__syscall_stub_start
), &offset
);
155 addr
= mmap64((void *) UML_CONFIG_STUB_CODE
, page_size(),
156 PROT_EXEC
, MAP_FIXED
| MAP_PRIVATE
, fd
, offset
);
157 if(addr
== MAP_FAILED
){
158 printk("mapping mmap stub failed, errno = %d\n",
164 fd
= phys_mapping(to_phys(stack
), &offset
);
165 addr
= mmap((void *) UML_CONFIG_STUB_DATA
, page_size(),
166 PROT_READ
| PROT_WRITE
,
167 MAP_FIXED
| MAP_SHARED
, fd
, offset
);
168 if(addr
== MAP_FAILED
){
169 printk("mapping segfault stack failed, "
170 "errno = %d\n", errno
);
175 if(!ptrace_faultinfo
&& (stack
!= NULL
)){
176 unsigned long v
= UML_CONFIG_STUB_CODE
+
177 (unsigned long) stub_segv_handler
-
178 (unsigned long) &__syscall_stub_start
;
180 set_sigstack((void *) UML_CONFIG_STUB_DATA
, page_size());
181 set_handler(SIGSEGV
, (void *) v
, SA_ONSTACK
,
182 SIGIO
, SIGWINCH
, SIGALRM
, SIGVTALRM
,
186 os_stop_process(os_getpid());
190 /* Each element set once, and only accessed by a single processor anyway */
193 int userspace_pid
[NR_CPUS
];
195 int start_userspace(unsigned long stub_stack
)
199 int pid
, status
, n
, flags
;
201 stack
= mmap(NULL
, PAGE_SIZE
, PROT_READ
| PROT_WRITE
| PROT_EXEC
,
202 MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0);
203 if(stack
== MAP_FAILED
)
204 panic("start_userspace : mmap failed, errno = %d", errno
);
205 sp
= (unsigned long) stack
+ PAGE_SIZE
- sizeof(void *);
207 flags
= CLONE_FILES
| SIGCHLD
;
208 if(proc_mm
) flags
|= CLONE_VM
;
209 pid
= clone(userspace_tramp
, (void *) sp
, flags
, (void *) stub_stack
);
211 panic("start_userspace : clone failed, errno = %d", errno
);
214 CATCH_EINTR(n
= waitpid(pid
, &status
, WUNTRACED
));
216 panic("start_userspace : wait failed, errno = %d",
218 } while(WIFSTOPPED(status
) && (WSTOPSIG(status
) == SIGVTALRM
));
220 if(!WIFSTOPPED(status
) || (WSTOPSIG(status
) != SIGSTOP
))
221 panic("start_userspace : expected SIGSTOP, got status = %d",
224 if (ptrace(PTRACE_OLDSETOPTIONS
, pid
, NULL
, (void *)PTRACE_O_TRACESYSGOOD
) < 0)
225 panic("start_userspace : PTRACE_SETOPTIONS failed, errno=%d\n",
228 if(munmap(stack
, PAGE_SIZE
) < 0)
229 panic("start_userspace : munmap failed, errno = %d\n", errno
);
234 void userspace(union uml_pt_regs
*regs
)
236 int err
, status
, op
, pid
= userspace_pid
[0];
237 int local_using_sysemu
; /*To prevent races if using_sysemu changes under us.*/
240 restore_registers(pid
, regs
);
242 /* Now we set local_using_sysemu to be used for one loop */
243 local_using_sysemu
= get_using_sysemu();
245 op
= SELECT_PTRACE_OPERATION(local_using_sysemu
, singlestepping(NULL
));
247 err
= ptrace(op
, pid
, 0, 0);
249 panic("userspace - could not resume userspace process, "
250 "pid=%d, ptrace operation = %d, errno = %d\n",
253 CATCH_EINTR(err
= waitpid(pid
, &status
, WUNTRACED
));
255 panic("userspace - waitpid failed, errno = %d\n",
258 regs
->skas
.is_user
= 1;
259 save_registers(pid
, regs
);
260 UPT_SYSCALL_NR(regs
) = -1; /* Assume: It's not a syscall */
262 if(WIFSTOPPED(status
)){
263 switch(WSTOPSIG(status
)){
265 if(PTRACE_FULL_FAULTINFO
|| !ptrace_faultinfo
)
266 user_signal(SIGSEGV
, regs
, pid
);
267 else handle_segv(pid
, regs
);
270 handle_trap(pid
, regs
, local_using_sysemu
);
273 relay_signal(SIGTRAP
, regs
);
281 user_signal(WSTOPSIG(status
), regs
, pid
);
284 printk("userspace - child stopped with signal "
285 "%d\n", WSTOPSIG(status
));
287 pid
= userspace_pid
[0];
290 /* Avoid -ERESTARTSYS handling in host */
291 PT_SYSCALL_NR(regs
->skas
.regs
) = -1;
295 #define INIT_JMP_NEW_THREAD 0
296 #define INIT_JMP_REMOVE_SIGSTACK 1
297 #define INIT_JMP_CALLBACK 2
298 #define INIT_JMP_HALT 3
299 #define INIT_JMP_REBOOT 4
302 int copy_context_skas0(unsigned long new_stack
, int pid
)
305 unsigned long regs
[MAX_REG_NR
];
306 unsigned long current_stack
= current_stub_stack();
307 struct stub_data
*data
= (struct stub_data
*) current_stack
;
308 struct stub_data
*child_data
= (struct stub_data
*) new_stack
;
310 int new_fd
= phys_mapping(to_phys((void *)new_stack
), &new_offset
);
312 /* prepare offset and fd of child's stack as argument for parent's
313 * and child's mmap2 calls
315 *data
= ((struct stub_data
) { .offset
= MMAP_OFFSET(new_offset
),
317 .timer
= ((struct itimerval
)
318 { { 0, 1000000 / hz() },
319 { 0, 1000000 / hz() }})});
320 get_safe_registers(regs
);
322 /* Set parent's instruction pointer to start of clone-stub */
323 regs
[REGS_IP_INDEX
] = UML_CONFIG_STUB_CODE
+
324 (unsigned long) stub_clone_handler
-
325 (unsigned long) &__syscall_stub_start
;
326 regs
[REGS_SP_INDEX
] = UML_CONFIG_STUB_DATA
+ PAGE_SIZE
-
328 err
= ptrace_setregs(pid
, regs
);
330 panic("copy_context_skas0 : PTRACE_SETREGS failed, "
331 "pid = %d, errno = %d\n", pid
, errno
);
333 /* set a well known return code for detection of child write failure */
334 child_data
->err
= 12345678;
336 /* Wait, until parent has finished its work: read child's pid from
337 * parent's stack, and check, if bad result.
339 wait_stub_done(pid
, 0, "copy_context_skas0");
343 panic("copy_context_skas0 - stub-parent reports error %d\n",
346 /* Wait, until child has finished too: read child's result from
347 * child's stack and check it.
349 wait_stub_done(pid
, -1, "copy_context_skas0");
350 if (child_data
->err
!= UML_CONFIG_STUB_DATA
)
351 panic("copy_context_skas0 - stub-child reports error %d\n",
354 if (ptrace(PTRACE_OLDSETOPTIONS
, pid
, NULL
,
355 (void *)PTRACE_O_TRACESYSGOOD
) < 0)
356 panic("copy_context_skas0 : PTRACE_SETOPTIONS failed, "
357 "errno = %d\n", errno
);
362 void new_thread(void *stack
, void **switch_buf_ptr
, void **fork_buf_ptr
,
363 void (*handler
)(int))
366 sigjmp_buf switch_buf
, fork_buf
;
368 *switch_buf_ptr
= &switch_buf
;
369 *fork_buf_ptr
= &fork_buf
;
371 /* Somewhat subtle - siglongjmp restores the signal mask before doing
372 * the longjmp. This means that when jumping from one stack to another
373 * when the target stack has interrupts enabled, an interrupt may occur
374 * on the source stack. This is bad when starting up a process because
375 * it's not supposed to get timer ticks until it has been scheduled.
376 * So, we disable interrupts around the sigsetjmp to ensure that
377 * they can't happen until we get back here where they are safe.
379 flags
= get_signals();
381 if(sigsetjmp(fork_buf
, 1) == 0)
382 new_thread_proc(stack
, handler
);
389 void thread_wait(void *sw
, void *fb
)
391 sigjmp_buf buf
, **switch_buf
= sw
, *fork_buf
;
395 if(sigsetjmp(buf
, 1) == 0)
396 siglongjmp(*fork_buf
, INIT_JMP_REMOVE_SIGSTACK
);
399 void switch_threads(void *me
, void *next
)
401 sigjmp_buf my_buf
, **me_ptr
= me
, *next_buf
= next
;
404 if(sigsetjmp(my_buf
, 1) == 0)
405 siglongjmp(*next_buf
, 1);
408 static sigjmp_buf initial_jmpbuf
;
410 /* XXX Make these percpu */
411 static void (*cb_proc
)(void *arg
);
413 static sigjmp_buf
*cb_back
;
415 int start_idle_thread(void *stack
, void *switch_buf_ptr
, void **fork_buf_ptr
)
417 sigjmp_buf
**switch_buf
= switch_buf_ptr
;
420 set_handler(SIGWINCH
, (__sighandler_t
) sig_handler
,
421 SA_ONSTACK
| SA_RESTART
, SIGUSR1
, SIGIO
, SIGALRM
,
424 *fork_buf_ptr
= &initial_jmpbuf
;
425 n
= sigsetjmp(initial_jmpbuf
, 1);
427 case INIT_JMP_NEW_THREAD
:
428 new_thread_proc((void *) stack
, new_thread_handler
);
430 case INIT_JMP_REMOVE_SIGSTACK
:
433 case INIT_JMP_CALLBACK
:
435 siglongjmp(*cb_back
, 1);
440 case INIT_JMP_REBOOT
:
444 panic("Bad sigsetjmp return in start_idle_thread - %d\n", n
);
446 siglongjmp(**switch_buf
, 1);
449 void remove_sigstack(void)
451 stack_t stack
= ((stack_t
) { .ss_flags
= SS_DISABLE
,
455 if(sigaltstack(&stack
, NULL
) != 0)
456 panic("disabling signal stack failed, errno = %d\n", errno
);
459 void initial_thread_cb_skas(void (*proc
)(void *), void *arg
)
468 if(sigsetjmp(here
, 1) == 0)
469 siglongjmp(initial_jmpbuf
, INIT_JMP_CALLBACK
);
480 siglongjmp(initial_jmpbuf
, INIT_JMP_HALT
);
483 void reboot_skas(void)
486 siglongjmp(initial_jmpbuf
, INIT_JMP_REBOOT
);
489 void switch_mm_skas(struct mm_id
*mm_idp
)
493 #warning need cpu pid in switch_mm_skas
495 err
= ptrace(PTRACE_SWITCH_MM
, userspace_pid
[0], 0,
498 panic("switch_mm_skas - PTRACE_SWITCH_MM failed, "
499 "errno = %d\n", errno
);
501 else userspace_pid
[0] = mm_idp
->u
.pid
;
505 * Overrides for Emacs so that we follow Linus's tabbing style.
506 * Emacs will notice this stuff at the end of the file and automatically
507 * adjust the settings for this buffer only. This must remain at the end
509 * ---------------------------------------------------------------------------
511 * c-file-style: "linux"