Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-23 12:42:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

[PATCH] uml: system call path cleanup

Browse Source 
This merges two sets of files which had no business being split apart in the
first place.

Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Jeff Dike 2005-09-03 15:57:42 -07:00 committed by Linus Torvalds
parent 08964c565b
commit e32dacb9f4
13 changed files with 131 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
arch/um/include/syscall.h Normal file
View File

@ -0,0 +1,12 @@
/*
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
* Licensed under the GPL
*/
#ifndef __SYSCALL_USER_H
#define __SYSCALL_USER_H
extern int record_syscall_start(int syscall);
extern void record_syscall_end(int index, long result);
#endif

23
arch/um/include/syscall_user.h
View File

@ -1,23 +0,0 @@
/*
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
* Licensed under the GPL
*/
#ifndef __SYSCALL_USER_H
#define __SYSCALL_USER_H
extern int record_syscall_start(int syscall);
extern void record_syscall_end(int index, long result);
#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:
*/

2
arch/um/include/sysdep-i386/syscalls.h
View File

@ -16,6 +16,8 @@ extern syscall_handler_t sys_rt_sigaction;
extern syscall_handler_t old_mmap_i386;
extern syscall_handler_t *sys_call_table[];
#define EXECUTE_SYSCALL(syscall, regs) \
((long (*)(struct syscall_args)) (*sys_call_table[syscall]))(SYSCALL_ARGS(&regs->regs))

2
arch/um/include/sysdep-x86_64/syscalls.h
View File

@ -14,6 +14,8 @@ typedef long syscall_handler_t(void);
extern syscall_handler_t *ia32_sys_call_table[];
extern syscall_handler_t *sys_call_table[];
#define EXECUTE_SYSCALL(syscall, regs) \
(((long (*)(long, long, long, long, long, long)) \
(*sys_call_table[syscall]))(UPT_SYSCALL_ARG1(&regs->regs), \

2
arch/um/kernel/Makefile
View File

@ -18,7 +18,7 @@ obj-$(CONFIG_BLK_DEV_INITRD) += initrd.o
obj-$(CONFIG_GPROF) += gprof_syms.o
obj-$(CONFIG_GCOV) += gmon_syms.o
obj-$(CONFIG_TTY_LOG) += tty_log.o
obj-$(CONFIG_SYSCALL_DEBUG) += syscall_user.o
obj-$(CONFIG_SYSCALL_DEBUG) += syscall.o
obj-$(CONFIG_MODE_TT) += tt/
obj-$(CONFIG_MODE_SKAS) += skas/

2
arch/um/kernel/skas/Makefile
View File

@ -4,7 +4,7 @@
#
obj-y := clone.o exec_kern.o mem.o mem_user.o mmu.o process.o process_kern.o \
syscall_kern.o syscall_user.o tlb.o trap_user.o uaccess.o \
syscall.o tlb.o trap_user.o uaccess.o
subdir- := util

50
arch/um/kernel/skas/syscall.c Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
* Licensed under the GPL
*/
#include "linux/sys.h"
#include "linux/ptrace.h"
#include "asm/errno.h"
#include "asm/unistd.h"
#include "asm/ptrace.h"
#include "asm/current.h"
#include "sysdep/syscalls.h"
#include "kern_util.h"
#include "syscall.h"
void handle_syscall(union uml_pt_regs *r)
{
struct pt_regs *regs = container_of(r, struct pt_regs, regs);
long result;
int syscall;
#ifdef UML_CONFIG_SYSCALL_DEBUG
int index;
index = record_syscall_start(UPT_SYSCALL_NR(r));
#endif
syscall_trace(r, 0);
current->thread.nsyscalls++;
nsyscalls++;
/* This should go in the declaration of syscall, but when I do that,
* strace -f -c bash -c 'ls ; ls' breaks, sometimes not tracing
* children at all, sometimes hanging when bash doesn't see the first
* ls exit.
* The assembly looks functionally the same to me. This is
* gcc version 4.0.1 20050727 (Red Hat 4.0.1-5)
* in case it's a compiler bug.
*/
syscall = UPT_SYSCALL_NR(r);
if((syscall >= NR_syscalls) || (syscall < 0))
result = -ENOSYS;
else result = EXECUTE_SYSCALL(syscall, regs);
REGS_SET_SYSCALL_RETURN(r->skas.regs, result);
syscall_trace(r, 1);
#ifdef UML_CONFIG_SYSCALL_DEBUG
record_syscall_end(index, result);
#endif
}

43
arch/um/kernel/skas/syscall_kern.c
View File

@ -1,43 +0,0 @@
/*
* Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
* Licensed under the GPL
*/
#include "linux/sys.h"
#include "linux/ptrace.h"
#include "asm/errno.h"
#include "asm/unistd.h"
#include "asm/ptrace.h"
#include "asm/current.h"
#include "sysdep/syscalls.h"
#include "kern_util.h"
extern syscall_handler_t *sys_call_table[];
long execute_syscall_skas(void *r)
{
struct pt_regs *regs = r;
long res;
int syscall;
current->thread.nsyscalls++;
nsyscalls++;
syscall = UPT_SYSCALL_NR(&regs->regs);
if((syscall >= NR_syscalls) || (syscall < 0))
res = -ENOSYS;
else res = EXECUTE_SYSCALL(syscall, regs);
return(res);
}
/*
* 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:
*/

44
arch/um/kernel/skas/syscall_user.c
View File

@ -1,44 +0,0 @@
/*
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
* Licensed under the GPL
*/
#include <stdlib.h>
#include <signal.h>
#include "kern_util.h"
#include "uml-config.h"
#include "syscall_user.h"
#include "sysdep/ptrace.h"
#include "sysdep/sigcontext.h"
#include "skas.h"
void handle_syscall(union uml_pt_regs *regs)
{
long result;
#ifdef UML_CONFIG_SYSCALL_DEBUG
int index;
index = record_syscall_start(UPT_SYSCALL_NR(regs));
#endif
syscall_trace(regs, 0);
result = execute_syscall_skas(regs);
REGS_SET_SYSCALL_RETURN(regs->skas.regs, result);
syscall_trace(regs, 1);
#ifdef UML_CONFIG_SYSCALL_DEBUG
record_syscall_end(index, result);
#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:
*/

36
arch/um/kernel/syscall.c Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
* Licensed under the GPL
*/
#include "kern_util.h"
#include "syscall.h"
#include "os.h"
struct {
int syscall;
int pid;
long result;
unsigned long long start;
unsigned long long end;
} syscall_record[1024];
int record_syscall_start(int syscall)
{
int max, index;
max = sizeof(syscall_record)/sizeof(syscall_record[0]);
index = next_syscall_index(max);
syscall_record[index].syscall = syscall;
syscall_record[index].pid = current_pid();
syscall_record[index].result = 0xdeadbeef;
syscall_record[index].start = os_usecs();
return(index);
}
void record_syscall_end(int index, long result)
{
syscall_record[index].result = result;
syscall_record[index].end = os_usecs();
}

48
arch/um/kernel/syscall_user.c
View File

@ -1,48 +0,0 @@
/*
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
* Licensed under the GPL
*/
#include <stdlib.h>
#include <sys/time.h>
#include "kern_util.h"
#include "syscall_user.h"
struct {
int syscall;
int pid;
long result;
struct timeval start;
struct timeval end;
} syscall_record[1024];
int record_syscall_start(int syscall)
{
int max, index;
max = sizeof(syscall_record)/sizeof(syscall_record[0]);
index = next_syscall_index(max);
syscall_record[index].syscall = syscall;
syscall_record[index].pid = current_pid();
syscall_record[index].result = 0xdeadbeef;
gettimeofday(&syscall_record[index].start, NULL);
return(index);
}
void record_syscall_end(int index, long result)
{
syscall_record[index].result = result;
gettimeofday(&syscall_record[index].end, NULL);
}
/*
* 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:
*/

47
arch/um/kernel/tt/syscall_kern.c
View File

@ -12,36 +12,41 @@
#include "asm/uaccess.h"
#include "asm/stat.h"
#include "sysdep/syscalls.h"
#include "sysdep/sigcontext.h"
#include "kern_util.h"
#include "syscall.h"
extern syscall_handler_t *sys_call_table[];
long execute_syscall_tt(void *r)
void syscall_handler_tt(int sig, struct pt_regs *regs)
{
struct pt_regs *regs = r;
long res;
void *sc;
long result;
int syscall;
#ifdef CONFIG_SYSCALL_DEBUG
int index;
index = record_syscall_start(syscall);
#endif
sc = UPT_SC(&regs->regs);
SC_START_SYSCALL(sc);
syscall_trace(&regs->regs, 0);
current->thread.nsyscalls++;
nsyscalls++;
#endif
syscall = UPT_SYSCALL_NR(&regs->regs);
if((syscall >= NR_syscalls) || (syscall < 0))
res = -ENOSYS;
else res = EXECUTE_SYSCALL(syscall, regs);
result = -ENOSYS;
else result = EXECUTE_SYSCALL(syscall, regs);
return(res);
/* regs->sc may have changed while the system call ran (there may
* have been an interrupt or segfault), so it needs to be refreshed.
*/
UPT_SC(&regs->regs) = sc;
SC_SET_SYSCALL_RETURN(sc, result);
syscall_trace(&regs->regs, 1);
#ifdef CONFIG_SYSCALL_DEBUG
record_syscall_end(index, result);
#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:
*/

35
arch/um/kernel/tt/syscall_user.c
View File

@ -13,42 +13,9 @@
#include "task.h"
#include "user_util.h"
#include "kern_util.h"
#include "syscall_user.h"
#include "syscall.h"
#include "tt.h"
void syscall_handler_tt(int sig, union uml_pt_regs *regs)
{
void *sc;
long result;
int syscall;
#ifdef UML_CONFIG_DEBUG_SYSCALL
int index;
#endif
syscall = UPT_SYSCALL_NR(regs);
sc = UPT_SC(regs);
SC_START_SYSCALL(sc);
#ifdef UML_CONFIG_DEBUG_SYSCALL
index = record_syscall_start(syscall);
#endif
syscall_trace(regs, 0);
result = execute_syscall_tt(regs);
/* regs->sc may have changed while the system call ran (there may
* have been an interrupt or segfault), so it needs to be refreshed.
*/
UPT_SC(regs) = sc;
SC_SET_SYSCALL_RETURN(sc, result);
syscall_trace(regs, 1);
#ifdef UML_CONFIG_DEBUG_SYSCALL
record_syscall_end(index, result);
#endif
}
void do_sigtrap(void *task)
{
UPT_SYSCALL_NR(TASK_REGS(task)) = -1;