forked from Minki/linux
[PATCH] remove remaining errno and __KERNEL_SYSCALLS__ references
The last in-kernel user of errno is gone, so we should remove the definition and everything referring to it. This also removes the now-unused lib/execve.c file that was introduced earlier. Also remove every trace of __KERNEL_SYSCALLS__ that still remained in the kernel. Signed-off-by: Arnd Bergmann <arnd@arndb.de> Cc: Andi Kleen <ak@muc.de> Cc: Paul Mackerras <paulus@samba.org> Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org> Cc: Richard Henderson <rth@twiddle.net> Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru> Cc: Russell King <rmk@arm.linux.org.uk> Cc: Ian Molton <spyro@f2s.com> Cc: Mikael Starvik <starvik@axis.com> Cc: David Howells <dhowells@redhat.com> Cc: Yoshinori Sato <ysato@users.sourceforge.jp> Cc: Hirokazu Takata <takata.hirokazu@renesas.com> Cc: Ralf Baechle <ralf@linux-mips.org> Cc: Kyle McMartin <kyle@mcmartin.ca> Cc: Heiko Carstens <heiko.carstens@de.ibm.com> Cc: Martin Schwidefsky <schwidefsky@de.ibm.com> Cc: Paul Mundt <lethal@linux-sh.org> Cc: Kazumoto Kojima <kkojima@rr.iij4u.or.jp> Cc: Richard Curnow <rc@rc0.org.uk> Cc: William Lee Irwin III <wli@holomorphy.com> Cc: "David S. Miller" <davem@davemloft.net> Cc: Jeff Dike <jdike@addtoit.com> Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it> Cc: Miles Bader <uclinux-v850@lsi.nec.co.jp> Cc: Chris Zankel <chris@zankel.net> Cc: "Luck, Tony" <tony.luck@intel.com> Cc: Geert Uytterhoeven <geert@linux-m68k.org> Cc: Roman Zippel <zippel@linux-m68k.org> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Arnd Bergmann
Linus Torvalds
parent
821278a75d
commit
135ab6ec8f
@ -8,8 +8,6 @@
|
||||
* 2005-10-07 Keith Owens <kaos@sgi.com>
|
||||
* Add notify_die() hooks.
|
||||
*/
|
||||
#define __KERNEL_SYSCALLS__ /* see <asm/unistd.h> */
|
||||
|
||||
#include <linux/cpu.h>
|
||||
#include <linux/pm.h>
|
||||
#include <linux/elf.h>
|
||||
|
||||
@ -26,7 +26,6 @@
|
||||
|
||||
|
||||
|
||||
#define __KERNEL_SYSCALLS__
|
||||
#include <linux/errno.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
|
||||
@ -150,7 +150,6 @@ that only one external action is invoked at a time.
|
||||
#include <linux/skbuff.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/io.h>
|
||||
#define __KERNEL_SYSCALLS__
|
||||
#include <linux/fs.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
@ -322,67 +322,6 @@
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/linkage.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static inline _syscall0(pid_t,setsid)
|
||||
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static inline _syscall1(int,dup,int,fd)
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
static inline _syscall1(int,close,int,fd)
|
||||
|
||||
struct pt_regs;
|
||||
asmlinkage long sys_mmap2(
|
||||
unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(const char *fname, char **argv, char **envp,
|
||||
long r13, long mof, long srp, struct pt_regs *regs);
|
||||
asmlinkage int sys_clone(unsigned long newusp, unsigned long flags,
|
||||
int* parent_tid, int* child_tid, long mof, long srp,
|
||||
struct pt_regs *regs);
|
||||
asmlinkage int sys_fork(long r10, long r11, long r12, long r13,
|
||||
long mof, long srp, struct pt_regs *regs);
|
||||
asmlinkage int sys_vfork(long r10, long r11, long r12, long r13,
|
||||
long mof, long srp, struct pt_regs *regs);
|
||||
asmlinkage int sys_pipe(unsigned long __user *fildes);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
/*
|
||||
* Since we define it "external", it collides with the built-in
|
||||
* definition, which has the "noreturn" attribute and will cause
|
||||
* complaints. We don't want to use -fno-builtin, so just use a
|
||||
* different name when in the kernel.
|
||||
*/
|
||||
#define _exit kernel_syscall_exit
|
||||
static inline _syscall1(int,_exit,int,exitcode)
|
||||
static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -440,31 +440,6 @@ type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg
|
||||
__syscall_return(type, __sc0); \
|
||||
}
|
||||
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/linkage.h>
|
||||
#include <asm/ptrace.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
#define __ARCH_WANT_IPC_PARSE_VERSION
|
||||
/* #define __ARCH_WANT_OLD_READDIR */
|
||||
#define __ARCH_WANT_OLD_STAT
|
||||
|
||||
@ -485,57 +485,6 @@ type name(atype a, btype b, ctype c, dtype d, etype e, ftype f) \
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static inline _syscall0(int,pause)
|
||||
static inline _syscall0(int,sync)
|
||||
static inline _syscall0(pid_t,setsid)
|
||||
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static inline _syscall1(int,dup,int,fd)
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
static inline _syscall1(int,close,int,fd)
|
||||
static inline _syscall1(int,_exit,int,exitcode)
|
||||
static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
static inline _syscall1(int,delete_module,const char *,name)
|
||||
|
||||
static inline pid_t wait(int * wait_stat)
|
||||
{
|
||||
return waitpid(-1,wait_stat,0);
|
||||
}
|
||||
|
||||
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(char *name, char **argv, char **envp,
|
||||
int dummy, ...);
|
||||
asmlinkage int sys_pipe(unsigned long *fildes);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*/
|
||||
|
||||
@ -451,45 +451,6 @@ __syscall_return(type,__res); \
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
#define __ARCH_WANT_SYS_RT_SIGSUSPEND
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/linkage.h>
|
||||
#include <asm/ptrace.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
|
||||
asmlinkage int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount);
|
||||
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(struct pt_regs regs);
|
||||
asmlinkage int sys_clone(struct pt_regs regs);
|
||||
asmlinkage int sys_fork(struct pt_regs regs);
|
||||
asmlinkage int sys_vfork(struct pt_regs regs);
|
||||
asmlinkage int sys_pipe(unsigned long __user *fildes);
|
||||
asmlinkage long sys_iopl(unsigned long unused);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -424,43 +424,6 @@ __syscall_return(type,__res); \
|
||||
#define __ARCH_WANT_SYS_OLDUMOUNT
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/linkage.h>
|
||||
#include <asm/ptrace.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
static __inline__ _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
|
||||
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(struct pt_regs regs);
|
||||
asmlinkage int sys_clone(struct pt_regs regs);
|
||||
asmlinkage int sys_fork(struct pt_regs regs);
|
||||
asmlinkage int sys_vfork(struct pt_regs regs);
|
||||
asmlinkage int sys_pipe(unsigned long __user *fildes);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -409,12 +409,6 @@ __syscall_return(type,__res); \
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -463,61 +463,6 @@ type name(atype a, btype b, ctype c, dtype d, etype e) \
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static inline _syscall0(int,pause)
|
||||
static inline _syscall0(int,sync)
|
||||
static inline _syscall0(pid_t,setsid)
|
||||
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static inline _syscall1(int,dup,int,fd)
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
static inline _syscall1(int,close,int,fd)
|
||||
static inline _syscall1(int,_exit,int,exitcode)
|
||||
static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
static inline _syscall1(int,delete_module,const char *,name)
|
||||
|
||||
static inline pid_t wait(int * wait_stat)
|
||||
{
|
||||
return waitpid(-1,wait_stat,0);
|
||||
}
|
||||
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(char *name, char **argv, char **envp);
|
||||
asmlinkage int sys_pipe(unsigned long *fildes);
|
||||
struct pt_regs;
|
||||
int sys_request_irq(unsigned int,
|
||||
irqreturn_t (*)(int, void *, struct pt_regs *),
|
||||
unsigned long, const char *, void *);
|
||||
void sys_free_irq(unsigned int, void *);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -1212,45 +1212,6 @@ type name (atype a,btype b,ctype c,dtype d,etype e,ftype f) \
|
||||
# define __ARCH_WANT_COMPAT_SYS_TIME
|
||||
# endif
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/linkage.h>
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/sim.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
|
||||
asmlinkage unsigned long sys_mmap(
|
||||
unsigned long addr, size_t len,
|
||||
int prot, int flags,
|
||||
int fd, off_t offset);
|
||||
asmlinkage long sys_mmap2(
|
||||
unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(nabi_no_regargs struct pt_regs regs);
|
||||
asmlinkage int sys_pipe(nabi_no_regargs struct pt_regs regs);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
#endif /* !__ASSEMBLY__ */
|
||||
|
||||
/*
|
||||
|
||||
@ -523,57 +523,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
|
||||
# define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
|
||||
# endif
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/stat.h>
|
||||
#include <linux/syscalls.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static inline _syscall0(pid_t,setsid)
|
||||
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static inline _syscall1(int,dup,int,fd)
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
static inline _syscall1(int,close,int,fd)
|
||||
static inline _syscall2(long,stat,char *,filename,struct stat *,statbuf)
|
||||
|
||||
static inline pid_t waitpid(int pid, int *wait_stat, int flags)
|
||||
{
|
||||
return sys_wait4(pid, wait_stat, flags, NULL);
|
||||
}
|
||||
struct mmap_arg_struct;
|
||||
asmlinkage long sys_mmap2(struct mmap_arg_struct __user *arg);
|
||||
|
||||
asmlinkage long sys_execve(struct pt_regs regs);
|
||||
asmlinkage long sys_clone(struct pt_regs regs);
|
||||
asmlinkage long sys_fork(struct pt_regs regs);
|
||||
asmlinkage long sys_vfork(struct pt_regs regs);
|
||||
asmlinkage long sys_pipe(unsigned long __user *fildes);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -472,76 +472,6 @@ __syscall_return(type,__sc0); \
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
#define __ARCH_WANT_SYS_RT_SIGSUSPEND
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/linkage.h>
|
||||
#include <asm/ptrace.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static __inline__ _syscall0(int,pause)
|
||||
static __inline__ _syscall0(int,sync)
|
||||
static __inline__ _syscall0(pid_t,setsid)
|
||||
static __inline__ _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
static __inline__ _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static __inline__ _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static __inline__ _syscall1(int,dup,int,fd)
|
||||
static __inline__ _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
static __inline__ _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
static __inline__ _syscall1(int,close,int,fd)
|
||||
static __inline__ _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
static __inline__ _syscall1(int,delete_module,const char *,name)
|
||||
|
||||
static __inline__ pid_t wait(int * wait_stat)
|
||||
{
|
||||
return waitpid(-1,wait_stat,0);
|
||||
}
|
||||
|
||||
asmlinkage long sys_mmap2(
|
||||
unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
asmlinkage int sys_execve(char *ufilename, char **uargv,
|
||||
char **uenvp, unsigned long r7,
|
||||
struct pt_regs regs);
|
||||
asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
|
||||
unsigned long parent_tidptr,
|
||||
unsigned long child_tidptr,
|
||||
struct pt_regs regs);
|
||||
asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
|
||||
unsigned long r6, unsigned long r7,
|
||||
struct pt_regs regs);
|
||||
asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
|
||||
unsigned long r6, unsigned long r7,
|
||||
struct pt_regs regs);
|
||||
asmlinkage int sys_pipe(unsigned long r4, unsigned long r5,
|
||||
unsigned long r6, unsigned long r7,
|
||||
struct pt_regs regs);
|
||||
asmlinkage ssize_t sys_pread_wrapper(unsigned int fd, char *buf,
|
||||
size_t count, long dummy, loff_t pos);
|
||||
asmlinkage ssize_t sys_pwrite_wrapper(unsigned int fd, const char *buf,
|
||||
size_t count, long dummy, loff_t pos);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -513,47 +513,6 @@ __syscall_return(type,__sc0); \
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
/* Copy from sh */
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
#include <asm/ptrace.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static inline _syscall0(int,pause)
|
||||
static inline _syscall1(int,setup,int,magic)
|
||||
static inline _syscall0(int,sync)
|
||||
static inline _syscall0(pid_t,setsid)
|
||||
static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static inline _syscall1(int,dup,int,fd)
|
||||
static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
static inline _syscall1(int,close,int,fd)
|
||||
static inline _syscall1(int,_exit,int,exitcode)
|
||||
static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
static inline _syscall1(int,delete_module,const char *,name)
|
||||
|
||||
static inline pid_t wait(int * wait_stat)
|
||||
{
|
||||
return waitpid(-1,wait_stat,0);
|
||||
}
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -478,53 +478,6 @@ return -1; \
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGSUSPEND
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static __inline__ _syscall0(pid_t,setsid)
|
||||
static __inline__ _syscall3(int,write,int,fd,__const__ char *,buf,off_t,count)
|
||||
static __inline__ _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static __inline__ _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static __inline__ _syscall1(int,dup,int,fd)
|
||||
static __inline__ _syscall3(int,execve,__const__ char *,file,char **,argv,char **,envp)
|
||||
static __inline__ _syscall3(int,open,__const__ char *,file,int,flag,int,mode)
|
||||
static __inline__ _syscall1(int,close,int,fd)
|
||||
static __inline__ _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
|
||||
#include <linux/linkage.h>
|
||||
|
||||
asmlinkage unsigned long sys_mmap(
|
||||
unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long off);
|
||||
asmlinkage unsigned long sys_mmap2(
|
||||
unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
void __user *restorer,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -445,48 +445,6 @@ if (__res>=0) \
|
||||
errno = -__res; \
|
||||
return -1; \
|
||||
}
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
static __inline__ _syscall0(pid_t,setsid)
|
||||
static __inline__ _syscall3(int,write,int,fd,__const__ char *,buf,off_t,count)
|
||||
static __inline__ _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
static __inline__ _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
static __inline__ _syscall1(int,dup,int,fd)
|
||||
static __inline__ _syscall3(int,execve,__const__ char *,file,char **,argv,char **,envp)
|
||||
static __inline__ _syscall3(int,open,__const__ char *,file,int,flag,int,mode)
|
||||
static __inline__ _syscall1(int,close,int,fd)
|
||||
static __inline__ _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
|
||||
#include <linux/linkage.h>
|
||||
|
||||
asmlinkage unsigned long sys_mmap(
|
||||
unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long off);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
void __user *restorer,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/* sysconf options, for SunOS compatibility */
|
||||
#define _SC_ARG_MAX 1
|
||||
|
||||
@ -387,57 +387,6 @@ type name (atype a, btype b, ctype c, dtype d, etype e, ftype f) \
|
||||
#define __ARCH_WANT_SYS_SIGPROCMASK
|
||||
#define __ARCH_WANT_SYS_RT_SIGACTION
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
#define __NR__exit __NR_exit
|
||||
extern inline _syscall0(pid_t,setsid)
|
||||
extern inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
|
||||
extern inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
|
||||
extern inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
|
||||
extern inline _syscall1(int,dup,int,fd)
|
||||
extern inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
|
||||
extern inline _syscall3(int,open,const char *,file,int,flag,int,mode)
|
||||
extern inline _syscall1(int,close,int,fd)
|
||||
extern inline _syscall1(int,_exit,int,exitcode)
|
||||
extern inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
|
||||
|
||||
extern inline pid_t wait(int * wait_stat)
|
||||
{
|
||||
return waitpid (-1, wait_stat, 0);
|
||||
}
|
||||
|
||||
unsigned long sys_mmap(unsigned long addr, size_t len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, off_t offset);
|
||||
unsigned long sys_mmap2(unsigned long addr, size_t len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
unsigned long fd, unsigned long pgoff);
|
||||
struct pt_regs;
|
||||
int sys_execve (char *name, char **argv, char **envp, struct pt_regs *regs);
|
||||
int sys_pipe (int *fildes);
|
||||
struct sigaction;
|
||||
asmlinkage long sys_rt_sigaction(int sig,
|
||||
const struct sigaction __user *act,
|
||||
struct sigaction __user *oact,
|
||||
size_t sigsetsize);
|
||||
|
||||
#endif /* __KERNEL_SYSCALLS__ */
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*/
|
||||
|
||||
@ -402,11 +402,6 @@ __asm__ __volatile__ ( \
|
||||
__syscall_return(type,__res); \
|
||||
}
|
||||
|
||||
|
||||
#ifdef __KERNEL_SYSCALLS__
|
||||
static __inline__ _syscall3(int,execve,const char*,file,char**,argv,char**,envp)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* "Conditional" syscalls
|
||||
*
|
||||
|
||||
@ -1,12 +1,8 @@
|
||||
#ifndef _LINUX_UNISTD_H_
|
||||
#define _LINUX_UNISTD_H_
|
||||
|
||||
#ifdef __KERNEL__
|
||||
extern int errno;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Include machine specific syscallX macros
|
||||
* Include machine specific syscall numbers
|
||||
*/
|
||||
#include <asm/unistd.h>
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
# Makefile for some libs needed in the kernel.
|
||||
#
|
||||
|
||||
lib-y := errno.o ctype.o string.o vsprintf.o cmdline.o \
|
||||
lib-y := ctype.o string.o vsprintf.o cmdline.o \
|
||||
bust_spinlocks.o rbtree.o radix-tree.o dump_stack.o \
|
||||
idr.o div64.o int_sqrt.o bitmap.o extable.o prio_tree.o \
|
||||
sha1.o
|
||||
@ -35,8 +35,6 @@ ifneq ($(CONFIG_HAVE_DEC_LOCK),y)
|
||||
lib-y += dec_and_lock.o
|
||||
endif
|
||||
|
||||
lib-y += execve.o
|
||||
|
||||
obj-$(CONFIG_CRC_CCITT) += crc-ccitt.o
|
||||
obj-$(CONFIG_CRC16) += crc16.o
|
||||
obj-$(CONFIG_CRC32) += crc32.o
|
||||
|
||||
@ -1,7 +0,0 @@
|
||||
/*
|
||||
* linux/lib/errno.c
|
||||
*
|
||||
* Copyright (C) 1991, 1992 Linus Torvalds
|
||||
*/
|
||||
|
||||
int errno;
|
||||
23
lib/execve.c
23
lib/execve.c
@ -1,23 +0,0 @@
|
||||
#include <asm/bug.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#define __KERNEL_SYSCALLS__
|
||||
static int errno __attribute__((unused));
|
||||
#include <asm/unistd.h>
|
||||
|
||||
#ifdef _syscall3
|
||||
int kernel_execve (const char *filename, char *const argv[], char *const envp[])
|
||||
__attribute__((__weak__));
|
||||
int kernel_execve (const char *filename, char *const argv[], char *const envp[])
|
||||
{
|
||||
mm_segment_t fs = get_fs();
|
||||
int ret;
|
||||
|
||||
WARN_ON(segment_eq(fs, USER_DS));
|
||||
ret = execve(filename, (char **)argv, (char **)envp);
|
||||
if (ret)
|
||||
ret = -errno;
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user