Added a batch of files under arch/um/kernel/skas.

arch/um/kernel/skas/include/skas.h

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_H
+#define __SKAS_H
+
+#include "sysdep/ptrace.h"
+
+extern int userspace_pid;
+
+extern void switch_threads(void *me, void *next);
+extern void thread_wait(void *sw, void *fb);
+extern void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
+                       void (*handler)(int));
+extern int start_idle_thread(void *stack, void *switch_buf_ptr, 
+			     void **fork_buf_ptr);
+extern int user_thread(unsigned long stack, int flags);
+extern void userspace(struct uml_pt_regs *regs);
+extern void new_thread_proc(void *stack, void (*handler)(int sig));
+extern void remove_sigstack(void);
+extern void new_thread_handler(int sig);
+extern void handle_syscall(struct uml_pt_regs *regs);
+extern void map(int fd, unsigned long virt, unsigned long phys, 
+		unsigned long len, int r, int w, int x);
+extern int unmap(int fd, void *addr, int len);
+extern int protect(int fd, unsigned long addr, unsigned long len, 
+		   int r, int w, int x, int must_succeed);
+extern void user_signal(int sig, struct uml_pt_regs *regs);
+extern int singlestepping_skas(void);
+extern int new_mm(int from);
+extern void save_registers(struct uml_pt_regs *regs);
+extern void restore_registers(struct uml_pt_regs *regs);
+extern void start_userspace(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

arch/um/kernel/skas/include/skas_ptrace.h

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_PTRACE_H
+#define __SKAS_PTRACE_H
+
+struct ptrace_faultinfo {
+	int is_write;
+	unsigned long addr;
+};
+
+struct ptrace_ldt {
+	int func;
+  	void *ptr;
+	unsigned long bytecount;
+};
+
+#define PTRACE_FAULTINFO 52
+#define PTRACE_SIGPENDING 53
+#define PTRACE_LDT 54
+#define PTRACE_SWITCH_MM 55
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

arch/um/kernel/skas/process.c

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <sched.h>
+#include <sys/wait.h>
+#include <sys/ptrace.h>
+#include <sys/mman.h>
+#include <sys/user.h>
+#include <asm/unistd.h>
+#include "user.h"
+#include "ptrace_user.h"
+#include "time_user.h"
+#include "sysdep/ptrace.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "skas.h"
+#include "skas_ptrace.h"
+#include "sysdep/sigcontext.h"
+#include "os.h"
+#include "proc_mm.h"
+
+unsigned long exec_regs[FRAME_SIZE];
+unsigned long exec_fp_regs[HOST_FP_SIZE];
+unsigned long exec_fpx_regs[HOST_XFP_SIZE];
+int have_fpx_regs = 1;
+
+static void handle_segv(int pid)
+{
+	struct ptrace_faultinfo fault;
+	int err;
+
+	err = ptrace(PTRACE_FAULTINFO, pid, 0, &fault);
+	if(err)
+		panic("handle_segv - PTRACE_FAULTINFO failed, errno = %d\n",
+		      errno);
+	segv(fault.addr, 0, FAULT_WRITE(fault.is_write), 1, NULL);
+}
+
+static void handle_trap(int pid, struct uml_pt_regs *regs)
+{
+	int err, syscall_nr, status;
+
+	syscall_nr = PT_SYSCALL_NR(regs->mode.skas.regs);
+	if(syscall_nr < 1){
+		relay_signal(SIGTRAP, regs);
+		return;
+	}
+	UPT_SYSCALL_NR(regs) = syscall_nr;
+
+	err = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_NR_OFFSET, __NR_getpid);
+	if(err < 0)
+	        panic("handle_trap - nullifying syscall failed errno = %d\n", 
+		      errno);
+
+	err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
+	if(err < 0)
+	        panic("handle_trap - continuing to end of syscall failed, "
+		      "errno = %d\n", errno);
+
+	err = waitpid(pid, &status, WUNTRACED);
+	if((err < 0) || !WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP))
+		panic("handle_trap - failed to wait at end of syscall, "
+		      "errno = %d, status = %d\n", errno, status);
+
+	handle_syscall(regs);
+}
+
+int userspace_pid;
+
+static int userspace_tramp(void *arg)
+{
+	init_new_thread_signals(0);
+	enable_timer();
+	ptrace(PTRACE_TRACEME, 0, 0, 0);
+	os_stop_process(os_getpid());
+}
+
+void start_userspace(void)
+{
+	void *stack;
+	unsigned long sp;
+	int pid, status, n;
+
+	stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
+		     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	if(stack == MAP_FAILED)
+		panic("start_userspace : mmap failed, errno = %d", errno);
+	sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
+
+	pid = clone(userspace_tramp, (void *) sp, 
+		    CLONE_FILES | CLONE_VM | SIGCHLD, NULL);
+	if(pid < 0)
+		panic("start_userspace : clone failed, errno = %d", errno);
+
+	do {
+		n = waitpid(pid, &status, WUNTRACED);
+		if(n < 0)
+			panic("start_userspace : wait failed, errno = %d", 
+			      errno);
+	} while(WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
+
+	if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
+		panic("start_userspace : expected SIGSTOP, got status = %d",
+		      status);
+
+	if(munmap(stack, PAGE_SIZE) < 0)
+		panic("start_userspace : munmap failed, errno = %d\n", errno);
+
+	userspace_pid = pid;
+}
+
+void userspace(struct uml_pt_regs *regs)
+{
+	int err, status, op;
+
+	restore_registers(regs);
+		
+	err = ptrace(PTRACE_SYSCALL, userspace_pid, 0, 0);
+	if(err)
+		panic("userspace - PTRACE_SYSCALL failed, errno = %d\n", 
+		       errno);
+	while(1){
+		err = waitpid(userspace_pid, &status, WUNTRACED);
+		if(err < 0)
+			panic("userspace - waitpid failed, errno = %d\n", 
+			      errno);
+
+		regs->is_user = 1;
+		save_registers(regs);
+
+		if(WIFSTOPPED(status)){
+		  	switch(WSTOPSIG(status)){
+			case SIGSEGV:
+				handle_segv(userspace_pid);
+				break;
+			case SIGTRAP:
+			        handle_trap(userspace_pid, regs);
+				break;
+			case SIGIO:
+			case SIGVTALRM:
+			case SIGILL:
+			case SIGBUS:
+			case SIGFPE:
+				user_signal(WSTOPSIG(status), regs);
+				break;
+			default:
+			        printk("userspace - child stopped with signal "
+				       "%d\n", WSTOPSIG(status));
+			}
+			interrupt_end();
+		}
+
+		restore_registers(regs);
+
+		op = singlestepping_skas() ? PTRACE_SINGLESTEP : 
+			PTRACE_SYSCALL;
+		err = ptrace(op, userspace_pid, 0, 0);
+		if(err)
+			panic("userspace - PTRACE_SYSCALL failed, "
+			      "errno = %d\n", errno);
+	}
+}
+
+void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
+		void (*handler)(int))
+{
+	jmp_buf switch_buf, fork_buf;
+
+	*switch_buf_ptr = &switch_buf;
+	*fork_buf_ptr = &fork_buf;
+
+	if(setjmp(fork_buf) == 0)
+		new_thread_proc(stack, handler);
+
+	remove_sigstack();
+}
+
+void thread_wait(void *sw, void *fb)
+{
+	jmp_buf buf, **switch_buf = sw, *fork_buf;
+
+	*switch_buf = &buf;
+	fork_buf = fb;
+	if(setjmp(buf) == 0)
+		longjmp(*fork_buf, 1);
+}
+
+static int move_registers(int int_op, int fp_op, struct uml_pt_regs *regs,
+			  unsigned long *fp_regs)
+{
+	if(ptrace(int_op, userspace_pid, 0, regs->mode.skas.regs) < 0)
+		return(-errno);
+	if(ptrace(fp_op, userspace_pid, 0, fp_regs) < 0)
+		return(-errno);
+	return(0);
+}
+
+void save_registers(struct uml_pt_regs *regs)
+{
+	unsigned long *fp_regs;
+	int err, fp_op;
+
+	if(have_fpx_regs){
+		fp_op = PTRACE_GETFPXREGS;
+		fp_regs = regs->mode.skas.xfp;
+	}
+	else {
+		fp_op = PTRACE_GETFPREGS;
+		fp_regs = regs->mode.skas.fp;
+	}
+
+	err = move_registers(PTRACE_GETREGS, fp_op, regs, fp_regs);
+	if(err)
+		panic("save_registers - saving registers failed, errno = %d\n",
+		      err);
+}
+
+void restore_registers(struct uml_pt_regs *regs)
+{
+	unsigned long *fp_regs;
+	int err, fp_op;
+
+	if(have_fpx_regs){
+		fp_op = PTRACE_SETFPXREGS;
+		fp_regs = regs->mode.skas.xfp;
+	}
+	else {
+		fp_op = PTRACE_SETFPREGS;
+		fp_regs = regs->mode.skas.fp;
+	}
+
+	err = move_registers(PTRACE_SETREGS, fp_op, regs, fp_regs);
+	if(err)
+		panic("restore_registers - saving registers failed, "
+		      "errno = %d\n", err);
+}
+
+void switch_threads(void *me, void *next)
+{
+	jmp_buf my_buf, **me_ptr = me, *next_buf = next;
+	
+	*me_ptr = &my_buf;
+	if(setjmp(my_buf) == 0)
+		longjmp(*next_buf, 1);
+}
+
+static jmp_buf initial_jmpbuf;
+
+/* XXX Make these percpu */
+static void (*cb_proc)(void *arg);
+static void *cb_arg;
+static jmp_buf *cb_back;
+
+int start_idle_thread(void *stack, void *switch_buf_ptr, void **fork_buf_ptr)
+{
+	jmp_buf **switch_buf = switch_buf_ptr;
+	int n;
+
+	*fork_buf_ptr = &initial_jmpbuf;
+	n = setjmp(initial_jmpbuf);
+	if(n == 0)
+		new_thread_proc((void *) stack, new_thread_handler);
+	else if(n == 1)
+		remove_sigstack();
+	else if(n == 2){
+		(*cb_proc)(cb_arg);
+		longjmp(*cb_back, 1);
+	}
+	else if(n == 3)
+		return(0);
+	else if(n == 4)
+		return(1);
+	longjmp(**switch_buf, 1);
+}
+
+void remove_sigstack(void)
+{
+	stack_t stack = ((stack_t) { .ss_flags	= SS_DISABLE,
+				     .ss_sp	= NULL,
+				     .ss_size	= 0 });
+
+	if(sigaltstack(&stack, NULL) != 0)
+		panic("disabling signal stack failed, errno = %d\n", errno);
+}
+
+void initial_thread_cb_skas(void (*proc)(void *), void *arg)
+{
+	jmp_buf here;
+
+	cb_proc = proc;
+	cb_arg = arg;
+	cb_back = &here;
+	if(setjmp(here) == 0)
+		longjmp(initial_jmpbuf, 2);
+	
+}
+
+void halt_skas(void)
+{
+	block_signals();
+	longjmp(initial_jmpbuf, 3);
+}
+
+void reboot_skas(void)
+{
+	block_signals();
+	longjmp(initial_jmpbuf, 4);
+}
+
+int new_mm(int from)
+{
+	struct proc_mm_op copy;
+	int n, fd = os_open_file("/proc/mm", of_write(OPENFLAGS()), 0);
+
+	if(fd < 0)
+		return(-errno);
+
+	if(from != -1){
+		copy = ((struct proc_mm_op) { .op 	= MM_COPY_SEGMENTS,
+					      .u 	= 
+					      { .copy_segments	= from } } );
+		n = os_write_file(fd, (char *) &copy, sizeof(copy));
+		if(n != sizeof(copy)) 
+			printk("new_mm : /proc/mm copy_segments failed, "
+			       "errno = %d\n", errno);
+	}
+	return(fd);
+}
+
+void switch_mm_skas(int mm_fd)
+{
+	int err;
+
+	err = ptrace(PTRACE_SWITCH_MM, userspace_pid, 0, mm_fd);
+	if(err)
+		panic("switch_mm_skas - PTRACE_SWITCH_MM failed, errno = %d\n",
+		      errno);
+}
+
+void kill_off_processes_skas(void)
+{
+	os_kill_process(userspace_pid, 1);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

arch/um/kernel/skas/process_kern.c

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "kern_util.h"
+#include "time_user.h"
+#include "signal_user.h"
+#include "skas.h"
+#include "os.h"
+#include "user_util.h"
+#include "tlb.h"
+#include "frame.h"
+#include "kern.h"
+#include "mode.h"
+
+int singlestepping_skas(void)
+{
+	int ret = current->ptrace & PT_DTRACE;
+
+	current->ptrace &= ~PT_DTRACE;
+	return(ret);
+}
+
+void *switch_to_skas(void *prev, void *next)
+{
+	struct task_struct *from, *to;
+
+	from = prev;
+	to = next;
+
+	/* XXX need to check runqueues[cpu].idle */
+	if(current->pid == 0)
+		switch_timers(0);
+
+	to->thread.prev_sched = from;
+	set_current(to);
+
+	switch_threads(&from->thread.mode.skas.switch_buf, 
+		       to->thread.mode.skas.switch_buf);
+
+	if(current->pid == 0)
+		switch_timers(1);
+
+	return(current->thread.prev_sched);
+}
+
+extern void schedule_tail(struct task_struct *prev);
+
+void new_thread_handler(int sig)
+{
+	int (*fn)(void *), n;
+	void *arg;
+
+	fn = current->thread.request.u.thread.proc;
+	arg = current->thread.request.u.thread.arg;
+	change_sig(SIGUSR1, 1);
+	thread_wait(&current->thread.mode.skas.switch_buf, 
+		    current->thread.mode.skas.fork_buf);
+
+#ifdef CONFIG_SMP
+	schedule_tail(NULL);
+#endif
+	current->thread.prev_sched = NULL;
+
+	n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
+	if(n == 1)
+		userspace(&current->thread.regs.regs);
+	else if(n == 2)
+		do_exit(0);
+}
+
+void new_thread_proc(void *stack, void (*handler)(int sig))
+{
+	init_new_thread_stack(stack, handler);
+	os_usr1_process(os_getpid());
+}
+
+void release_thread_skas(struct task_struct *task)
+{
+}
+
+void exit_thread_skas(void)
+{
+}
+
+void fork_handler(int sig)
+{
+        change_sig(SIGUSR1, 1);
+ 	thread_wait(&current->thread.mode.skas.switch_buf, 
+		    current->thread.mode.skas.fork_buf);
+  	
+	force_flush_all();
+#ifdef CONFIG_SMP
+	schedule_tail(current->thread.prev_sched);
+#endif
+	current->thread.prev_sched = NULL;
+	unblock_signals();
+
+	userspace(&current->thread.regs.regs);
+}
+
+int copy_thread_skas(int nr, unsigned long clone_flags, unsigned long sp,
+		     unsigned long stack_top, struct task_struct * p, 
+		     struct pt_regs *regs)
+{
+  	void (*handler)(int);
+
+	if(current->thread.forking){
+	  	memcpy(&p->thread.regs.regs.mode.skas, 
+		       &current->thread.regs.regs.mode.skas, 
+		       sizeof(p->thread.regs.regs.mode.skas));
+		REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.mode.skas.regs, 0);
+		if(sp != 0) REGS_SP(p->thread.regs.regs.mode.skas.regs) = sp;
+
+		handler = fork_handler;
+	}
+	else {
+	  	memcpy(p->thread.regs.regs.mode.skas.regs, exec_regs, 
+		       sizeof(p->thread.regs.regs.mode.skas.regs));
+		memcpy(p->thread.regs.regs.mode.skas.fp, exec_fp_regs, 
+		       sizeof(p->thread.regs.regs.mode.skas.fp));
+	  	memcpy(p->thread.regs.regs.mode.skas.xfp, exec_fpx_regs, 
+		       sizeof(p->thread.regs.regs.mode.skas.xfp));
+                p->thread.request.u.thread = current->thread.request.u.thread;
+		handler = new_thread_handler;
+	}
+
+	new_thread((void *) p->thread.kernel_stack, 
+		   &p->thread.mode.skas.switch_buf, 
+		   &p->thread.mode.skas.fork_buf, handler);
+	return(0);
+}
+
+void init_idle_skas(void)
+{
+	cpu_tasks[current->thread_info->cpu].pid = os_getpid();
+}
+
+extern void start_kernel(void);
+
+static int start_kernel_proc(void *unused)
+{
+	int pid;
+
+	block_signals();
+	pid = os_getpid();
+
+	cpu_tasks[0].pid = pid;
+	cpu_tasks[0].task = current;
+#ifdef CONFIG_SMP
+ 	cpu_online_map = 1;
+#endif
+	start_kernel();
+	return(0);
+}
+
+int start_uml_skas(void)
+{
+	start_userspace();
+	capture_signal_stack();
+
+	init_new_thread_signals(1);
+	idle_timer();
+
+	init_task.thread.request.u.thread.proc = start_kernel_proc;
+	init_task.thread.request.u.thread.arg = NULL;
+	return(start_idle_thread((void *) init_task.thread.kernel_stack,
+				 &init_task.thread.mode.skas.switch_buf,
+				 &init_task.thread.mode.skas.fork_buf));
+}
+
+int external_pid_skas(struct task_struct *task)
+{
+	return(userspace_pid);
+}
+
+int thread_pid_skas(struct thread_struct *thread)
+{
+	return(userspace_pid);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

arch/um/kernel/skas/syscall_user.c

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <signal.h>
+#include "kern_util.h"
+#include "syscall_user.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/sigcontext.h"
+
+/* XXX Bogus */
+#define ERESTARTSYS	512
+#define ERESTARTNOINTR	513
+#define ERESTARTNOHAND	514
+
+void handle_syscall(struct uml_pt_regs *regs)
+{
+	long result;
+	int index;
+
+	host_to_regs(regs);
+	index = record_syscall_start(UPT_SYSCALL_NR(regs));
+
+	syscall_trace();
+	result = execute_syscall(regs);
+
+	REGS_SET_SYSCALL_RETURN(regs->mode.skas.regs, result);
+	if((result == -ERESTARTNOHAND) || (result == -ERESTARTSYS) || 
+	   (result == -ERESTARTNOINTR))
+		do_signal(result);
+
+	syscall_trace();
+	record_syscall_end(index, result);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

arch/um/kernel/skas/trap_user.c

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <signal.h>
+#include <errno.h>
+#include <asm/sigcontext.h>
+#include "sysdep/ptrace.h"
+#include "signal_user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "task.h"
+#include "sigcontext.h"
+
+void sig_handler_common_skas(int sig, struct sigcontext *sc)
+{
+	struct uml_pt_regs save_regs, *r;
+	struct signal_info *info;
+	int save_errno = errno;
+
+	r = (struct uml_pt_regs *) TASK_REGS(get_current());
+	save_regs = *r;
+	r->is_user = 0;
+	r->mode.skas.fault_addr = SC_FAULT_ADDR(sc);
+	r->mode.skas.fault_type = SC_FAULT_TYPE(sc);
+	r->mode.skas.trap_type = SC_TRAP_TYPE(sc);
+
+	change_sig(SIGUSR1, 1);
+	info = &sig_info[sig];
+	if(!info->is_irq) unblock_signals();
+
+	(*info->handler)(sig, r);
+
+	*r = save_regs;
+	errno = save_errno;
+}
+
+extern int missed_ticks[];
+
+void user_signal(int sig, struct uml_pt_regs *regs)
+{
+	struct signal_info *info;
+
+	if(sig == SIGVTALRM)
+		missed_ticks[cpu()]++;
+	regs->is_user = 1;
+	regs->mode.skas.fault_addr = 0;
+	regs->mode.skas.fault_type = 0;
+	regs->mode.skas.trap_type = 0;
+	info = &sig_info[sig];
+	(*info->handler)(sig, regs);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

arch/um/kernel/tt/include/tt.h

+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_H__
+#define __TT_H__
+
+#include "sysdep/ptrace.h"
+
+extern int gdb_pid;
+extern int debug;
+extern int debug_stop;
+extern int debug_trace;
+
+extern int honeypot;
+
+extern int fork_tramp(void *sig_stack);
+extern int do_proc_op(void *t, int proc_id);
+extern int tracer(int (*init_proc)(void *), void *sp);
+extern void attach_process(int pid);
+extern void tracer_panic(char *format, ...);
+extern void set_init_pid(int pid);
+extern int set_user_mode(void *task);
+extern void set_tracing(void *t, int tracing);
+extern int is_tracing(void *task);
+extern int singlestepping_tt(void *t);
+extern void clear_singlestep(void *t);
+extern void syscall_handler(int sig, struct uml_pt_regs *regs);
+extern void exit_kernel(int pid, void *task);
+extern int do_syscall(void *task, int pid);
+extern int is_valid_pid(int pid);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */