diff options
| author | marcel <marcel@FreeBSD.org> | 2001-09-08 19:07:04 +0000 |
|---|---|---|
| committer | marcel <marcel@FreeBSD.org> | 2001-09-08 19:07:04 +0000 |
| commit | df61d9eb64550a7afc1b41ccc9e0261af45c98c1 (patch) | |
| tree | 684b7cfa2a29ef6b8c2244d13f69d58e1e89c819 | |
| parent | bc484946ce384f7bb29f0d6da97f0d3eb7084574 (diff) | |
| download | FreeBSD-src-df61d9eb64550a7afc1b41ccc9e0261af45c98c1.zip FreeBSD-src-df61d9eb64550a7afc1b41ccc9e0261af45c98c1.tar.gz | |
Round of cleanups and enhancements. These include (in random order):
o Introduce private types for use in linux syscalls for two reasons:
1. establish type independence for ease in porting and,
2. provide a visual queue as to which syscalls have proper
prototypes to further cleanup the i386/alpha split.
Linuxulator types are prefixed by 'l_'. void and char have not
been "virtualized".
o Provide dummy functions for all syscalls and remove dummy functions
or implementations of truely obsolete syscalls.
o Sanitize the shm*, sem* and msg* syscalls.
o Make a first attempt to implement the linux_sysctl syscall. At this
time it only returns one MIB (KERN_VERSION), but most importantly,
it tells us when we need to add additional sysctls :-)
o Bump the kenel version up to 2.4.2 (this is not the same as the
KERN_VERSION MIB, BTW).
o Implement new syscalls, of which most are specific to i386. Our
syscall table is now up to date with Linux 2.4.2. Some highlights:
- Implement the 32-bit uid_t and gid_t bases syscalls.
- Implement a couple of 64-bit file size/offset bases syscalls.
o Fix or improve numerous syscalls and prototypes.
o Reduce style(9) violations while I'm here. Especially indentation
inconsistencies within the same file are addressed. Re-indenting
did not obfuscate actual changes to the extend that it could not
be combined.
NOTE: I spend some time testing these changes and found that if there
were regressions, they were not caused by these changes AFAICT.
It was observed that installing a RH 7.1 runtime environment
did make matters worse. Hangs and/or reboots have been observed
with and without these changes, so when it failed to make life
better in cases it doesn't look like it made it worse.
27 files changed, 3655 insertions, 2748 deletions
diff --git a/sys/alpha/linux/linux.h b/sys/alpha/linux/linux.h index af3f3ac..6ea22e6 100644 --- a/sys/alpha/linux/linux.h +++ b/sys/alpha/linux/linux.h @@ -38,19 +38,70 @@ */ extern u_char linux_debug_map[]; #define ldebug(name) isclr(linux_debug_map, LINUX_SYS_linux_ ## name) -#define ARGS(nm, fmt) "Linux-emul(%ld): "#nm"("fmt")\n", (long)p->p_pid -#define LMSG(fmt) "Linux-emul(%ld): "fmt"\n", (long)p->p_pid +#define ARGS(nm, fmt) "linux(%ld): "#nm"("fmt")\n", (long)p->p_pid +#define LMSG(fmt) "linux(%ld): "fmt"\n", (long)p->p_pid #ifdef MALLOC_DECLARE MALLOC_DECLARE(M_LINUX); #endif +typedef int l_int; +typedef int64_t l_long; +typedef int64_t l_longlong; +typedef short l_short; +typedef unsigned int l_uint; +typedef uint64_t l_ulong; +typedef uint64_t l_ulonglong; +typedef unsigned short l_ushort; + +typedef char *l_caddr_t; +typedef l_long l_clock_t; +typedef l_int l_daddr_t; +typedef l_uint l_dev_t; +typedef l_uint l_gid_t; +typedef l_ushort l_gid16_t; +typedef l_uint l_ino_t; +typedef l_int l_key_t; +typedef l_long l_loff_t; +typedef l_uint l_mode_t; +typedef l_long l_off_t; +typedef l_int l_pid_t; +typedef l_ulong l_size_t; +typedef l_long l_suseconds_t; +typedef l_long l_time_t; +typedef l_uint l_uid_t; +typedef l_ushort l_uid16_t; + +typedef struct { + l_int val[2]; +} l_fsid_t; + +typedef struct { + l_time_t tv_sec; + l_suseconds_t tv_usec; +} l_timeval; + +#define l_fd_set fd_set + /* * Miscellaneous */ #define LINUX_NAME_MAX 255 #define LINUX_MAX_UTSNAME 65 +#define LINUX_CTL_MAXNAME 10 + +struct l___sysctl_args +{ + l_int *name; + l_int nlen; + void *oldval; + l_size_t *oldlenp; + void *newval; + l_size_t newlen; + l_ulong __spare[4]; +}; + /* Scheduling policies */ #define LINUX_SCHED_OTHER 0 #define LINUX_SCHED_FIFO 1 @@ -77,25 +128,32 @@ MALLOC_DECLARE(M_LINUX); #define LINUX_MAP_FIXED 0x0100 #define LINUX_MAP_GROWSDOWN 0x1000 -typedef char * linux_caddr_t; -typedef long linux_clock_t; -typedef u_short linux_dev_t; -typedef u_short linux_gid_t; -typedef u_long linux_ino_t; -typedef int linux_key_t; /* XXX */ -typedef u_short linux_mode_t; -typedef u_short linux_nlink_t; -typedef long linux_off_t; -typedef int linux_pid_t; -/*typedef u_int linux_size_t; */ -typedef long linux_time_t; -typedef u_short linux_uid_t; +/* + * stat family of syscalls + */ +struct l_timespec { + l_ulong tv_sec; +}; -typedef struct { - int val[2]; -} linux_fsid_t; +struct l_newstat { + l_uint st_dev; + l_uint st_ino; + l_uint st_mode; + l_uint st_nlink; + l_uint st_uid; + l_uint st_gid; + l_uint st_rdev; + l_long st_size; + struct l_timespec st_atimespec; + struct l_timespec st_mtimespec; + struct l_timespec st_ctimespec; + l_uint st_blksize; + l_int st_blocks; + l_uint st_flags; + l_uint st_gen; +}; -struct linux_new_utsname { +struct l_new_utsname { char sysname[LINUX_MAX_UTSNAME]; char nodename[LINUX_MAX_UTSNAME]; char release[LINUX_MAX_UTSNAME]; @@ -139,10 +197,12 @@ struct linux_new_utsname { #define LINUX_SIGIO 29 #define LINUX_SIGPOLL LINUX_SIGIO #define LINUX_SIGPWR 30 -#define LINUX_SIGTBLSZ 31 -#define LINUX_SIGUNUSED LINUX_SIGTBLSZ +#define LINUX_SIGUNUSED 31 -#define LINUX_NSIG 64 +#define LINUX_SIGTBLSZ 31 +#define LINUX_NSIG_WORDS 2 +#define LINUX_NBPW 32 +#define LINUX_NSIG (LINUX_NBPW * LINUX_NSIG_WORDS) /* sigaction flags */ #define LINUX_SA_ONSTACK 0x00000001 @@ -169,58 +229,49 @@ struct linux_new_utsname { #define LINUX_MINSIGSTKSZ 4096 -typedef void (*linux_handler_t)(int); -typedef u_long linux_osigset_t; +typedef void (*l_handler_t)(l_int); +typedef l_ulong l_osigset_t; typedef struct { - u_int __bits[2]; -/* u_long __bits[1];*/ -} linux_sigset_t; + l_uint __bits[LINUX_NSIG_WORDS]; +} l_sigset_t; typedef struct { - linux_handler_t lsa_handler; - linux_osigset_t lsa_mask; - u_long lsa_flags; + l_handler_t lsa_handler; + l_osigset_t lsa_mask; + l_ulong lsa_flags; void (*lsa_restorer)(void); -} linux_osigaction_t; +} l_osigaction_t; typedef struct { - linux_handler_t lsa_handler; - u_long lsa_flags; + l_handler_t lsa_handler; + l_ulong lsa_flags; void (*lsa_restorer)(void); - linux_sigset_t lsa_mask; -} linux_sigaction_t; - -#if 0 -typedef struct { - void *ss_sp; - int ss_flags; - linux_size_t ss_size; -} linux_stack_t; -#endif + l_sigset_t lsa_mask; +} l_sigaction_t; /* * The Linux sigcontext */ -struct linux_sigcontext { - long sc_onstack; - long sc_mask; - long sc_pc; - long sc_ps; - long sc_regs[32]; - long sc_ownedfp; - long sc_fpregs[32]; - u_long sc_fpcr; - u_long sc_fp_control; - u_long sc_reserved1, sc_reserved2; - u_long sc_ssize; - char * sc_sbase; - u_long sc_traparg_a0; - u_long sc_traparg_a1; - u_long sc_traparg_a2; - u_long sc_fp_trap_pc; - u_long sc_fp_trigger_sum; - u_long sc_fp_trigger_inst; +struct l_sigcontext { + l_long sc_onstack; + l_long sc_mask; + l_long sc_pc; + l_long sc_ps; + l_long sc_regs[32]; + l_long sc_ownedfp; + l_long sc_fpregs[32]; + l_ulong sc_fpcr; + l_ulong sc_fp_control; + l_ulong sc_reserved1, sc_reserved2; + l_ulong sc_ssize; + char *sc_sbase; + l_ulong sc_traparg_a0; + l_ulong sc_traparg_a1; + l_ulong sc_traparg_a2; + l_ulong sc_fp_trap_pc; + l_ulong sc_fp_trigger_sum; + l_ulong sc_fp_trigger_inst; }; /* @@ -229,10 +280,10 @@ struct linux_sigcontext { * This means that we need to pass the pointer to the handler too. * It is appended to the frame to not interfere with the rest of it. */ -struct linux_sigframe { - int sf_sig; - struct linux_sigcontext sf_sc; - linux_handler_t sf_handler; +struct l_sigframe { + l_int sf_sig; + struct l_sigcontext sf_sc; + l_handler_t sf_handler; }; /* @@ -333,6 +384,14 @@ int linux_ioctl_unregister_handler(struct linux_ioctl_handler *h); #define LINUX_SETVAL 16 #define LINUX_SETALL 17 +union l_semun { + l_int val; + struct l_semid_ds *buf; + l_ushort *array; + struct l_seminfo *__buf; + void *__pad; +}; + /* * Socket defines */ @@ -393,41 +452,40 @@ int linux_ioctl_unregister_handler(struct linux_ioctl_handler *h); #define LINUX_IP_ADD_MEMBERSHIP 35 #define LINUX_IP_DROP_MEMBERSHIP 36 -struct linux_sockaddr { - u_short sa_family; - char sa_data[14]; +struct l_sockaddr { + l_ushort sa_family; + char sa_data[14]; }; -struct linux_ifmap { - u_long mem_start; - u_long mem_end; - u_short base_addr; - u_char irq; - u_char dma; - u_char port; +struct l_ifmap { + l_ulong mem_start; + l_ulong mem_end; + l_ushort base_addr; + u_char irq; + u_char dma; + u_char port; }; #define LINUX_IFHWADDRLEN 6 #define LINUX_IFNAMSIZ 16 -struct linux_ifreq { +struct l_ifreq { union { char ifrn_name[LINUX_IFNAMSIZ]; /* if name, e.g. "en0" */ } ifr_ifrn; union { - struct linux_sockaddr ifru_addr; - struct linux_sockaddr ifru_dstaddr; - struct linux_sockaddr ifru_broadaddr; - struct linux_sockaddr ifru_netmask; - struct linux_sockaddr ifru_hwaddr; - short ifru_flags; - int ifru_metric; - int ifru_mtu; - struct linux_ifmap ifru_map; - char ifru_slave[LINUX_IFNAMSIZ]; /* Just fits the size */ - /* linux_caddr_t ifru_data; */ - caddr_t ifru_data; + struct l_sockaddr ifru_addr; + struct l_sockaddr ifru_dstaddr; + struct l_sockaddr ifru_broadaddr; + struct l_sockaddr ifru_netmask; + struct l_sockaddr ifru_hwaddr; + l_short ifru_flags; + l_int ifru_metric; + l_int ifru_mtu; + struct l_ifmap ifru_map; + char ifru_slave[LINUX_IFNAMSIZ]; + l_caddr_t ifru_data; } ifr_ifru; }; @@ -437,7 +495,6 @@ struct linux_ifreq { extern char linux_sigcode[]; extern int linux_szsigcode; -/*extern const char linux_emul_path[];*/ extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL]; extern struct sysentvec linux_sysvec; @@ -447,4 +504,25 @@ extern struct sysentvec elf_linux_sysvec; struct image_params; struct trapframe; +/* + * poll() + */ +#define LINUX_POLLIN 0x0001 +#define LINUX_POLLPRI 0x0002 +#define LINUX_POLLOUT 0x0004 +#define LINUX_POLLERR 0x0008 +#define LINUX_POLLHUP 0x0010 +#define LINUX_POLLNVAL 0x0020 +#define LINUX_POLLRDNORM 0x0040 +#define LINUX_POLLRDBAND 0x0080 +#define LINUX_POLLWRNORM 0x0100 +#define LINUX_POLLWRBAND 0x0200 +#define LINUX_POLLMSG 0x0400 + +struct l_pollfd { + l_int fd; + l_short events; + l_short revents; +}; + #endif /* !_ALPHA_LINUX_LINUX_H_ */ diff --git a/sys/alpha/linux/linux_dummy.c b/sys/alpha/linux/linux_dummy.c index 820c7ab..39fb142 100644 --- a/sys/alpha/linux/linux_dummy.c +++ b/sys/alpha/linux/linux_dummy.c @@ -37,11 +37,9 @@ #include <alpha/linux/linux_proto.h> #include <compat/linux/linux_util.h> - DUMMY(ptrace); -DUMMY(ksyslog); +DUMMY(syslog); DUMMY(vhangup); -DUMMY(idle); DUMMY(swapoff); DUMMY(sysinfo); DUMMY(adjtimex); @@ -52,14 +50,11 @@ DUMMY(get_kernel_syms); DUMMY(quotactl); DUMMY(bdflush); DUMMY(sysfs); -DUMMY(afs_syscall); DUMMY(setfsuid); DUMMY(setfsgid); DUMMY(getsid); -DUMMY(sysctl); DUMMY(query_module); DUMMY(nfsservctl); -DUMMY(getresgid); DUMMY(prctl); DUMMY(rt_sigpending); DUMMY(rt_sigtimedwait); @@ -67,3 +62,24 @@ DUMMY(rt_sigqueueinfo); DUMMY(capget); DUMMY(capset); DUMMY(sendfile); + +DUMMY(chown); +DUMMY(getdtablesize); +DUMMY(gethostname); +DUMMY(getpagesize); +DUMMY(lchown); +DUMMY(madvise); +DUMMY(mincore); +DUMMY(old_adjtimex); +DUMMY(pciconfig_iobase); +DUMMY(pciconfig_read); +DUMMY(pciconfig_write); +DUMMY(pivot_root); +DUMMY(recvmsg); +DUMMY(sendmsg); +DUMMY(sethae); +DUMMY(sigaltstack); +DUMMY(sigpending); +DUMMY(socketpair); +DUMMY(utimes); + diff --git a/sys/alpha/linux/linux_genassym.c b/sys/alpha/linux/linux_genassym.c index d66e6f2..654456f 100644 --- a/sys/alpha/linux/linux_genassym.c +++ b/sys/alpha/linux/linux_genassym.c @@ -7,7 +7,5 @@ #include <alpha/linux/linux.h> -ASSYM(LINUX_SIGF_HANDLER, offsetof(struct linux_sigframe, sf_handler)); -ASSYM(LINUX_SIGF_SC, offsetof(struct linux_sigframe, sf_sc)); -/* ASSYM(LINUX_SC_GS, offsetof(struct linux_sigcontext, sc_gs)); */ -/* ASSYM(LINUX_SC_EFLAGS, offsetof(struct linux_sigcontext, sc_eflags)); */ +ASSYM(LINUX_SIGF_HANDLER, offsetof(struct l_sigframe, sf_handler)); +ASSYM(LINUX_SIGF_SC, offsetof(struct l_sigframe, sf_sc)); diff --git a/sys/alpha/linux/linux_machdep.c b/sys/alpha/linux/linux_machdep.c index 40740b4..d2310c2 100644 --- a/sys/alpha/linux/linux_machdep.c +++ b/sys/alpha/linux/linux_machdep.c @@ -247,7 +247,7 @@ linux_mmap(struct proc *p, struct linux_mmap_args *linux_args) */ /* This gives us TOS */ - bsd_args.addr = linux_args->addr + linux_args->len; + bsd_args.addr = (caddr_t)(linux_args->addr + linux_args->len); /* This gives us our maximum stack size */ if (linux_args->len > STACK_SIZE - GUARD_SIZE) @@ -264,7 +264,7 @@ linux_mmap(struct proc *p, struct linux_mmap_args *linux_args) bsd_args.addr -= bsd_args.len; bsd_args.addr = (caddr_t)round_page(bsd_args.addr); /* XXXX */ } else { - bsd_args.addr = linux_args->addr; + bsd_args.addr = (caddr_t)linux_args->addr; bsd_args.len = linux_args->len; } @@ -299,7 +299,7 @@ linux_rt_sigsuspend(p, uap) struct linux_rt_sigsuspend_args *uap; { int error; - linux_sigset_t lmask; + l_sigset_t lmask; sigset_t *bmask; struct sigsuspend_args bsd; caddr_t sg; @@ -311,10 +311,10 @@ linux_rt_sigsuspend(p, uap) printf(ARGS(rt_sigsuspend, "%p, %d"), (void *)uap->newset, uap->sigsetsize); #endif - if (uap->sigsetsize != sizeof(linux_sigset_t)) + if (uap->sigsetsize != sizeof(l_sigset_t)) return (EINVAL); - error = copyin(uap->newset, &lmask, sizeof(linux_sigset_t)); + error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); if (error) return (error); @@ -373,8 +373,6 @@ static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = { RLIMIT_NPROC, RLIMIT_MEMLOCK }; -int dosetrlimit __P((struct proc *p, u_int which, struct rlimit *limp)); - int linux_setrlimit(p, uap) struct proc *p; diff --git a/sys/alpha/linux/linux_proto.h b/sys/alpha/linux/linux_proto.h index 63829ab..9caa5ea 100644 --- a/sys/alpha/linux/linux_proto.h +++ b/sys/alpha/linux/linux_proto.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/alpha/linux/syscalls.master,v 1.45 2001/02/20 03:47:59 gallatin Exp + * created from FreeBSD: src/sys/alpha/linux/syscalls.master,v 1.48 2001/09/08 18:49:31 marcel Exp */ #ifndef _LINUX_SYSPROTO_H_ @@ -18,517 +18,581 @@ struct proc; #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) -struct linux_fork_args { +#if BYTE_ORDER == LITTLE_ENDIAN +#define PADL_(t) 0 +#define PADR_(t) PAD_(t) +#else +#define PADL_(t) PAD_(t) +#define PADR_(t) 0 +#endif + +struct linux_fork_args { register_t dummy; }; -struct osf1_wait4_args { - int pid; char pid_[PAD_(int)]; - int * status; char status_[PAD_(int *)]; - int options; char options_[PAD_(int)]; - struct osf1_rusage * rusage; char rusage_[PAD_(struct osf1_rusage *)]; -}; -struct linux_link_args { - char * path; char path_[PAD_(char *)]; - char * to; char to_[PAD_(char *)]; +struct osf1_wait4_args { + char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; + char status_l_[PADL_(int *)]; int * status; char status_r_[PADR_(int *)]; + char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; + char rusage_l_[PADL_(struct osf1_rusage *)]; struct osf1_rusage * rusage; char rusage_r_[PADR_(struct osf1_rusage *)]; }; -struct linux_unlink_args { - char * path; char path_[PAD_(char *)]; +struct linux_link_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; -struct linux_chdir_args { - char * path; char path_[PAD_(char *)]; +struct linux_unlink_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_mknod_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; - int dev; char dev_[PAD_(int)]; +struct linux_chdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_chmod_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; +struct linux_mknod_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; + char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)]; }; -struct linux_chown_args { - char * path; char path_[PAD_(char *)]; - int uid; char uid_[PAD_(int)]; - int gid; char gid_[PAD_(int)]; +struct linux_chmod_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; }; -struct linux_brk_args { - char * dsend; char dsend_[PAD_(char *)]; +struct linux_chown_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)]; + char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)]; }; -struct linux_lseek_args { - int fdes; char fdes_[PAD_(int)]; - long off; char off_[PAD_(long)]; - int whence; char whence_[PAD_(int)]; +struct linux_brk_args { + char dsend_l_[PADL_(l_ulong)]; l_ulong dsend; char dsend_r_[PADR_(l_ulong)]; }; -struct linux_umount2_args { - char * path; char path_[PAD_(char *)]; - int flags; char flags_[PAD_(int)]; +struct linux_lseek_args { + char fdes_l_[PADL_(l_uint)]; l_uint fdes; char fdes_r_[PADR_(l_uint)]; + char off_l_[PADL_(l_off_t)]; l_off_t off; char off_r_[PADR_(l_off_t)]; + char whence_l_[PADL_(l_int)]; l_int whence; char whence_r_[PADR_(l_int)]; }; -struct linux_ptrace_args { +struct linux_getpid_args { register_t dummy; }; -struct linux_access_args { - char * path; char path_[PAD_(char *)]; - int flags; char flags_[PAD_(int)]; +struct linux_umount_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; -struct linux_kill_args { - int pid; char pid_[PAD_(int)]; - int signum; char signum_[PAD_(int)]; +struct linux_getuid_args { + register_t dummy; }; -struct linux_open_args { - char * path; char path_[PAD_(char *)]; - int flags; char flags_[PAD_(int)]; - int mode; char mode_[PAD_(int)]; +struct linux_ptrace_args { + register_t dummy; }; -struct osf1_sigprocmask_args { - int how; char how_[PAD_(int)]; - u_long mask; char mask_[PAD_(u_long)]; +struct linux_access_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; -struct linux_ioctl_args { - int fd; char fd_[PAD_(int)]; - u_long cmd; char cmd_[PAD_(u_long)]; - u_long arg; char arg_[PAD_(u_long)]; +struct linux_kill_args { + char pid_l_[PADL_(l_int)]; l_int pid; char pid_r_[PADR_(l_int)]; + char signum_l_[PADL_(l_int)]; l_int signum; char signum_r_[PADR_(l_int)]; }; -struct linux_symlink_args { - char * path; char path_[PAD_(char *)]; - char * to; char to_[PAD_(char *)]; +struct linux_open_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; -struct linux_readlink_args { - char * name; char name_[PAD_(char *)]; - char * buf; char buf_[PAD_(char *)]; - int count; char count_[PAD_(int)]; +struct linux_getgid_args { + register_t dummy; }; -struct linux_execve_args { - char * path; char path_[PAD_(char *)]; - char ** argp; char argp_[PAD_(char **)]; - char ** envp; char envp_[PAD_(char **)]; +struct osf1_sigprocmask_args { + char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; + char mask_l_[PADL_(u_long)]; u_long mask; char mask_r_[PADR_(u_long)]; }; -struct linux_vfork_args { +struct linux_sigpending_args { register_t dummy; }; -struct linux_newstat_args { - char * path; char path_[PAD_(char *)]; - struct linux_newstat * buf; char buf_[PAD_(struct linux_newstat *)]; +struct linux_ioctl_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; }; -struct linux_newlstat_args { - char * path; char path_[PAD_(char *)]; - struct linux_newstat * buf; char buf_[PAD_(struct linux_newstat *)]; +struct linux_symlink_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; -struct linux_mmap_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - size_t len; char len_[PAD_(size_t)]; - int prot; char prot_[PAD_(int)]; - int flags; char flags_[PAD_(int)]; - int fd; char fd_[PAD_(int)]; - off_t pos; char pos_[PAD_(off_t)]; +struct linux_readlink_args { + char name_l_[PADL_(char *)]; char * name; char name_r_[PADR_(char *)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char count_l_[PADL_(l_int)]; l_int count; char count_r_[PADR_(l_int)]; }; -struct linux_munmap_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - u_long len; char len_[PAD_(u_long)]; +struct linux_execve_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char argp_l_[PADL_(char **)]; char ** argp; char argp_r_[PADR_(char **)]; + char envp_l_[PADL_(char **)]; char ** envp; char envp_r_[PADR_(char **)]; }; -struct linux_mprotect_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - size_t len; char len_[PAD_(size_t)]; - int prot; char prot_[PAD_(int)]; +struct linux_getpagesize_args { + register_t dummy; }; -struct linux_vhangup_args { +struct linux_vfork_args { register_t dummy; }; -struct linux_setgroups_args { - u_int gidsetsize; char gidsetsize_[PAD_(u_int)]; - linux_gid_t * gidset; char gidset_[PAD_(linux_gid_t *)]; +struct linux_newstat_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)]; }; -struct linux_getgroups_args { - u_int gidsetsize; char gidsetsize_[PAD_(u_int)]; - linux_gid_t * gidset; char gidset_[PAD_(linux_gid_t *)]; +struct linux_newlstat_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)]; }; -struct linux_setpgid_args { - int pid; char pid_[PAD_(int)]; - int pgid; char pgid_[PAD_(int)]; +struct linux_mmap_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_ulong)]; l_ulong len; char len_r_[PADR_(l_ulong)]; + char prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char pos_l_[PADL_(l_ulong)]; l_ulong pos; char pos_r_[PADR_(l_ulong)]; }; -struct osf1_setitimer_args { - u_int which; char which_[PAD_(u_int)]; - struct itimerval * itv; char itv_[PAD_(struct itimerval *)]; - struct itimerval * oitv; char oitv_[PAD_(struct itimerval *)]; -}; -struct linux_newfstat_args { - int fd; char fd_[PAD_(int)]; - struct linux_newstat * buf; char buf_[PAD_(struct linux_newstat *)]; -}; -struct linux_fcntl_args { - int fd; char fd_[PAD_(int)]; - int cmd; char cmd_[PAD_(int)]; - u_long arg; char arg_[PAD_(u_long)]; -}; -struct osf1_select_args { - u_int nd; char nd_[PAD_(u_int)]; - fd_set * in; char in_[PAD_(fd_set *)]; - fd_set * ou; char ou_[PAD_(fd_set *)]; - fd_set * ex; char ex_[PAD_(fd_set *)]; - struct timeval * tv; char tv_[PAD_(struct timeval *)]; -}; -struct osf1_socket_args { - int domain; char domain_[PAD_(int)]; - int type; char type_[PAD_(int)]; - int protocol; char protocol_[PAD_(int)]; -}; -struct linux_connect_args { - int s; char s_[PAD_(int)]; - caddr_t name; char name_[PAD_(caddr_t)]; - int namelen; char namelen_[PAD_(int)]; -}; -struct osf1_sigreturn_args { - struct osigcontext * sigcntxp; char sigcntxp_[PAD_(struct osigcontext *)]; -}; -struct osf1_sigsuspend_args { - unsigned long ss; char ss_[PAD_(unsigned long)]; -}; -struct osf1_gettimeofday_args { - struct timeval * tp; char tp_[PAD_(struct timeval *)]; - struct timezone * tzp; char tzp_[PAD_(struct timezone *)]; -}; -struct osf1_getrusage_args { - long who; char who_[PAD_(long)]; - void * rusage; char rusage_[PAD_(void *)]; -}; -struct linux_rename_args { - char * from; char from_[PAD_(char *)]; - char * to; char to_[PAD_(char *)]; -}; -struct linux_truncate_args { - char * path; char path_[PAD_(char *)]; - long length; char length_[PAD_(long)]; -}; -struct osf1_sendto_args { - int s; char s_[PAD_(int)]; - caddr_t buf; char buf_[PAD_(caddr_t)]; - size_t len; char len_[PAD_(size_t)]; - int flags; char flags_[PAD_(int)]; - struct sockaddr * to; char to_[PAD_(struct sockaddr *)]; - int tolen; char tolen_[PAD_(int)]; -}; -struct linux_mkdir_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; -}; -struct linux_rmdir_args { - char * path; char path_[PAD_(char *)]; -}; -struct linux_getrlimit_args { - u_int resource; char resource_[PAD_(u_int)]; - struct rlimit * rlim; char rlim_[PAD_(struct rlimit *)]; -}; -struct linux_setrlimit_args { - u_int resource; char resource_[PAD_(u_int)]; - struct rlimit * rlim; char rlim_[PAD_(struct rlimit *)]; -}; -struct linux_quotactl_args { - register_t dummy; -}; -struct osf1_sigaction_args { - int sig; char sig_[PAD_(int)]; - struct osf1_sigaction * nsa; char nsa_[PAD_(struct osf1_sigaction *)]; - struct osf1_sigaction * osa; char osa_[PAD_(struct osf1_sigaction *)]; -}; -struct linux_msgctl_args { - int arg1; char arg1_[PAD_(int)]; - int arg2; char arg2_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; -}; -struct linux_msgget_args { - int arg1; char arg1_[PAD_(int)]; - int arg2; char arg2_[PAD_(int)]; -}; -struct linux_msgrcv_args { - int arg1; char arg1_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; - size_t arg2; char arg2_[PAD_(size_t)]; - long arg3; char arg3_[PAD_(long)]; - int arg4; char arg4_[PAD_(int)]; -}; -struct linux_msgsnd_args { - int arg1; char arg1_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; - size_t arg2; char arg2_[PAD_(size_t)]; - long arg3; char arg3_[PAD_(long)]; - int arg4; char arg4_[PAD_(int)]; -}; -struct linux_semctl_args { - int arg1; char arg1_[PAD_(int)]; - int arg2; char arg2_[PAD_(int)]; - int arg3; char arg3_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; +struct linux_munmap_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; }; -struct linux_semget_args { - int arg1; char arg1_[PAD_(int)]; - int arg2; char arg2_[PAD_(int)]; - int arg3; char arg3_[PAD_(int)]; +struct linux_mprotect_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)]; }; -struct linux_semop_args { - int arg1; char arg1_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; - int arg2; char arg2_[PAD_(int)]; +struct linux_madvise_args { + register_t dummy; }; -struct linux_lchown_args { - char * path; char path_[PAD_(char *)]; - int uid; char uid_[PAD_(int)]; - int gid; char gid_[PAD_(int)]; +struct linux_vhangup_args { + register_t dummy; }; -struct linux_shmat_args { - int arg1; char arg1_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; - int arg2; char arg2_[PAD_(int)]; - caddr_t arg3; char arg3_[PAD_(caddr_t)]; +struct linux_setgroups_args { + char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)]; + char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)]; }; -struct linux_shmctl_args { - int arg1; char arg1_[PAD_(int)]; - int arg2; char arg2_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; +struct linux_getgroups_args { + char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)]; + char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)]; }; -struct linux_shmdt_args { - caddr_t ptr; char ptr_[PAD_(caddr_t)]; +struct linux_setpgid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char pgid_l_[PADL_(l_pid_t)]; l_pid_t pgid; char pgid_r_[PADR_(l_pid_t)]; }; -struct linux_shmget_args { - int arg1; char arg1_[PAD_(int)]; - size_t arg2; char arg2_[PAD_(size_t)]; - int arg3; char arg3_[PAD_(int)]; +struct osf1_setitimer_args { + char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; + char itv_l_[PADL_(struct itimerval *)]; struct itimerval * itv; char itv_r_[PADR_(struct itimerval *)]; + char oitv_l_[PADL_(struct itimerval *)]; struct itimerval * oitv; char oitv_r_[PADR_(struct itimerval *)]; }; -struct linux_msync_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - int len; char len_[PAD_(int)]; - int fl; char fl_[PAD_(int)]; +struct linux_gethostname_args { + register_t dummy; +}; +struct linux_getdtablesize_args { + register_t dummy; }; -struct linux_getpgid_args { - int pid; char pid_[PAD_(int)]; +struct linux_newfstat_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)]; }; -struct linux_getsid_args { - linux_pid_t pid; char pid_[PAD_(linux_pid_t)]; +struct linux_fcntl_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; }; -struct osf1_sysinfo_args { - int cmd; char cmd_[PAD_(int)]; - char * buf; char buf_[PAD_(char *)]; - long count; char count_[PAD_(long)]; +struct osf1_select_args { + char nd_l_[PADL_(u_int)]; u_int nd; char nd_r_[PADR_(u_int)]; + char in_l_[PADL_(fd_set *)]; fd_set * in; char in_r_[PADR_(fd_set *)]; + char ou_l_[PADL_(fd_set *)]; fd_set * ou; char ou_r_[PADR_(fd_set *)]; + char ex_l_[PADL_(fd_set *)]; fd_set * ex; char ex_r_[PADR_(fd_set *)]; + char tv_l_[PADL_(struct timeval *)]; struct timeval * tv; char tv_r_[PADR_(struct timeval *)]; }; -struct linux_sysfs_args { - int option; char option_[PAD_(int)]; - u_long arg1; char arg1_[PAD_(u_long)]; - u_long arg2; char arg2_[PAD_(u_long)]; +struct osf1_socket_args { + char domain_l_[PADL_(int)]; int domain; char domain_r_[PADR_(int)]; + char type_l_[PADL_(int)]; int type; char type_r_[PADR_(int)]; + char protocol_l_[PADL_(int)]; int protocol; char protocol_r_[PADR_(int)]; }; -struct osf1_getsysinfo_args { - u_long op; char op_[PAD_(u_long)]; - caddr_t buffer; char buffer_[PAD_(caddr_t)]; - u_long nbytes; char nbytes_[PAD_(u_long)]; - caddr_t arg; char arg_[PAD_(caddr_t)]; - u_long flag; char flag_[PAD_(u_long)]; +struct linux_connect_args { + char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; + char name_l_[PADL_(struct l_sockaddr *)]; struct l_sockaddr * name; char name_r_[PADR_(struct l_sockaddr *)]; + char namelen_l_[PADL_(l_int)]; l_int namelen; char namelen_r_[PADR_(l_int)]; }; -struct osf1_setsysinfo_args { - u_long op; char op_[PAD_(u_long)]; - caddr_t buffer; char buffer_[PAD_(caddr_t)]; - u_long nbytes; char nbytes_[PAD_(u_long)]; - caddr_t arg; char arg_[PAD_(caddr_t)]; - u_long flag; char flag_[PAD_(u_long)]; +struct osf1_sigreturn_args { + char sigcntxp_l_[PADL_(struct osigcontext *)]; struct osigcontext * sigcntxp; char sigcntxp_r_[PADR_(struct osigcontext *)]; }; -struct linux_afs_syscall_args { +struct osf1_sigsuspend_args { + char ss_l_[PADL_(unsigned long)]; unsigned long ss; char ss_r_[PADR_(unsigned long)]; +}; +struct linux_recvmsg_args { register_t dummy; }; -struct linux_bdflush_args { +struct linux_sendmsg_args { register_t dummy; }; -struct linux_mount_args { - char * specialfile; char specialfile_[PAD_(char *)]; - char * dir; char dir_[PAD_(char *)]; - char * filesystemtype; char filesystemtype_[PAD_(char *)]; - u_long rwflag; char rwflag_[PAD_(u_long)]; - void * data; char data_[PAD_(void *)]; +struct osf1_gettimeofday_args { + char tp_l_[PADL_(struct timeval *)]; struct timeval * tp; char tp_r_[PADR_(struct timeval *)]; + char tzp_l_[PADL_(struct timezone *)]; struct timezone * tzp; char tzp_r_[PADR_(struct timezone *)]; +}; +struct osf1_getrusage_args { + char who_l_[PADL_(long)]; long who; char who_r_[PADR_(long)]; + char rusage_l_[PADL_(void *)]; void * rusage; char rusage_r_[PADR_(void *)]; +}; +struct linux_rename_args { + char from_l_[PADL_(char *)]; char * from; char from_r_[PADR_(char *)]; + char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; +}; +struct linux_truncate_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char length_l_[PADL_(l_ulong)]; l_ulong length; char length_r_[PADR_(l_ulong)]; +}; +struct osf1_sendto_args { + char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; + char buf_l_[PADL_(caddr_t)]; caddr_t buf; char buf_r_[PADR_(caddr_t)]; + char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)]; + char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; + char to_l_[PADL_(struct sockaddr *)]; struct sockaddr * to; char to_r_[PADR_(struct sockaddr *)]; + char tolen_l_[PADL_(int)]; int tolen; char tolen_r_[PADR_(int)]; }; -struct linux_swapoff_args { +struct linux_socketpair_args { register_t dummy; }; -struct linux_getdents_args { - int fd; char fd_[PAD_(int)]; - void * dent; char dent_[PAD_(void *)]; - unsigned count; char count_[PAD_(unsigned)]; +struct linux_mkdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; +}; +struct linux_rmdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; +}; +struct linux_getrlimit_args { + char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)]; + char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)]; +}; +struct linux_setrlimit_args { + char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)]; + char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)]; +}; +struct linux_quotactl_args { + register_t dummy; }; -struct linux_create_module_args { +struct osf1_sigaction_args { + char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)]; + char nsa_l_[PADL_(struct osf1_sigaction *)]; struct osf1_sigaction * nsa; char nsa_r_[PADR_(struct osf1_sigaction *)]; + char osa_l_[PADL_(struct osf1_sigaction *)]; struct osf1_sigaction * osa; char osa_r_[PADR_(struct osf1_sigaction *)]; +}; +struct linux_msgctl_args { + char msqid_l_[PADL_(l_int)]; l_int msqid; char msqid_r_[PADR_(l_int)]; + char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)]; + char buf_l_[PADL_(struct l_msqid_ds *)]; struct l_msqid_ds * buf; char buf_r_[PADR_(struct l_msqid_ds *)]; +}; +struct linux_msgget_args { + char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)]; + char msgflg_l_[PADL_(l_int)]; l_int msgflg; char msgflg_r_[PADR_(l_int)]; +}; +struct linux_msgrcv_args { + char msqid_l_[PADL_(l_int)]; l_int msqid; char msqid_r_[PADR_(l_int)]; + char msgp_l_[PADL_(struct l_msgbuf *)]; struct l_msgbuf * msgp; char msgp_r_[PADR_(struct l_msgbuf *)]; + char msgsz_l_[PADL_(l_size_t)]; l_size_t msgsz; char msgsz_r_[PADR_(l_size_t)]; + char msgtyp_l_[PADL_(l_long)]; l_long msgtyp; char msgtyp_r_[PADR_(l_long)]; + char msgflg_l_[PADL_(l_int)]; l_int msgflg; char msgflg_r_[PADR_(l_int)]; +}; +struct linux_msgsnd_args { + char msqid_l_[PADL_(l_int)]; l_int msqid; char msqid_r_[PADR_(l_int)]; + char msgp_l_[PADL_(struct l_msgbuf *)]; struct l_msgbuf * msgp; char msgp_r_[PADR_(struct l_msgbuf *)]; + char msgsz_l_[PADL_(l_size_t)]; l_size_t msgsz; char msgsz_r_[PADR_(l_size_t)]; + char msgflg_l_[PADL_(l_int)]; l_int msgflg; char msgflg_r_[PADR_(l_int)]; +}; +struct linux_semctl_args { + char semid_l_[PADL_(l_int)]; l_int semid; char semid_r_[PADR_(l_int)]; + char semnum_l_[PADL_(l_int)]; l_int semnum; char semnum_r_[PADR_(l_int)]; + char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)]; + char arg_l_[PADL_(union l_semun)]; union l_semun arg; char arg_r_[PADR_(union l_semun)]; +}; +struct linux_semget_args { + char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)]; + char nsems_l_[PADL_(l_int)]; l_int nsems; char nsems_r_[PADR_(l_int)]; + char semflg_l_[PADL_(l_int)]; l_int semflg; char semflg_r_[PADR_(l_int)]; +}; +struct linux_semop_args { + char semid_l_[PADL_(l_int)]; l_int semid; char semid_r_[PADR_(l_int)]; + char tsops_l_[PADL_(struct l_sembuf *)]; struct l_sembuf * tsops; char tsops_r_[PADR_(struct l_sembuf *)]; + char nsops_l_[PADL_(l_uint)]; l_uint nsops; char nsops_r_[PADR_(l_uint)]; +}; +struct linux_lchown_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)]; + char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)]; +}; +struct linux_shmat_args { + char shmid_l_[PADL_(l_int)]; l_int shmid; char shmid_r_[PADR_(l_int)]; + char shmaddr_l_[PADL_(char *)]; char * shmaddr; char shmaddr_r_[PADR_(char *)]; + char shmflg_l_[PADL_(l_int)]; l_int shmflg; char shmflg_r_[PADR_(l_int)]; +}; +struct linux_shmctl_args { + char shmid_l_[PADL_(l_int)]; l_int shmid; char shmid_r_[PADR_(l_int)]; + char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)]; + char buf_l_[PADL_(struct l_shmid_ds *)]; struct l_shmid_ds * buf; char buf_r_[PADR_(struct l_shmid_ds *)]; +}; +struct linux_shmdt_args { + char shmaddr_l_[PADL_(char *)]; char * shmaddr; char shmaddr_r_[PADR_(char *)]; +}; +struct linux_shmget_args { + char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; + char shmflg_l_[PADL_(l_int)]; l_int shmflg; char shmflg_r_[PADR_(l_int)]; +}; +struct linux_msync_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char fl_l_[PADL_(l_int)]; l_int fl; char fl_r_[PADR_(l_int)]; +}; +struct linux_getpgid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; +}; +struct linux_getsid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; +}; +struct linux_sigaltstack_args { register_t dummy; }; -struct linux_init_module_args { +struct osf1_sysinfo_args { + char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char count_l_[PADL_(long)]; long count; char count_r_[PADR_(long)]; +}; +struct linux_sysfs_args { + char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)]; + char arg1_l_[PADL_(l_ulong)]; l_ulong arg1; char arg1_r_[PADR_(l_ulong)]; + char arg2_l_[PADL_(l_ulong)]; l_ulong arg2; char arg2_r_[PADR_(l_ulong)]; +}; +struct osf1_getsysinfo_args { + char op_l_[PADL_(u_long)]; u_long op; char op_r_[PADR_(u_long)]; + char buffer_l_[PADL_(caddr_t)]; caddr_t buffer; char buffer_r_[PADR_(caddr_t)]; + char nbytes_l_[PADL_(u_long)]; u_long nbytes; char nbytes_r_[PADR_(u_long)]; + char arg_l_[PADL_(caddr_t)]; caddr_t arg; char arg_r_[PADR_(caddr_t)]; + char flag_l_[PADL_(u_long)]; u_long flag; char flag_r_[PADR_(u_long)]; +}; +struct osf1_setsysinfo_args { + char op_l_[PADL_(u_long)]; u_long op; char op_r_[PADR_(u_long)]; + char buffer_l_[PADL_(caddr_t)]; caddr_t buffer; char buffer_r_[PADR_(caddr_t)]; + char nbytes_l_[PADL_(u_long)]; u_long nbytes; char nbytes_r_[PADR_(u_long)]; + char arg_l_[PADL_(caddr_t)]; caddr_t arg; char arg_r_[PADR_(caddr_t)]; + char flag_l_[PADL_(u_long)]; u_long flag; char flag_r_[PADR_(u_long)]; +}; +struct linux_bdflush_args { register_t dummy; }; -struct linux_delete_module_args { +struct linux_sethae_args { register_t dummy; }; -struct linux_get_kernel_syms_args { +struct linux_mount_args { + char specialfile_l_[PADL_(char *)]; char * specialfile; char specialfile_r_[PADR_(char *)]; + char dir_l_[PADL_(char *)]; char * dir; char dir_r_[PADR_(char *)]; + char filesystemtype_l_[PADL_(char *)]; char * filesystemtype; char filesystemtype_r_[PADR_(char *)]; + char rwflag_l_[PADL_(l_ulong)]; l_ulong rwflag; char rwflag_r_[PADR_(l_ulong)]; + char data_l_[PADL_(void *)]; void * data; char data_r_[PADR_(void *)]; +}; +struct linux_old_adjtimex_args { register_t dummy; }; -struct linux_ksyslog_args { - int what; char what_[PAD_(int)]; +struct linux_swapoff_args { + register_t dummy; }; -struct linux_reboot_args { - int magic1; char magic1_[PAD_(int)]; - int magic2; char magic2_[PAD_(int)]; - int opt; char opt_[PAD_(int)]; +struct linux_getdents_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char dent_l_[PADL_(void *)]; void * dent; char dent_r_[PADR_(void *)]; + char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; }; -struct linux_clone_args { - int flags; char flags_[PAD_(int)]; - void * stack; char stack_[PAD_(void *)]; +struct linux_create_module_args { + register_t dummy; }; -struct linux_uselib_args { - char * library; char library_[PAD_(char *)]; +struct linux_init_module_args { + register_t dummy; }; -struct linux_sysinfo_args { +struct linux_delete_module_args { register_t dummy; }; -struct linux_sysctl_args { +struct linux_get_kernel_syms_args { register_t dummy; }; -struct linux_idle_args { +struct linux_syslog_args { + char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)]; +}; +struct linux_reboot_args { + char magic1_l_[PADL_(l_int)]; l_int magic1; char magic1_r_[PADR_(l_int)]; + char magic2_l_[PADL_(l_int)]; l_int magic2; char magic2_r_[PADR_(l_int)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(void *)]; void * arg; char arg_r_[PADR_(void *)]; +}; +struct linux_clone_args { + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; + char stack_l_[PADL_(void *)]; void * stack; char stack_r_[PADR_(void *)]; +}; +struct linux_uselib_args { + char library_l_[PADL_(char *)]; char * library; char library_r_[PADR_(char *)]; +}; +struct linux_sysinfo_args { register_t dummy; }; -struct linux_umount_args { - char * path; char path_[PAD_(char *)]; +struct linux_sysctl_args { + char args_l_[PADL_(struct l___sysctl_args *)]; struct l___sysctl_args * args; char args_r_[PADR_(struct l___sysctl_args *)]; +}; +struct linux_oldumount_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_times_args { - struct linux_times_argv * buf; char buf_[PAD_(struct linux_times_argv *)]; +struct linux_times_args { + char buf_l_[PADL_(struct l_times_argv *)]; struct l_times_argv * buf; char buf_r_[PADR_(struct l_times_argv *)]; }; -struct linux_personality_args { - int per; char per_[PAD_(int)]; +struct linux_personality_args { + char per_l_[PADL_(l_ulong)]; l_ulong per; char per_r_[PADR_(l_ulong)]; }; -struct linux_setfsuid_args { - linux_uid_t uid; char uid_[PAD_(linux_uid_t)]; +struct linux_setfsuid_args { + char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)]; }; -struct linux_setfsgid_args { - linux_gid_t gid; char gid_[PAD_(linux_gid_t)]; +struct linux_setfsgid_args { + char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)]; }; -struct linux_ustat_args { - linux_dev_t dev; char dev_[PAD_(linux_dev_t)]; - struct linux_ustat * ubuf; char ubuf_[PAD_(struct linux_ustat *)]; +struct linux_ustat_args { + char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)]; + char ubuf_l_[PADL_(struct l_ustat *)]; struct l_ustat * ubuf; char ubuf_r_[PADR_(struct l_ustat *)]; }; -struct linux_statfs_args { - char * path; char path_[PAD_(char *)]; - struct linux_statfs_buf * buf; char buf_[PAD_(struct linux_statfs_buf *)]; +struct linux_statfs_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char buf_l_[PADL_(struct l_statfs_buf *)]; struct l_statfs_buf * buf; char buf_r_[PADR_(struct l_statfs_buf *)]; }; -struct linux_fstatfs_args { - int fd; char fd_[PAD_(int)]; - struct linux_statfs_buf * buf; char buf_[PAD_(struct linux_statfs_buf *)]; +struct linux_fstatfs_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(struct l_statfs_buf *)]; struct l_statfs_buf * buf; char buf_r_[PADR_(struct l_statfs_buf *)]; }; -struct linux_sched_setscheduler_args { - pid_t pid; char pid_[PAD_(pid_t)]; - int policy; char policy_[PAD_(int)]; - const struct sched_param * param; char param_[PAD_(const struct sched_param *)]; +struct linux_sched_setscheduler_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)]; + char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)]; }; -struct linux_sched_getscheduler_args { - pid_t pid; char pid_[PAD_(pid_t)]; +struct linux_sched_getscheduler_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; }; -struct linux_sched_get_priority_max_args { - int policy; char policy_[PAD_(int)]; +struct linux_sched_get_priority_max_args { + char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)]; }; -struct linux_sched_get_priority_min_args { - int policy; char policy_[PAD_(int)]; +struct linux_sched_get_priority_min_args { + char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)]; }; -struct linux_newuname_args { - struct linux_newuname_t * buf; char buf_[PAD_(struct linux_newuname_t *)]; +struct linux_newuname_args { + char buf_l_[PADL_(struct l_newuname_t *)]; struct l_newuname_t * buf; char buf_r_[PADR_(struct l_newuname_t *)]; }; -struct linux_mremap_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - u_long old_len; char old_len_[PAD_(u_long)]; - u_long new_len; char new_len_[PAD_(u_long)]; - u_long flags; char flags_[PAD_(u_long)]; +struct linux_mremap_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char old_len_l_[PADL_(l_ulong)]; l_ulong old_len; char old_len_r_[PADR_(l_ulong)]; + char new_len_l_[PADL_(l_ulong)]; l_ulong new_len; char new_len_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; + char new_addr_l_[PADL_(l_ulong)]; l_ulong new_addr; char new_addr_r_[PADR_(l_ulong)]; }; -struct linux_nfsservctl_args { +struct linux_nfsservctl_args { register_t dummy; }; -struct linux_getresgid_args { - linux_gid_t * rgid; char rgid_[PAD_(linux_gid_t *)]; - linux_gid_t * egid; char egid_[PAD_(linux_gid_t *)]; - linux_gid_t * sgid; char sgid_[PAD_(linux_gid_t *)]; +struct linux_pciconfig_read_args { + register_t dummy; }; -struct linux_query_module_args { +struct linux_pciconfig_write_args { register_t dummy; }; -struct linux_prctl_args { +struct linux_query_module_args { register_t dummy; }; -struct linux_pread_args { - int fd; char fd_[PAD_(int)]; - char * buf; char buf_[PAD_(char *)]; - size_t nbyte; char nbyte_[PAD_(size_t)]; - off_t offset; char offset_[PAD_(off_t)]; +struct linux_prctl_args { + register_t dummy; }; -struct linux_pwrite_args { - int fd; char fd_[PAD_(int)]; - const char * buf; char buf_[PAD_(const char *)]; - size_t nbyte; char nbyte_[PAD_(size_t)]; - off_t offset; char offset_[PAD_(off_t)]; +struct linux_pread_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; }; -struct linux_rt_sigreturn_args { +struct linux_pwrite_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; +}; +struct linux_rt_sigreturn_args { register_t dummy; }; -struct linux_rt_sigaction_args { - int sig; char sig_[PAD_(int)]; - linux_sigaction_t * act; char act_[PAD_(linux_sigaction_t *)]; - linux_sigaction_t * oact; char oact_[PAD_(linux_sigaction_t *)]; - size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; +struct linux_rt_sigaction_args { + char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; + char act_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * act; char act_r_[PADR_(l_sigaction_t *)]; + char oact_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * oact; char oact_r_[PADR_(l_sigaction_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; -struct linux_rt_sigprocmask_args { - int how; char how_[PAD_(int)]; - linux_sigset_t * mask; char mask_[PAD_(linux_sigset_t *)]; - linux_sigset_t * omask; char omask_[PAD_(linux_sigset_t *)]; - size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; +struct linux_rt_sigprocmask_args { + char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)]; + char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)]; + char omask_l_[PADL_(l_sigset_t *)]; l_sigset_t * omask; char omask_r_[PADR_(l_sigset_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; -struct linux_rt_sigpending_args { +struct linux_rt_sigpending_args { register_t dummy; }; -struct linux_rt_sigtimedwait_args { +struct linux_rt_sigtimedwait_args { register_t dummy; }; -struct linux_rt_sigqueueinfo_args { +struct linux_rt_sigqueueinfo_args { register_t dummy; }; -struct linux_rt_sigsuspend_args { - linux_sigset_t * newset; char newset_[PAD_(linux_sigset_t *)]; - size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; -}; -struct linux_newselect_args { - int nfds; char nfds_[PAD_(int)]; - fd_set * readfds; char readfds_[PAD_(fd_set *)]; - fd_set * writefds; char writefds_[PAD_(fd_set *)]; - fd_set * exceptfds; char exceptfds_[PAD_(fd_set *)]; - struct timeval * timeout; char timeout_[PAD_(struct timeval *)]; -}; -struct linux_getitimer_args { - u_int which; char which_[PAD_(u_int)]; - struct itimerval * itv; char itv_[PAD_(struct itimerval *)]; +struct linux_rt_sigsuspend_args { + char newset_l_[PADL_(l_sigset_t *)]; l_sigset_t * newset; char newset_r_[PADR_(l_sigset_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; +}; +struct linux_select_args { + char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)]; + char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)]; + char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)]; + char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)]; + char timeout_l_[PADL_(struct l_timeval *)]; struct l_timeval * timeout; char timeout_r_[PADR_(struct l_timeval *)]; +}; +struct linux_getitimer_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)]; +}; +struct linux_setitimer_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)]; + char oitv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * oitv; char oitv_r_[PADR_(struct l_itimerval *)]; +}; +struct linux_utimes_args { + char fname_l_[PADL_(char *)]; char * fname; char fname_r_[PADR_(char *)]; + char times_l_[PADL_(struct l_timeval *)]; struct l_timeval * times; char times_r_[PADR_(struct l_timeval *)]; +}; +struct linux_wait4_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char status_l_[PADL_(l_uint *)]; l_uint * status; char status_r_[PADR_(l_uint *)]; + char options_l_[PADL_(l_int)]; l_int options; char options_r_[PADR_(l_int)]; + char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)]; +}; +struct linux_adjtimex_args { + register_t dummy; }; -struct linux_setitimer_args { - u_int which; char which_[PAD_(u_int)]; - struct itimerval * itv; char itv_[PAD_(struct itimerval *)]; - struct itimerval * oitv; char oitv_[PAD_(struct itimerval *)]; +struct linux_getcwd_args { + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char bufsize_l_[PADL_(l_ulong)]; l_ulong bufsize; char bufsize_r_[PADR_(l_ulong)]; }; -struct linux_utime_args { - char * fname; char fname_[PAD_(char *)]; - struct linux_utimbuf * times; char times_[PAD_(struct linux_utimbuf *)]; +struct linux_capget_args { + register_t dummy; }; -struct linux_wait4_args { - int pid; char pid_[PAD_(int)]; - int * status; char status_[PAD_(int *)]; - int options; char options_[PAD_(int)]; - struct rusage * rusage; char rusage_[PAD_(struct rusage *)]; +struct linux_capset_args { + register_t dummy; }; -struct linux_adjtimex_args { +struct linux_sendfile_args { register_t dummy; }; -struct linux_getcwd_args { - char * buf; char buf_[PAD_(char *)]; - unsigned long bufsize; char bufsize_[PAD_(unsigned long)]; +struct linux_pivot_root_args { + char new_root_l_[PADL_(char *)]; char * new_root; char new_root_r_[PADR_(char *)]; + char put_old_l_[PADL_(char *)]; char * put_old; char put_old_r_[PADR_(char *)]; }; -struct linux_capget_args { - register_t dummy; +struct linux_mincore_args { + char start_l_[PADL_(l_ulong)]; l_ulong start; char start_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char vec_l_[PADL_(u_char *)]; u_char * vec; char vec_r_[PADR_(u_char *)]; }; -struct linux_capset_args { +struct linux_pciconfig_iobase_args { register_t dummy; }; -struct linux_sendfile_args { - register_t dummy; +struct linux_getdents64_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char dirent_l_[PADL_(void *)]; void * dirent; char dirent_r_[PADR_(void *)]; + char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; }; int linux_fork __P((struct proc *, struct linux_fork_args *)); int osf1_wait4 __P((struct proc *, struct osf1_wait4_args *)); @@ -540,27 +604,35 @@ int linux_chmod __P((struct proc *, struct linux_chmod_args *)); int linux_chown __P((struct proc *, struct linux_chown_args *)); int linux_brk __P((struct proc *, struct linux_brk_args *)); int linux_lseek __P((struct proc *, struct linux_lseek_args *)); -int linux_umount2 __P((struct proc *, struct linux_umount2_args *)); +int linux_getpid __P((struct proc *, struct linux_getpid_args *)); +int linux_umount __P((struct proc *, struct linux_umount_args *)); +int linux_getuid __P((struct proc *, struct linux_getuid_args *)); int linux_ptrace __P((struct proc *, struct linux_ptrace_args *)); int linux_access __P((struct proc *, struct linux_access_args *)); int linux_kill __P((struct proc *, struct linux_kill_args *)); int linux_open __P((struct proc *, struct linux_open_args *)); +int linux_getgid __P((struct proc *, struct linux_getgid_args *)); int osf1_sigprocmask __P((struct proc *, struct osf1_sigprocmask_args *)); +int linux_sigpending __P((struct proc *, struct linux_sigpending_args *)); int linux_ioctl __P((struct proc *, struct linux_ioctl_args *)); int linux_symlink __P((struct proc *, struct linux_symlink_args *)); int linux_readlink __P((struct proc *, struct linux_readlink_args *)); int linux_execve __P((struct proc *, struct linux_execve_args *)); +int linux_getpagesize __P((struct proc *, struct linux_getpagesize_args *)); int linux_vfork __P((struct proc *, struct linux_vfork_args *)); int linux_newstat __P((struct proc *, struct linux_newstat_args *)); int linux_newlstat __P((struct proc *, struct linux_newlstat_args *)); int linux_mmap __P((struct proc *, struct linux_mmap_args *)); int linux_munmap __P((struct proc *, struct linux_munmap_args *)); int linux_mprotect __P((struct proc *, struct linux_mprotect_args *)); +int linux_madvise __P((struct proc *, struct linux_madvise_args *)); int linux_vhangup __P((struct proc *, struct linux_vhangup_args *)); int linux_setgroups __P((struct proc *, struct linux_setgroups_args *)); int linux_getgroups __P((struct proc *, struct linux_getgroups_args *)); int linux_setpgid __P((struct proc *, struct linux_setpgid_args *)); int osf1_setitimer __P((struct proc *, struct osf1_setitimer_args *)); +int linux_gethostname __P((struct proc *, struct linux_gethostname_args *)); +int linux_getdtablesize __P((struct proc *, struct linux_getdtablesize_args *)); int linux_newfstat __P((struct proc *, struct linux_newfstat_args *)); int linux_fcntl __P((struct proc *, struct linux_fcntl_args *)); int osf1_select __P((struct proc *, struct osf1_select_args *)); @@ -568,11 +640,14 @@ int osf1_socket __P((struct proc *, struct osf1_socket_args *)); int linux_connect __P((struct proc *, struct linux_connect_args *)); int osf1_sigreturn __P((struct proc *, struct osf1_sigreturn_args *)); int osf1_sigsuspend __P((struct proc *, struct osf1_sigsuspend_args *)); +int linux_recvmsg __P((struct proc *, struct linux_recvmsg_args *)); +int linux_sendmsg __P((struct proc *, struct linux_sendmsg_args *)); int osf1_gettimeofday __P((struct proc *, struct osf1_gettimeofday_args *)); int osf1_getrusage __P((struct proc *, struct osf1_getrusage_args *)); int linux_rename __P((struct proc *, struct linux_rename_args *)); int linux_truncate __P((struct proc *, struct linux_truncate_args *)); int osf1_sendto __P((struct proc *, struct osf1_sendto_args *)); +int linux_socketpair __P((struct proc *, struct linux_socketpair_args *)); int linux_mkdir __P((struct proc *, struct linux_mkdir_args *)); int linux_rmdir __P((struct proc *, struct linux_rmdir_args *)); int linux_getrlimit __P((struct proc *, struct linux_getrlimit_args *)); @@ -594,27 +669,28 @@ int linux_shmget __P((struct proc *, struct linux_shmget_args *)); int linux_msync __P((struct proc *, struct linux_msync_args *)); int linux_getpgid __P((struct proc *, struct linux_getpgid_args *)); int linux_getsid __P((struct proc *, struct linux_getsid_args *)); +int linux_sigaltstack __P((struct proc *, struct linux_sigaltstack_args *)); int osf1_sysinfo __P((struct proc *, struct osf1_sysinfo_args *)); int linux_sysfs __P((struct proc *, struct linux_sysfs_args *)); int osf1_getsysinfo __P((struct proc *, struct osf1_getsysinfo_args *)); int osf1_setsysinfo __P((struct proc *, struct osf1_setsysinfo_args *)); -int linux_afs_syscall __P((struct proc *, struct linux_afs_syscall_args *)); int linux_bdflush __P((struct proc *, struct linux_bdflush_args *)); +int linux_sethae __P((struct proc *, struct linux_sethae_args *)); int linux_mount __P((struct proc *, struct linux_mount_args *)); +int linux_old_adjtimex __P((struct proc *, struct linux_old_adjtimex_args *)); int linux_swapoff __P((struct proc *, struct linux_swapoff_args *)); int linux_getdents __P((struct proc *, struct linux_getdents_args *)); int linux_create_module __P((struct proc *, struct linux_create_module_args *)); int linux_init_module __P((struct proc *, struct linux_init_module_args *)); int linux_delete_module __P((struct proc *, struct linux_delete_module_args *)); int linux_get_kernel_syms __P((struct proc *, struct linux_get_kernel_syms_args *)); -int linux_ksyslog __P((struct proc *, struct linux_ksyslog_args *)); +int linux_syslog __P((struct proc *, struct linux_syslog_args *)); int linux_reboot __P((struct proc *, struct linux_reboot_args *)); int linux_clone __P((struct proc *, struct linux_clone_args *)); int linux_uselib __P((struct proc *, struct linux_uselib_args *)); int linux_sysinfo __P((struct proc *, struct linux_sysinfo_args *)); int linux_sysctl __P((struct proc *, struct linux_sysctl_args *)); -int linux_idle __P((struct proc *, struct linux_idle_args *)); -int linux_umount __P((struct proc *, struct linux_umount_args *)); +int linux_oldumount __P((struct proc *, struct linux_oldumount_args *)); int linux_times __P((struct proc *, struct linux_times_args *)); int linux_personality __P((struct proc *, struct linux_personality_args *)); int linux_setfsuid __P((struct proc *, struct linux_setfsuid_args *)); @@ -629,7 +705,8 @@ int linux_sched_get_priority_min __P((struct proc *, struct linux_sched_get_prio int linux_newuname __P((struct proc *, struct linux_newuname_args *)); int linux_mremap __P((struct proc *, struct linux_mremap_args *)); int linux_nfsservctl __P((struct proc *, struct linux_nfsservctl_args *)); -int linux_getresgid __P((struct proc *, struct linux_getresgid_args *)); +int linux_pciconfig_read __P((struct proc *, struct linux_pciconfig_read_args *)); +int linux_pciconfig_write __P((struct proc *, struct linux_pciconfig_write_args *)); int linux_query_module __P((struct proc *, struct linux_query_module_args *)); int linux_prctl __P((struct proc *, struct linux_prctl_args *)); int linux_pread __P((struct proc *, struct linux_pread_args *)); @@ -641,16 +718,20 @@ int linux_rt_sigpending __P((struct proc *, struct linux_rt_sigpending_args *)); int linux_rt_sigtimedwait __P((struct proc *, struct linux_rt_sigtimedwait_args *)); int linux_rt_sigqueueinfo __P((struct proc *, struct linux_rt_sigqueueinfo_args *)); int linux_rt_sigsuspend __P((struct proc *, struct linux_rt_sigsuspend_args *)); -int linux_newselect __P((struct proc *, struct linux_newselect_args *)); +int linux_select __P((struct proc *, struct linux_select_args *)); int linux_getitimer __P((struct proc *, struct linux_getitimer_args *)); int linux_setitimer __P((struct proc *, struct linux_setitimer_args *)); -int linux_utime __P((struct proc *, struct linux_utime_args *)); +int linux_utimes __P((struct proc *, struct linux_utimes_args *)); int linux_wait4 __P((struct proc *, struct linux_wait4_args *)); int linux_adjtimex __P((struct proc *, struct linux_adjtimex_args *)); int linux_getcwd __P((struct proc *, struct linux_getcwd_args *)); int linux_capget __P((struct proc *, struct linux_capget_args *)); int linux_capset __P((struct proc *, struct linux_capset_args *)); int linux_sendfile __P((struct proc *, struct linux_sendfile_args *)); +int linux_pivot_root __P((struct proc *, struct linux_pivot_root_args *)); +int linux_mincore __P((struct proc *, struct linux_mincore_args *)); +int linux_pciconfig_iobase __P((struct proc *, struct linux_pciconfig_iobase_args *)); +int linux_getdents64 __P((struct proc *, struct linux_getdents64_args *)); #ifdef COMPAT_43 @@ -658,5 +739,7 @@ int linux_sendfile __P((struct proc *, struct linux_sendfile_args *)); #endif /* COMPAT_43 */ #undef PAD_ +#undef PADL_ +#undef PADR_ #endif /* !_LINUX_SYSPROTO_H_ */ diff --git a/sys/alpha/linux/linux_syscall.h b/sys/alpha/linux/linux_syscall.h index 6a6de7f..b2c1b28 100644 --- a/sys/alpha/linux/linux_syscall.h +++ b/sys/alpha/linux/linux_syscall.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/alpha/linux/syscalls.master,v 1.45 2001/02/20 03:47:59 gallatin Exp + * created from FreeBSD: src/sys/alpha/linux/syscalls.master,v 1.48 2001/09/08 18:49:31 marcel Exp */ #define LINUX_SYS_exit 1 @@ -21,10 +21,10 @@ #define LINUX_SYS_linux_chown 16 #define LINUX_SYS_linux_brk 17 #define LINUX_SYS_linux_lseek 19 -#define LINUX_SYS_getpid 20 -#define LINUX_SYS_linux_umount2 22 +#define LINUX_SYS_linux_getpid 20 +#define LINUX_SYS_linux_umount 22 #define LINUX_SYS_setuid 23 -#define LINUX_SYS_getuid 24 +#define LINUX_SYS_linux_getuid 24 #define LINUX_SYS_linux_ptrace 26 #define LINUX_SYS_linux_access 33 #define LINUX_SYS_sync 36 @@ -33,9 +33,10 @@ #define LINUX_SYS_dup 41 #define LINUX_SYS_pipe 42 #define LINUX_SYS_linux_open 45 -#define LINUX_SYS_getgid 47 +#define LINUX_SYS_linux_getgid 47 #define LINUX_SYS_osf1_sigprocmask 48 #define LINUX_SYS_acct 51 +#define LINUX_SYS_linux_sigpending 52 #define LINUX_SYS_linux_ioctl 54 #define LINUX_SYS_linux_symlink 57 #define LINUX_SYS_linux_readlink 58 @@ -43,18 +44,22 @@ #define LINUX_SYS_umask 60 #define LINUX_SYS_chroot 61 #define LINUX_SYS_getpgrp 63 +#define LINUX_SYS_linux_getpagesize 64 #define LINUX_SYS_linux_vfork 66 #define LINUX_SYS_linux_newstat 67 #define LINUX_SYS_linux_newlstat 68 #define LINUX_SYS_linux_mmap 71 #define LINUX_SYS_linux_munmap 73 #define LINUX_SYS_linux_mprotect 74 +#define LINUX_SYS_linux_madvise 75 #define LINUX_SYS_linux_vhangup 76 #define LINUX_SYS_linux_setgroups 79 #define LINUX_SYS_linux_getgroups 80 #define LINUX_SYS_linux_setpgid 82 #define LINUX_SYS_osf1_setitimer 83 +#define LINUX_SYS_linux_gethostname 87 #define LINUX_SYS_osethostname 88 +#define LINUX_SYS_linux_getdtablesize 89 #define LINUX_SYS_dup2 90 #define LINUX_SYS_linux_newfstat 91 #define LINUX_SYS_linux_fcntl 92 @@ -72,6 +77,8 @@ #define LINUX_SYS_setsockopt 105 #define LINUX_SYS_listen 106 #define LINUX_SYS_osf1_sigsuspend 111 +#define LINUX_SYS_linux_recvmsg 113 +#define LINUX_SYS_linux_sendmsg 114 #define LINUX_SYS_osf1_gettimeofday 116 #define LINUX_SYS_osf1_getrusage 117 #define LINUX_SYS_getsockopt 118 @@ -89,6 +96,7 @@ #define LINUX_SYS_setgid 132 #define LINUX_SYS_osf1_sendto 133 #define LINUX_SYS_shutdown 134 +#define LINUX_SYS_linux_socketpair 135 #define LINUX_SYS_linux_mkdir 136 #define LINUX_SYS_linux_rmdir 137 #define LINUX_SYS_utimes 138 @@ -115,20 +123,22 @@ #define LINUX_SYS_linux_msync 217 #define LINUX_SYS_linux_getpgid 233 #define LINUX_SYS_linux_getsid 234 +#define LINUX_SYS_linux_sigaltstack 235 #define LINUX_SYS_osf1_sysinfo 241 -#define LINUX_SYS_linux_sysfs 255 +#define LINUX_SYS_linux_sysfs 254 #define LINUX_SYS_osf1_getsysinfo 256 #define LINUX_SYS_osf1_setsysinfo 257 -#define LINUX_SYS_linux_afs_syscall 258 #define LINUX_SYS_linux_bdflush 300 +#define LINUX_SYS_linux_sethae 301 #define LINUX_SYS_linux_mount 302 +#define LINUX_SYS_linux_old_adjtimex 303 #define LINUX_SYS_linux_swapoff 304 #define LINUX_SYS_linux_getdents 305 #define LINUX_SYS_linux_create_module 306 #define LINUX_SYS_linux_init_module 307 #define LINUX_SYS_linux_delete_module 308 #define LINUX_SYS_linux_get_kernel_syms 309 -#define LINUX_SYS_linux_ksyslog 310 +#define LINUX_SYS_linux_syslog 310 #define LINUX_SYS_linux_reboot 311 #define LINUX_SYS_linux_clone 312 #define LINUX_SYS_linux_uselib 313 @@ -138,8 +148,7 @@ #define LINUX_SYS_munlockall 317 #define LINUX_SYS_linux_sysinfo 318 #define LINUX_SYS_linux_sysctl 319 -#define LINUX_SYS_linux_idle 320 -#define LINUX_SYS_linux_umount 321 +#define LINUX_SYS_linux_oldumount 321 #define LINUX_SYS_swapon 322 #define LINUX_SYS_linux_times 323 #define LINUX_SYS_linux_personality 324 @@ -160,8 +169,10 @@ #define LINUX_SYS_nanosleep 340 #define LINUX_SYS_linux_mremap 341 #define LINUX_SYS_linux_nfsservctl 342 -#define LINUX_SYS_setresgid 343 -#define LINUX_SYS_linux_getresgid 344 +#define LINUX_SYS_setresuid 343 +#define LINUX_SYS_getresuid 344 +#define LINUX_SYS_linux_pciconfig_read 345 +#define LINUX_SYS_linux_pciconfig_write 346 #define LINUX_SYS_linux_query_module 347 #define LINUX_SYS_linux_prctl 348 #define LINUX_SYS_linux_pread 349 @@ -173,12 +184,12 @@ #define LINUX_SYS_linux_rt_sigtimedwait 355 #define LINUX_SYS_linux_rt_sigqueueinfo 356 #define LINUX_SYS_linux_rt_sigsuspend 357 -#define LINUX_SYS_linux_newselect 358 +#define LINUX_SYS_linux_select 358 #define LINUX_SYS_gettimeofday 359 #define LINUX_SYS_settimeofday 360 #define LINUX_SYS_linux_getitimer 361 #define LINUX_SYS_linux_setitimer 362 -#define LINUX_SYS_linux_utime 363 +#define LINUX_SYS_linux_utimes 363 #define LINUX_SYS_getrusage 364 #define LINUX_SYS_linux_wait4 365 #define LINUX_SYS_linux_adjtimex 366 @@ -186,4 +197,10 @@ #define LINUX_SYS_linux_capget 368 #define LINUX_SYS_linux_capset 369 #define LINUX_SYS_linux_sendfile 370 -#define LINUX_SYS_MAXSYSCALL 371 +#define LINUX_SYS_setresgid 371 +#define LINUX_SYS_getresgid 372 +#define LINUX_SYS_linux_pivot_root 374 +#define LINUX_SYS_linux_mincore 375 +#define LINUX_SYS_linux_pciconfig_iobase 376 +#define LINUX_SYS_linux_getdents64 377 +#define LINUX_SYS_MAXSYSCALL 378 diff --git a/sys/alpha/linux/linux_sysent.c b/sys/alpha/linux/linux_sysent.c index 04d2185..c6f87bf 100644 --- a/sys/alpha/linux/linux_sysent.c +++ b/sys/alpha/linux/linux_sysent.c @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/alpha/linux/syscalls.master,v 1.45 2001/02/20 03:47:59 gallatin Exp + * created from FreeBSD: src/sys/alpha/linux/syscalls.master,v 1.48 2001/09/08 18:49:31 marcel Exp */ #include "opt_compat.h" @@ -18,8 +18,8 @@ /* The casts are bogus but will do for now. */ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 0 = */ - { AS(sys_exit_args), (sy_call_t *)sys_exit }, /* 1 = exit */ - { 0, (sy_call_t *)linux_fork }, /* 2 = linux_fork */ + { SYF_MPSAFE | AS(sys_exit_args), (sy_call_t *)sys_exit }, /* 1 = exit */ + { SYF_MPSAFE | 0, (sy_call_t *)linux_fork }, /* 2 = linux_fork */ { AS(read_args), (sy_call_t *)read }, /* 3 = read */ { AS(write_args), (sy_call_t *)write }, /* 4 = write */ { 0, (sy_call_t *)nosys }, /* 5 = */ @@ -37,11 +37,11 @@ struct sysent linux_sysent[] = { { AS(linux_brk_args), (sy_call_t *)linux_brk }, /* 17 = linux_brk */ { 0, (sy_call_t *)nosys }, /* 18 = */ { AS(linux_lseek_args), (sy_call_t *)linux_lseek }, /* 19 = linux_lseek */ - { 0, (sy_call_t *)getpid }, /* 20 = getpid */ + { 0, (sy_call_t *)linux_getpid }, /* 20 = linux_getpid */ { 0, (sy_call_t *)nosys }, /* 21 = osf1_mount */ - { AS(linux_umount2_args), (sy_call_t *)linux_umount2 }, /* 22 = linux_umount2 */ + { AS(linux_umount_args), (sy_call_t *)linux_umount }, /* 22 = linux_umount */ { AS(setuid_args), (sy_call_t *)setuid }, /* 23 = setuid */ - { 0, (sy_call_t *)getuid }, /* 24 = getuid */ + { 0, (sy_call_t *)linux_getuid }, /* 24 = linux_getuid */ { 0, (sy_call_t *)nosys }, /* 25 = */ { 0, (sy_call_t *)linux_ptrace }, /* 26 = linux_ptrace */ { 0, (sy_call_t *)nosys }, /* 27 = */ @@ -60,16 +60,16 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 40 = */ { AS(dup_args), (sy_call_t *)dup }, /* 41 = dup */ { 0, (sy_call_t *)pipe }, /* 42 = pipe */ - { 0, (sy_call_t *)nosys }, /* 43 = */ + { 0, (sy_call_t *)nosys }, /* 43 = osf_set_program_attributes */ { 0, (sy_call_t *)nosys }, /* 44 = */ { AS(linux_open_args), (sy_call_t *)linux_open }, /* 45 = linux_open */ { 0, (sy_call_t *)nosys }, /* 46 = */ - { 0, (sy_call_t *)getgid }, /* 47 = getgid */ + { 0, (sy_call_t *)linux_getgid }, /* 47 = linux_getgid */ { AS(osf1_sigprocmask_args), (sy_call_t *)osf1_sigprocmask }, /* 48 = osf1_sigprocmask */ { 0, (sy_call_t *)nosys }, /* 49 = */ { 0, (sy_call_t *)nosys }, /* 50 = */ { AS(acct_args), (sy_call_t *)acct }, /* 51 = acct */ - { 0, (sy_call_t *)nosys }, /* 52 = sigpending */ + { 0, (sy_call_t *)linux_sigpending }, /* 52 = linux_sigpending */ { 0, (sy_call_t *)nosys }, /* 53 = */ { AS(linux_ioctl_args), (sy_call_t *)linux_ioctl }, /* 54 = linux_ioctl */ { 0, (sy_call_t *)nosys }, /* 55 = */ @@ -81,9 +81,9 @@ struct sysent linux_sysent[] = { { AS(chroot_args), (sy_call_t *)chroot }, /* 61 = chroot */ { 0, (sy_call_t *)nosys }, /* 62 = */ { 0, (sy_call_t *)getpgrp }, /* 63 = getpgrp */ - { 0, (sy_call_t *)nosys }, /* 64 = getpagesize */ + { 0, (sy_call_t *)linux_getpagesize }, /* 64 = linux_getpagesize */ { 0, (sy_call_t *)nosys }, /* 65 = */ - { 0, (sy_call_t *)linux_vfork }, /* 66 = linux_vfork */ + { SYF_MPSAFE | 0, (sy_call_t *)linux_vfork }, /* 66 = linux_vfork */ { AS(linux_newstat_args), (sy_call_t *)linux_newstat }, /* 67 = linux_newstat */ { AS(linux_newlstat_args), (sy_call_t *)linux_newlstat }, /* 68 = linux_newlstat */ { 0, (sy_call_t *)nosys }, /* 69 = */ @@ -92,7 +92,7 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 72 = */ { AS(linux_munmap_args), (sy_call_t *)linux_munmap }, /* 73 = linux_munmap */ { AS(linux_mprotect_args), (sy_call_t *)linux_mprotect }, /* 74 = linux_mprotect */ - { 0, (sy_call_t *)nosys }, /* 75 = madvise */ + { 0, (sy_call_t *)linux_madvise }, /* 75 = linux_madvise */ { 0, (sy_call_t *)linux_vhangup }, /* 76 = linux_vhangup */ { 0, (sy_call_t *)nosys }, /* 77 = */ { 0, (sy_call_t *)nosys }, /* 78 = */ @@ -103,10 +103,10 @@ struct sysent linux_sysent[] = { { AS(osf1_setitimer_args), (sy_call_t *)osf1_setitimer }, /* 83 = osf1_setitimer */ { 0, (sy_call_t *)nosys }, /* 84 = */ { 0, (sy_call_t *)nosys }, /* 85 = */ - { 0, (sy_call_t *)nosys }, /* 86 = */ - { 0, (sy_call_t *)nosys }, /* 87 = gethostname */ - { AS(sethostname_args), (sy_call_t *)osethostname }, /* 88 = osethostname */ - { 0, (sy_call_t *)nosys }, /* 89 = getdtablesize */ + { 0, (sy_call_t *)nosys }, /* 86 = osf_getitimer */ + { 0, (sy_call_t *)linux_gethostname }, /* 87 = linux_gethostname */ + { SYF_MPSAFE | AS(sethostname_args), (sy_call_t *)osethostname }, /* 88 = osethostname */ + { 0, (sy_call_t *)linux_getdtablesize }, /* 89 = linux_getdtablesize */ { AS(dup2_args), (sy_call_t *)dup2 }, /* 90 = dup2 */ { AS(linux_newfstat_args), (sy_call_t *)linux_newfstat }, /* 91 = linux_newfstat */ { AS(linux_fcntl_args), (sy_call_t *)linux_fcntl }, /* 92 = linux_fcntl */ @@ -117,7 +117,7 @@ struct sysent linux_sysent[] = { { AS(osf1_socket_args), (sy_call_t *)osf1_socket }, /* 97 = osf1_socket */ { AS(linux_connect_args), (sy_call_t *)linux_connect }, /* 98 = linux_connect */ { AS(accept_args), (sy_call_t *)oaccept }, /* 99 = accept */ - { 0, (sy_call_t *)nosys }, /* 100 = */ + { 0, (sy_call_t *)nosys }, /* 100 = osf_getpriority */ { AS(osend_args), (sy_call_t *)osend }, /* 101 = osend */ { AS(orecv_args), (sy_call_t *)orecv }, /* 102 = orecv */ { AS(osf1_sigreturn_args), (sy_call_t *)osf1_sigreturn }, /* 103 = osf1_sigreturn */ @@ -129,9 +129,9 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 109 = */ { 0, (sy_call_t *)nosys }, /* 110 = */ { AS(osf1_sigsuspend_args), (sy_call_t *)osf1_sigsuspend }, /* 111 = osf1_sigsuspend */ - { 0, (sy_call_t *)nosys }, /* 112 = */ - { 0, (sy_call_t *)nosys }, /* 113 = recvmsg */ - { 0, (sy_call_t *)nosys }, /* 114 = sendmsg */ + { 0, (sy_call_t *)nosys }, /* 112 = osf_sigstack */ + { 0, (sy_call_t *)linux_recvmsg }, /* 113 = linux_recvmsg */ + { 0, (sy_call_t *)linux_sendmsg }, /* 114 = linux_sendmsg */ { 0, (sy_call_t *)nosys }, /* 115 = */ { AS(osf1_gettimeofday_args), (sy_call_t *)osf1_gettimeofday }, /* 116 = osf1_gettimeofday */ { AS(osf1_getrusage_args), (sy_call_t *)osf1_getrusage }, /* 117 = osf1_getrusage */ @@ -139,7 +139,7 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 119 = */ { AS(readv_args), (sy_call_t *)readv }, /* 120 = readv */ { AS(writev_args), (sy_call_t *)writev }, /* 121 = writev */ - { 0, (sy_call_t *)nosys }, /* 122 = */ + { 0, (sy_call_t *)nosys }, /* 122 = osf_settimeofday */ { AS(fchown_args), (sy_call_t *)fchown }, /* 123 = fchown */ { AS(fchmod_args), (sy_call_t *)fchmod }, /* 124 = fchmod */ { AS(recvfrom_args), (sy_call_t *)orecvfrom }, /* 125 = recvfrom */ @@ -152,7 +152,7 @@ struct sysent linux_sysent[] = { { AS(setgid_args), (sy_call_t *)setgid }, /* 132 = setgid */ { AS(osf1_sendto_args), (sy_call_t *)osf1_sendto }, /* 133 = osf1_sendto */ { AS(shutdown_args), (sy_call_t *)shutdown }, /* 134 = shutdown */ - { 0, (sy_call_t *)nosys }, /* 135 = socketpair */ + { 0, (sy_call_t *)linux_socketpair }, /* 135 = linux_socketpair */ { AS(linux_mkdir_args), (sy_call_t *)linux_mkdir }, /* 136 = linux_mkdir */ { AS(linux_rmdir_args), (sy_call_t *)linux_rmdir }, /* 137 = linux_rmdir */ { AS(utimes_args), (sy_call_t *)utimes }, /* 138 = utimes */ @@ -176,14 +176,14 @@ struct sysent linux_sysent[] = { { AS(osf1_sigaction_args), (sy_call_t *)osf1_sigaction }, /* 156 = osf1_sigaction */ { 0, (sy_call_t *)nosys }, /* 157 = */ { 0, (sy_call_t *)nosys }, /* 158 = */ - { 0, (sy_call_t *)nosys }, /* 159 = */ - { 0, (sy_call_t *)nosys }, /* 160 = */ - { 0, (sy_call_t *)nosys }, /* 161 = */ + { 0, (sy_call_t *)nosys }, /* 159 = osf_getdirentries */ + { 0, (sy_call_t *)nosys }, /* 160 = osf_statfs */ + { 0, (sy_call_t *)nosys }, /* 161 = osf_fstatfs */ { 0, (sy_call_t *)nosys }, /* 162 = */ { 0, (sy_call_t *)nosys }, /* 163 = */ { 0, (sy_call_t *)nosys }, /* 164 = */ - { 0, (sy_call_t *)nosys }, /* 165 = */ - { AS(setdomainname_args), (sy_call_t *)setdomainname }, /* 166 = setdomainname */ + { 0, (sy_call_t *)nosys }, /* 165 = osf_getdomainname */ + { SYF_MPSAFE | AS(setdomainname_args), (sy_call_t *)setdomainname }, /* 166 = setdomainname */ { 0, (sy_call_t *)nosys }, /* 167 = */ { 0, (sy_call_t *)nosys }, /* 168 = */ { 0, (sy_call_t *)nosys }, /* 169 = */ @@ -216,7 +216,7 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 196 = */ { 0, (sy_call_t *)nosys }, /* 197 = */ { 0, (sy_call_t *)nosys }, /* 198 = */ - { 0, (sy_call_t *)nosys }, /* 199 = */ + { 0, (sy_call_t *)nosys }, /* 199 = osf_swapon */ { AS(linux_msgctl_args), (sy_call_t *)linux_msgctl }, /* 200 = linux_msgctl */ { AS(linux_msgget_args), (sy_call_t *)linux_msgget }, /* 201 = linux_msgget */ { AS(linux_msgrcv_args), (sy_call_t *)linux_msgrcv }, /* 202 = linux_msgrcv */ @@ -224,7 +224,7 @@ struct sysent linux_sysent[] = { { AS(linux_semctl_args), (sy_call_t *)linux_semctl }, /* 204 = linux_semctl */ { AS(linux_semget_args), (sy_call_t *)linux_semget }, /* 205 = linux_semget */ { AS(linux_semop_args), (sy_call_t *)linux_semop }, /* 206 = linux_semop */ - { 0, (sy_call_t *)nosys }, /* 207 = */ + { 0, (sy_call_t *)nosys }, /* 207 = osf_utsname */ { AS(linux_lchown_args), (sy_call_t *)linux_lchown }, /* 208 = linux_lchown */ { AS(linux_shmat_args), (sy_call_t *)linux_shmat }, /* 209 = linux_shmat */ { AS(linux_shmctl_args), (sy_call_t *)linux_shmctl }, /* 210 = linux_shmctl */ @@ -252,7 +252,7 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 232 = */ { AS(linux_getpgid_args), (sy_call_t *)linux_getpgid }, /* 233 = linux_getpgid */ { AS(linux_getsid_args), (sy_call_t *)linux_getsid }, /* 234 = linux_getsid */ - { 0, (sy_call_t *)nosys }, /* 235 = sigaltstack */ + { 0, (sy_call_t *)linux_sigaltstack }, /* 235 = linux_sigaltstack */ { 0, (sy_call_t *)nosys }, /* 236 = */ { 0, (sy_call_t *)nosys }, /* 237 = */ { 0, (sy_call_t *)nosys }, /* 238 = */ @@ -261,21 +261,21 @@ struct sysent linux_sysent[] = { { AS(osf1_sysinfo_args), (sy_call_t *)osf1_sysinfo }, /* 241 = osf1_sysinfo */ { 0, (sy_call_t *)nosys }, /* 242 = */ { 0, (sy_call_t *)nosys }, /* 243 = */ - { 0, (sy_call_t *)nosys }, /* 244 = */ + { 0, (sy_call_t *)nosys }, /* 244 = osf_proplist_syscall */ { 0, (sy_call_t *)nosys }, /* 245 = */ { 0, (sy_call_t *)nosys }, /* 246 = */ { 0, (sy_call_t *)nosys }, /* 247 = */ { 0, (sy_call_t *)nosys }, /* 248 = */ { 0, (sy_call_t *)nosys }, /* 249 = */ { 0, (sy_call_t *)nosys }, /* 250 = */ - { 0, (sy_call_t *)nosys }, /* 251 = */ + { 0, (sy_call_t *)nosys }, /* 251 = osf_usleep_thread */ { 0, (sy_call_t *)nosys }, /* 252 = */ { 0, (sy_call_t *)nosys }, /* 253 = */ - { 0, (sy_call_t *)nosys }, /* 254 = */ - { AS(linux_sysfs_args), (sy_call_t *)linux_sysfs }, /* 255 = linux_sysfs */ + { AS(linux_sysfs_args), (sy_call_t *)linux_sysfs }, /* 254 = linux_sysfs */ + { 0, (sy_call_t *)nosys }, /* 255 = */ { AS(osf1_getsysinfo_args), (sy_call_t *)osf1_getsysinfo }, /* 256 = osf1_getsysinfo */ { AS(osf1_setsysinfo_args), (sy_call_t *)osf1_setsysinfo }, /* 257 = osf1_setsysinfo */ - { 0, (sy_call_t *)linux_afs_syscall }, /* 258 = linux_afs_syscall */ + { 0, (sy_call_t *)nosys }, /* 258 = */ { 0, (sy_call_t *)nosys }, /* 259 = */ { 0, (sy_call_t *)nosys }, /* 260 = */ { 0, (sy_call_t *)nosys }, /* 261 = */ @@ -318,16 +318,16 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)nosys }, /* 298 = */ { 0, (sy_call_t *)nosys }, /* 299 = */ { 0, (sy_call_t *)linux_bdflush }, /* 300 = linux_bdflush */ - { 0, (sy_call_t *)nosys }, /* 301 = sethae */ + { 0, (sy_call_t *)linux_sethae }, /* 301 = linux_sethae */ { AS(linux_mount_args), (sy_call_t *)linux_mount }, /* 302 = linux_mount */ - { 0, (sy_call_t *)nosys }, /* 303 = old_adjtimex */ + { 0, (sy_call_t *)linux_old_adjtimex }, /* 303 = linux_old_adjtimex */ { 0, (sy_call_t *)linux_swapoff }, /* 304 = linux_swapoff */ { AS(linux_getdents_args), (sy_call_t *)linux_getdents }, /* 305 = linux_getdents */ { 0, (sy_call_t *)linux_create_module }, /* 306 = linux_create_module */ { 0, (sy_call_t *)linux_init_module }, /* 307 = linux_init_module */ { 0, (sy_call_t *)linux_delete_module }, /* 308 = linux_delete_module */ { 0, (sy_call_t *)linux_get_kernel_syms }, /* 309 = linux_get_kernel_syms */ - { AS(linux_ksyslog_args), (sy_call_t *)linux_ksyslog }, /* 310 = linux_ksyslog */ + { AS(linux_syslog_args), (sy_call_t *)linux_syslog }, /* 310 = linux_syslog */ { AS(linux_reboot_args), (sy_call_t *)linux_reboot }, /* 311 = linux_reboot */ { AS(linux_clone_args), (sy_call_t *)linux_clone }, /* 312 = linux_clone */ { AS(linux_uselib_args), (sy_call_t *)linux_uselib }, /* 313 = linux_uselib */ @@ -336,9 +336,9 @@ struct sysent linux_sysent[] = { { AS(mlockall_args), (sy_call_t *)mlockall }, /* 316 = mlockall */ { 0, (sy_call_t *)munlockall }, /* 317 = munlockall */ { 0, (sy_call_t *)linux_sysinfo }, /* 318 = linux_sysinfo */ - { 0, (sy_call_t *)linux_sysctl }, /* 319 = linux_sysctl */ - { 0, (sy_call_t *)linux_idle }, /* 320 = linux_idle */ - { AS(linux_umount_args), (sy_call_t *)linux_umount }, /* 321 = linux_umount */ + { AS(linux_sysctl_args), (sy_call_t *)linux_sysctl }, /* 319 = linux_sysctl */ + { 0, (sy_call_t *)nosys }, /* 320 = sys_idle */ + { AS(linux_oldumount_args), (sy_call_t *)linux_oldumount }, /* 321 = linux_oldumount */ { AS(swapon_args), (sy_call_t *)swapon }, /* 322 = swapon */ { AS(linux_times_args), (sy_call_t *)linux_times }, /* 323 = linux_times */ { AS(linux_personality_args), (sy_call_t *)linux_personality }, /* 324 = linux_personality */ @@ -351,19 +351,19 @@ struct sysent linux_sysent[] = { { AS(sched_getparam_args), (sy_call_t *)sched_getparam }, /* 331 = sched_getparam */ { AS(linux_sched_setscheduler_args), (sy_call_t *)linux_sched_setscheduler }, /* 332 = linux_sched_setscheduler */ { AS(linux_sched_getscheduler_args), (sy_call_t *)linux_sched_getscheduler }, /* 333 = linux_sched_getscheduler */ - { 0, (sy_call_t *)sched_yield }, /* 334 = sched_yield */ + { SYF_MPSAFE | 0, (sy_call_t *)sched_yield }, /* 334 = sched_yield */ { AS(linux_sched_get_priority_max_args), (sy_call_t *)linux_sched_get_priority_max }, /* 335 = linux_sched_get_priority_max */ { AS(linux_sched_get_priority_min_args), (sy_call_t *)linux_sched_get_priority_min }, /* 336 = linux_sched_get_priority_min */ { AS(sched_rr_get_interval_args), (sy_call_t *)sched_rr_get_interval }, /* 337 = sched_rr_get_interval */ - { 0, (sy_call_t *)nosys }, /* 338 = afs_syscall */ + { 0, (sy_call_t *)nosys }, /* 338 = sys_afs_syscall */ { AS(linux_newuname_args), (sy_call_t *)linux_newuname }, /* 339 = linux_newuname */ - { AS(nanosleep_args), (sy_call_t *)nanosleep }, /* 340 = nanosleep */ + { SYF_MPSAFE | AS(nanosleep_args), (sy_call_t *)nanosleep }, /* 340 = nanosleep */ { AS(linux_mremap_args), (sy_call_t *)linux_mremap }, /* 341 = linux_mremap */ { 0, (sy_call_t *)linux_nfsservctl }, /* 342 = linux_nfsservctl */ - { AS(setresgid_args), (sy_call_t *)setresgid }, /* 343 = setresgid */ - { AS(linux_getresgid_args), (sy_call_t *)linux_getresgid }, /* 344 = linux_getresgid */ - { 0, (sy_call_t *)nosys }, /* 345 = pciconfig_read */ - { 0, (sy_call_t *)nosys }, /* 346 = pciconfig_write */ + { AS(setresuid_args), (sy_call_t *)setresuid }, /* 343 = setresuid */ + { AS(getresuid_args), (sy_call_t *)getresuid }, /* 344 = getresuid */ + { 0, (sy_call_t *)linux_pciconfig_read }, /* 345 = linux_pciconfig_read */ + { 0, (sy_call_t *)linux_pciconfig_write }, /* 346 = linux_pciconfig_write */ { 0, (sy_call_t *)linux_query_module }, /* 347 = linux_query_module */ { 0, (sy_call_t *)linux_prctl }, /* 348 = linux_prctl */ { AS(linux_pread_args), (sy_call_t *)linux_pread }, /* 349 = linux_pread */ @@ -375,12 +375,12 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)linux_rt_sigtimedwait }, /* 355 = linux_rt_sigtimedwait */ { 0, (sy_call_t *)linux_rt_sigqueueinfo }, /* 356 = linux_rt_sigqueueinfo */ { AS(linux_rt_sigsuspend_args), (sy_call_t *)linux_rt_sigsuspend }, /* 357 = linux_rt_sigsuspend */ - { AS(linux_newselect_args), (sy_call_t *)linux_newselect }, /* 358 = linux_newselect */ + { AS(linux_select_args), (sy_call_t *)linux_select }, /* 358 = linux_select */ { AS(gettimeofday_args), (sy_call_t *)gettimeofday }, /* 359 = gettimeofday */ - { AS(settimeofday_args), (sy_call_t *)settimeofday }, /* 360 = settimeofday */ + { SYF_MPSAFE | AS(settimeofday_args), (sy_call_t *)settimeofday }, /* 360 = settimeofday */ { AS(linux_getitimer_args), (sy_call_t *)linux_getitimer }, /* 361 = linux_getitimer */ { AS(linux_setitimer_args), (sy_call_t *)linux_setitimer }, /* 362 = linux_setitimer */ - { AS(linux_utime_args), (sy_call_t *)linux_utime }, /* 363 = linux_utime */ + { AS(linux_utimes_args), (sy_call_t *)linux_utimes }, /* 363 = linux_utimes */ { AS(getrusage_args), (sy_call_t *)getrusage }, /* 364 = getrusage */ { AS(linux_wait4_args), (sy_call_t *)linux_wait4 }, /* 365 = linux_wait4 */ { 0, (sy_call_t *)linux_adjtimex }, /* 366 = linux_adjtimex */ @@ -388,4 +388,11 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)linux_capget }, /* 368 = linux_capget */ { 0, (sy_call_t *)linux_capset }, /* 369 = linux_capset */ { 0, (sy_call_t *)linux_sendfile }, /* 370 = linux_sendfile */ + { AS(setresgid_args), (sy_call_t *)setresgid }, /* 371 = setresgid */ + { AS(getresgid_args), (sy_call_t *)getresgid }, /* 372 = getresgid */ + { 0, (sy_call_t *)nosys }, /* 373 = sys_dipc */ + { AS(linux_pivot_root_args), (sy_call_t *)linux_pivot_root }, /* 374 = linux_pivot_root */ + { AS(linux_mincore_args), (sy_call_t *)linux_mincore }, /* 375 = linux_mincore */ + { 0, (sy_call_t *)linux_pciconfig_iobase }, /* 376 = linux_pciconfig_iobase */ + { AS(linux_getdents64_args), (sy_call_t *)linux_getdents64 }, /* 377 = linux_getdents64 */ }; diff --git a/sys/compat/linux/linux_file.c b/sys/compat/linux/linux_file.c index 2a5d673..3d16a94 100644 --- a/sys/compat/linux/linux_file.c +++ b/sys/compat/linux/linux_file.c @@ -149,175 +149,6 @@ linux_open(struct proc *p, struct linux_open_args *args) return error; } -struct linux_flock { - short l_type; - short l_whence; - linux_off_t l_start; - linux_off_t l_len; - linux_pid_t l_pid; -}; - -static void -linux_to_bsd_flock(struct linux_flock *linux_flock, struct flock *bsd_flock) -{ - switch (linux_flock->l_type) { - case LINUX_F_RDLCK: - bsd_flock->l_type = F_RDLCK; - break; - case LINUX_F_WRLCK: - bsd_flock->l_type = F_WRLCK; - break; - case LINUX_F_UNLCK: - bsd_flock->l_type = F_UNLCK; - break; - default: - bsd_flock->l_type = -1; - break; - } - bsd_flock->l_whence = linux_flock->l_whence; - bsd_flock->l_start = (off_t)linux_flock->l_start; - bsd_flock->l_len = (off_t)linux_flock->l_len; - bsd_flock->l_pid = (pid_t)linux_flock->l_pid; -} - -static void -bsd_to_linux_flock(struct flock *bsd_flock, struct linux_flock *linux_flock) -{ - switch (bsd_flock->l_type) { - case F_RDLCK: - linux_flock->l_type = LINUX_F_RDLCK; - break; - case F_WRLCK: - linux_flock->l_type = LINUX_F_WRLCK; - break; - case F_UNLCK: - linux_flock->l_type = LINUX_F_UNLCK; - break; - } - linux_flock->l_whence = bsd_flock->l_whence; - linux_flock->l_start = (linux_off_t)bsd_flock->l_start; - linux_flock->l_len = (linux_off_t)bsd_flock->l_len; - linux_flock->l_pid = (linux_pid_t)bsd_flock->l_pid; -} - -int -linux_fcntl(struct proc *p, struct linux_fcntl_args *args) -{ - int error, result; - struct fcntl_args /* { - int fd; - int cmd; - long arg; - } */ fcntl_args; - struct linux_flock linux_flock; - struct flock *bsd_flock; - struct filedesc *fdp; - struct file *fp; - caddr_t sg; - - sg = stackgap_init(); - bsd_flock = (struct flock *)stackgap_alloc(&sg, sizeof(struct flock)); - -#ifdef DEBUG - if (ldebug(fcntl)) - printf(ARGS(fcntl, "%d, %08x, *"), args->fd, args->cmd); -#endif - fcntl_args.fd = args->fd; - - switch (args->cmd) { - case LINUX_F_DUPFD: - fcntl_args.cmd = F_DUPFD; - fcntl_args.arg = args->arg; - return fcntl(p, &fcntl_args); - - case LINUX_F_GETFD: - fcntl_args.cmd = F_GETFD; - return fcntl(p, &fcntl_args); - - case LINUX_F_SETFD: - fcntl_args.cmd = F_SETFD; - fcntl_args.arg = args->arg; - return fcntl(p, &fcntl_args); - - case LINUX_F_GETFL: - fcntl_args.cmd = F_GETFL; - error = fcntl(p, &fcntl_args); - result = p->p_retval[0]; - p->p_retval[0] = 0; - if (result & O_RDONLY) p->p_retval[0] |= LINUX_O_RDONLY; - if (result & O_WRONLY) p->p_retval[0] |= LINUX_O_WRONLY; - if (result & O_RDWR) p->p_retval[0] |= LINUX_O_RDWR; - if (result & O_NDELAY) p->p_retval[0] |= LINUX_O_NONBLOCK; - if (result & O_APPEND) p->p_retval[0] |= LINUX_O_APPEND; - if (result & O_FSYNC) p->p_retval[0] |= LINUX_O_SYNC; - if (result & O_ASYNC) p->p_retval[0] |= LINUX_FASYNC; - return error; - - case LINUX_F_SETFL: - fcntl_args.arg = 0; - if (args->arg & LINUX_O_NDELAY) fcntl_args.arg |= O_NONBLOCK; - if (args->arg & LINUX_O_APPEND) fcntl_args.arg |= O_APPEND; - if (args->arg & LINUX_O_SYNC) fcntl_args.arg |= O_FSYNC; - if (args->arg & LINUX_FASYNC) fcntl_args.arg |= O_ASYNC; - fcntl_args.cmd = F_SETFL; - return fcntl(p, &fcntl_args); - - case LINUX_F_GETLK: - if ((error = copyin((caddr_t)args->arg, (caddr_t)&linux_flock, - sizeof(struct linux_flock)))) - return error; - linux_to_bsd_flock(&linux_flock, bsd_flock); - fcntl_args.cmd = F_GETLK; - fcntl_args.arg = (long)bsd_flock; - error = fcntl(p, &fcntl_args); - if (error) - return error; - bsd_to_linux_flock(bsd_flock, &linux_flock); - return copyout((caddr_t)&linux_flock, (caddr_t)args->arg, - sizeof(struct linux_flock)); - - case LINUX_F_SETLK: - if ((error = copyin((caddr_t)args->arg, (caddr_t)&linux_flock, - sizeof(struct linux_flock)))) - return error; - linux_to_bsd_flock(&linux_flock, bsd_flock); - fcntl_args.cmd = F_SETLK; - fcntl_args.arg = (long)bsd_flock; - return fcntl(p, &fcntl_args); - - case LINUX_F_SETLKW: - if ((error = copyin((caddr_t)args->arg, (caddr_t)&linux_flock, - sizeof(struct linux_flock)))) - return error; - linux_to_bsd_flock(&linux_flock, bsd_flock); - fcntl_args.cmd = F_SETLKW; - fcntl_args.arg = (long)bsd_flock; - return fcntl(p, &fcntl_args); - - case LINUX_F_GETOWN: - fcntl_args.cmd = F_GETOWN; - return fcntl(p, &fcntl_args); - - case LINUX_F_SETOWN: - /* - * XXX some Linux applications depend on F_SETOWN having no - * significant effect for pipes (SIGIO is not delivered for - * pipes under Linux-2.2.35 at least). - */ - fdp = p->p_fd; - if ((u_int)args->fd >= fdp->fd_nfiles || - (fp = fdp->fd_ofiles[args->fd]) == NULL) - return EBADF; - if (fp->f_type == DTYPE_PIPE) - return EINVAL; - - fcntl_args.cmd = F_SETOWN; - fcntl_args.arg = args->arg; - return fcntl(p, &fcntl_args); - } - return EINVAL; -} - int linux_lseek(struct proc *p, struct linux_lseek_args *args) { @@ -333,7 +164,7 @@ linux_lseek(struct proc *p, struct linux_lseek_args *args) #ifdef DEBUG if (ldebug(lseek)) printf(ARGS(lseek, "%d, %ld, %d"), - args->fdes, args->off, args->whence); + args->fdes, (long)args->off, args->whence); #endif tmp_args.fd = args->fdes; tmp_args.offset = (off_t)args->off; @@ -372,17 +203,6 @@ linux_llseek(struct proc *p, struct linux_llseek_args *args) } #endif /*!__alpha__*/ - -struct linux_dirent { - long dino; - linux_off_t doff; - unsigned short dreclen; - char dname[LINUX_NAME_MAX + 1]; -}; - -#define LINUX_RECLEN(de,namlen) \ - ALIGN((((char *)&(de)->dname - (char *)de) + (namlen) + 1)) - #ifndef __alpha__ int linux_readdir(struct proc *p, struct linux_readdir_args *args) @@ -396,178 +216,250 @@ linux_readdir(struct proc *p, struct linux_readdir_args *args) } #endif /*!__alpha__*/ -int -linux_getdents(struct proc *p, struct linux_getdents_args *args) -{ - register struct dirent *bdp; - struct vnode *vp; - caddr_t inp, buf; /* BSD-format */ - int len, reclen; /* BSD-format */ - caddr_t outp; /* Linux-format */ - int resid, linuxreclen=0; /* Linux-format */ - struct file *fp; - struct uio auio; - struct iovec aiov; - struct vattr va; - off_t off; - struct linux_dirent linux_dirent; - int buflen, error, eofflag, nbytes, justone; - u_long *cookies = NULL, *cookiep; - int ncookies; +/* + * Note that linux_getdents(2) and linux_getdents64(2) have the same + * arguments. They only differ in the definition of struct dirent they + * operate on. We use this to common the code, with the exception of + * accessing struct dirent. Note that linux_readdir(2) is implemented + * by means of linux_getdents(2). In this case we never operate on + * struct dirent64 and thus don't need to handle it... + */ -#ifdef DEBUG - if (ldebug(getdents)) - printf(ARGS(getdents, "%d, *, %d"), args->fd, args->count); -#endif - if ((error = getvnode(p->p_fd, args->fd, &fp)) != 0) { - return (error); - } +struct l_dirent { + l_long d_ino; + l_off_t d_off; + l_ushort d_reclen; + char d_name[LINUX_NAME_MAX + 1]; +}; - if ((fp->f_flag & FREAD) == 0) - return (EBADF); +struct l_dirent64 { + uint64_t d_ino; + int64_t d_off; + l_ushort d_reclen; + u_char d_type; + char d_name[LINUX_NAME_MAX + 1]; +}; - vp = (struct vnode *) fp->f_data; +#define LINUX_RECLEN(de,namlen) \ + ALIGN((((char *)&(de)->d_name - (char *)de) + (namlen) + 1)) - if (vp->v_type != VDIR) - return (EINVAL); +#define LINUX_DIRBLKSIZ 512 - if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p))) { - return error; - } +static int +getdents_common(struct proc *p, struct linux_getdents64_args *args, + int is64bit) +{ + register struct dirent *bdp; + struct vnode *vp; + caddr_t inp, buf; /* BSD-format */ + int len, reclen; /* BSD-format */ + caddr_t outp; /* Linux-format */ + int resid, linuxreclen=0; /* Linux-format */ + struct file *fp; + struct uio auio; + struct iovec aiov; + struct vattr va; + off_t off; + struct l_dirent linux_dirent; + struct l_dirent64 linux_dirent64; + int buflen, error, eofflag, nbytes, justone; + u_long *cookies = NULL, *cookiep; + int ncookies; + + if ((error = getvnode(p->p_fd, args->fd, &fp)) != 0) + return (error); + + if ((fp->f_flag & FREAD) == 0) + return (EBADF); + + vp = (struct vnode *) fp->f_data; + if (vp->v_type != VDIR) + return (EINVAL); + + if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p))) + return (error); + + nbytes = args->count; + if (nbytes == 1) { + /* readdir(2) case. Always struct dirent. */ + if (is64bit) + return (EINVAL); + nbytes = sizeof(linux_dirent); + justone = 1; + } else + justone = 0; + + off = fp->f_offset; + + buflen = max(LINUX_DIRBLKSIZ, nbytes); + buflen = min(buflen, MAXBSIZE); + buf = malloc(buflen, M_TEMP, M_WAITOK); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - nbytes = args->count; - if (nbytes == 1) { - nbytes = sizeof (struct linux_dirent); - justone = 1; - } - else - justone = 0; - - off = fp->f_offset; -#define DIRBLKSIZ 512 /* XXX we used to use ufs's DIRBLKSIZ */ - buflen = max(DIRBLKSIZ, nbytes); - buflen = min(buflen, MAXBSIZE); - buf = malloc(buflen, M_TEMP, M_WAITOK); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); again: - aiov.iov_base = buf; - aiov.iov_len = buflen; - auio.uio_iov = &aiov; - auio.uio_iovcnt = 1; - auio.uio_rw = UIO_READ; - auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; - auio.uio_resid = buflen; - auio.uio_offset = off; - - if (cookies) { - free(cookies, M_TEMP); - cookies = NULL; - } - - error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies); - if (error) { - goto out; - } - - inp = buf; - outp = (caddr_t) args->dent; - resid = nbytes; - if ((len = buflen - auio.uio_resid) <= 0) { - goto eof; - } - - cookiep = cookies; - - if (cookies) { - /* - * When using cookies, the vfs has the option of reading from - * a different offset than that supplied (UFS truncates the - * offset to a block boundary to make sure that it never reads - * partway through a directory entry, even if the directory - * has been compacted). - */ - while (len > 0 && ncookies > 0 && *cookiep <= off) { - bdp = (struct dirent *) inp; - len -= bdp->d_reclen; - inp += bdp->d_reclen; - cookiep++; - ncookies--; - } - } - - while (len > 0) { - if (cookiep && ncookies == 0) - break; - bdp = (struct dirent *) inp; - reclen = bdp->d_reclen; - if (reclen & 3) { - printf("linux_readdir: reclen=%d\n", reclen); - error = EFAULT; - goto out; - } - - if (bdp->d_fileno == 0) { - inp += reclen; - if (cookiep) { - off = *cookiep++; - ncookies--; - } else - off += reclen; - len -= reclen; - continue; - } - linuxreclen = LINUX_RECLEN(&linux_dirent, bdp->d_namlen); - if (reclen > len || resid < linuxreclen) { - outp++; - break; + aiov.iov_base = buf; + aiov.iov_len = buflen; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_rw = UIO_READ; + auio.uio_segflg = UIO_SYSSPACE; + auio.uio_procp = p; + auio.uio_resid = buflen; + auio.uio_offset = off; + + if (cookies) { + free(cookies, M_TEMP); + cookies = NULL; } - linux_dirent.dino = (long) bdp->d_fileno; - if (justone) { - /* - * old linux-style readdir usage. - */ - linux_dirent.doff = (linux_off_t) linuxreclen; - linux_dirent.dreclen = (u_short) bdp->d_namlen; - } else { - if (cookiep) - linux_dirent.doff = (linux_off_t)*cookiep; - else - linux_dirent.doff = (linux_off_t)(off + reclen); - linux_dirent.dreclen = (u_short) linuxreclen; + + if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, + &cookies))) + goto out; + + inp = buf; + outp = (caddr_t)args->dirent; + resid = nbytes; + if ((len = buflen - auio.uio_resid) <= 0) + goto eof; + + cookiep = cookies; + + if (cookies) { + /* + * When using cookies, the vfs has the option of reading from + * a different offset than that supplied (UFS truncates the + * offset to a block boundary to make sure that it never reads + * partway through a directory entry, even if the directory + * has been compacted). + */ + while (len > 0 && ncookies > 0 && *cookiep <= off) { + bdp = (struct dirent *) inp; + len -= bdp->d_reclen; + inp += bdp->d_reclen; + cookiep++; + ncookies--; + } } - strcpy(linux_dirent.dname, bdp->d_name); - if ((error = copyout((caddr_t)&linux_dirent, outp, linuxreclen))) { - goto out; + + while (len > 0) { + if (cookiep && ncookies == 0) + break; + bdp = (struct dirent *) inp; + reclen = bdp->d_reclen; + if (reclen & 3) { + error = EFAULT; + goto out; + } + + if (bdp->d_fileno == 0) { + inp += reclen; + if (cookiep) { + off = *cookiep++; + ncookies--; + } else + off += reclen; + + len -= reclen; + continue; + } + + linuxreclen = (is64bit) + ? LINUX_RECLEN(&linux_dirent64, bdp->d_namlen) + : LINUX_RECLEN(&linux_dirent, bdp->d_namlen); + + if (reclen > len || resid < linuxreclen) { + outp++; + break; + } + + if (justone) { + /* readdir(2) case. */ + linux_dirent.d_ino = (l_long)bdp->d_fileno; + linux_dirent.d_off = (l_off_t)linuxreclen; + linux_dirent.d_reclen = (l_ushort)bdp->d_namlen; + strcpy(linux_dirent.d_name, bdp->d_name); + error = copyout(&linux_dirent, outp, linuxreclen); + } else { + if (is64bit) { + linux_dirent64.d_ino = bdp->d_fileno; + linux_dirent64.d_off = (cookiep) + ? (l_off_t)*cookiep + : (l_off_t)(off + reclen); + linux_dirent64.d_reclen = + (l_ushort)linuxreclen; + linux_dirent64.d_type = bdp->d_type; + strcpy(linux_dirent64.d_name, bdp->d_name); + error = copyout(&linux_dirent64, outp, + linuxreclen); + } else { + linux_dirent.d_ino = bdp->d_fileno; + linux_dirent.d_off = (cookiep) + ? (l_off_t)*cookiep + : (l_off_t)(off + reclen); + linux_dirent.d_reclen = (l_ushort)linuxreclen; + strcpy(linux_dirent.d_name, bdp->d_name); + error = copyout(&linux_dirent, outp, + linuxreclen); + } + } + if (error) + goto out; + + inp += reclen; + if (cookiep) { + off = *cookiep++; + ncookies--; + } else + off += reclen; + + outp += linuxreclen; + resid -= linuxreclen; + len -= reclen; + if (justone) + break; } - inp += reclen; - if (cookiep) { - off = *cookiep++; - ncookies--; - } else - off += reclen; - outp += linuxreclen; - resid -= linuxreclen; - len -= reclen; - if (justone) - break; - } - if (outp == (caddr_t) args->dent) - goto again; - fp->f_offset = off; + if (outp == (caddr_t)args->dirent) + goto again; - if (justone) - nbytes = resid + linuxreclen; + fp->f_offset = off; + if (justone) + nbytes = resid + linuxreclen; eof: - p->p_retval[0] = nbytes - resid; + p->p_retval[0] = nbytes - resid; + out: - if (cookies) - free(cookies, M_TEMP); - VOP_UNLOCK(vp, 0, p); - free(buf, M_TEMP); - return error; + if (cookies) + free(cookies, M_TEMP); + + VOP_UNLOCK(vp, 0, p); + free(buf, M_TEMP); + return (error); +} + +int +linux_getdents(struct proc *p, struct linux_getdents_args *args) +{ + +#ifdef DEBUG + if (ldebug(getdents)) + printf(ARGS(getdents, "%d, *, %d"), args->fd, args->count); +#endif + + return (getdents_common(p, (struct linux_getdents64_args*)args, 0)); +} + +int +linux_getdents64(struct proc *p, struct linux_getdents64_args *args) +{ + +#ifdef DEBUG + if (ldebug(getdents64)) + printf(ARGS(getdents64, "%d, *, %d"), args->fd, args->count); +#endif + + return (getdents_common(p, args, 1)); } /* @@ -649,50 +541,6 @@ linux_chmod(struct proc *p, struct linux_chmod_args *args) } int -linux_chown(struct proc *p, struct linux_chown_args *args) -{ - struct chown_args bsd; - caddr_t sg; - - sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); - -#ifdef DEBUG - if (ldebug(chown)) - printf(ARGS(chown, "%s, %d, %d"), - args->path, args->uid, args->gid); -#endif - bsd.path = args->path; - /* XXX size casts here */ - bsd.uid = args->uid; - bsd.gid = args->gid; - - return chown(p, &bsd); -} - -int -linux_lchown(struct proc *p, struct linux_lchown_args *args) -{ - struct lchown_args bsd; - caddr_t sg; - - sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); - -#ifdef DEBUG - if (ldebug(lchown)) - printf(ARGS(lchown, "%s, %d, %d"), - args->path, args->uid, args->gid); -#endif - bsd.path = args->path; - /* XXX size casts here */ - bsd.uid = args->uid; - bsd.gid = args->gid; - - return lchown(p, &bsd); -} - -int linux_mkdir(struct proc *p, struct linux_mkdir_args *args) { struct mkdir_args bsd; @@ -801,7 +649,8 @@ linux_truncate(struct proc *p, struct linux_truncate_args *args) #ifdef DEBUG if (ldebug(truncate)) - printf(ARGS(truncate, "%s, %ld"), args->path, args->length); + printf(ARGS(truncate, "%s, %ld"), args->path, + (long)args->length); #endif bsd.path = args->path; bsd.length = args->length; @@ -937,17 +786,17 @@ linux_mount(struct proc *p, struct linux_mount_args *args) } int -linux_umount(struct proc *p, struct linux_umount_args *args) +linux_oldumount(struct proc *p, struct linux_oldumount_args *args) { - struct linux_umount2_args args2; + struct linux_umount_args args2; args2.path = args->path; args2.flags = 0; - return (linux_umount2(p, &args2)); + return (linux_umount(p, &args2)); } int -linux_umount2(struct proc *p, struct linux_umount2_args *args) +linux_umount(struct proc *p, struct linux_umount_args *args) { struct unmount_args bsd; @@ -955,3 +804,325 @@ linux_umount2(struct proc *p, struct linux_umount2_args *args) bsd.flags = args->flags; /* XXX correct? */ return (unmount(p, &bsd)); } + +/* + * fcntl family of syscalls + */ + +struct l_flock { + l_short l_type; + l_short l_whence; + l_off_t l_start; + l_off_t l_len; + l_pid_t l_pid; +}; + +static void +linux_to_bsd_flock(struct l_flock *linux_flock, struct flock *bsd_flock) +{ + switch (linux_flock->l_type) { + case LINUX_F_RDLCK: + bsd_flock->l_type = F_RDLCK; + break; + case LINUX_F_WRLCK: + bsd_flock->l_type = F_WRLCK; + break; + case LINUX_F_UNLCK: + bsd_flock->l_type = F_UNLCK; + break; + default: + bsd_flock->l_type = -1; + break; + } + bsd_flock->l_whence = linux_flock->l_whence; + bsd_flock->l_start = (off_t)linux_flock->l_start; + bsd_flock->l_len = (off_t)linux_flock->l_len; + bsd_flock->l_pid = (pid_t)linux_flock->l_pid; +} + +static void +bsd_to_linux_flock(struct flock *bsd_flock, struct l_flock *linux_flock) +{ + switch (bsd_flock->l_type) { + case F_RDLCK: + linux_flock->l_type = LINUX_F_RDLCK; + break; + case F_WRLCK: + linux_flock->l_type = LINUX_F_WRLCK; + break; + case F_UNLCK: + linux_flock->l_type = LINUX_F_UNLCK; + break; + } + linux_flock->l_whence = bsd_flock->l_whence; + linux_flock->l_start = (l_off_t)bsd_flock->l_start; + linux_flock->l_len = (l_off_t)bsd_flock->l_len; + linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid; +} + +#if defined(__i386__) +struct l_flock64 { + l_short l_type; + l_short l_whence; + l_loff_t l_start; + l_loff_t l_len; + l_pid_t l_pid; +}; + +static void +linux_to_bsd_flock64(struct l_flock64 *linux_flock, struct flock *bsd_flock) +{ + switch (linux_flock->l_type) { + case LINUX_F_RDLCK: + bsd_flock->l_type = F_RDLCK; + break; + case LINUX_F_WRLCK: + bsd_flock->l_type = F_WRLCK; + break; + case LINUX_F_UNLCK: + bsd_flock->l_type = F_UNLCK; + break; + default: + bsd_flock->l_type = -1; + break; + } + bsd_flock->l_whence = linux_flock->l_whence; + bsd_flock->l_start = (off_t)linux_flock->l_start; + bsd_flock->l_len = (off_t)linux_flock->l_len; + bsd_flock->l_pid = (pid_t)linux_flock->l_pid; +} + +static void +bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock) +{ + switch (bsd_flock->l_type) { + case F_RDLCK: + linux_flock->l_type = LINUX_F_RDLCK; + break; + case F_WRLCK: + linux_flock->l_type = LINUX_F_WRLCK; + break; + case F_UNLCK: + linux_flock->l_type = LINUX_F_UNLCK; + break; + } + linux_flock->l_whence = bsd_flock->l_whence; + linux_flock->l_start = (l_loff_t)bsd_flock->l_start; + linux_flock->l_len = (l_loff_t)bsd_flock->l_len; + linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid; +} +#endif /* __i386__ */ + +#if defined(__alpha__) +#define linux_fcntl64_args linux_fcntl_args +#endif + +static int +fcntl_common(struct proc *p, struct linux_fcntl64_args *args) +{ + struct fcntl_args fcntl_args; + struct filedesc *fdp; + struct file *fp; + int error, result; + + fcntl_args.fd = args->fd; + + switch (args->cmd) { + case LINUX_F_DUPFD: + fcntl_args.cmd = F_DUPFD; + fcntl_args.arg = args->arg; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_GETFD: + fcntl_args.cmd = F_GETFD; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_SETFD: + fcntl_args.cmd = F_SETFD; + fcntl_args.arg = args->arg; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_GETFL: + fcntl_args.cmd = F_GETFL; + error = fcntl(p, &fcntl_args); + result = p->p_retval[0]; + p->p_retval[0] = 0; + if (result & O_RDONLY) + p->p_retval[0] |= LINUX_O_RDONLY; + if (result & O_WRONLY) + p->p_retval[0] |= LINUX_O_WRONLY; + if (result & O_RDWR) + p->p_retval[0] |= LINUX_O_RDWR; + if (result & O_NDELAY) + p->p_retval[0] |= LINUX_O_NONBLOCK; + if (result & O_APPEND) + p->p_retval[0] |= LINUX_O_APPEND; + if (result & O_FSYNC) + p->p_retval[0] |= LINUX_O_SYNC; + if (result & O_ASYNC) + p->p_retval[0] |= LINUX_FASYNC; + return (error); + + case LINUX_F_SETFL: + fcntl_args.arg = 0; + if (args->arg & LINUX_O_NDELAY) + fcntl_args.arg |= O_NONBLOCK; + if (args->arg & LINUX_O_APPEND) + fcntl_args.arg |= O_APPEND; + if (args->arg & LINUX_O_SYNC) + fcntl_args.arg |= O_FSYNC; + if (args->arg & LINUX_FASYNC) + fcntl_args.arg |= O_ASYNC; + fcntl_args.cmd = F_SETFL; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_GETOWN: + fcntl_args.cmd = F_GETOWN; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_SETOWN: + /* + * XXX some Linux applications depend on F_SETOWN having no + * significant effect for pipes (SIGIO is not delivered for + * pipes under Linux-2.2.35 at least). + */ + fdp = p->p_fd; + if ((u_int)args->fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[args->fd]) == NULL) + return (EBADF); + if (fp->f_type == DTYPE_PIPE) + return (EINVAL); + + fcntl_args.cmd = F_SETOWN; + fcntl_args.arg = args->arg; + return (fcntl(p, &fcntl_args)); + } + + return (EINVAL); +} + +int +linux_fcntl(struct proc *p, struct linux_fcntl_args *args) +{ + struct linux_fcntl64_args args64; + struct fcntl_args fcntl_args; + struct l_flock linux_flock; + struct flock *bsd_flock; + int error; + caddr_t sg; + + sg = stackgap_init(); + bsd_flock = (struct flock *)stackgap_alloc(&sg, sizeof(bsd_flock)); + +#ifdef DEBUG + if (ldebug(fcntl)) + printf(ARGS(fcntl, "%d, %08x, *"), args->fd, args->cmd); +#endif + + switch (args->cmd) { + case LINUX_F_GETLK: + error = copyin((caddr_t)args->arg, &linux_flock, + sizeof(linux_flock)); + if (error) + return (error); + linux_to_bsd_flock(&linux_flock, bsd_flock); + fcntl_args.fd = args->fd; + fcntl_args.cmd = F_GETLK; + fcntl_args.arg = (long)bsd_flock; + error = fcntl(p, &fcntl_args); + if (error) + return (error); + bsd_to_linux_flock(bsd_flock, &linux_flock); + return (copyout(&linux_flock, (caddr_t)args->arg, + sizeof(linux_flock))); + + case LINUX_F_SETLK: + error = copyin((caddr_t)args->arg, &linux_flock, + sizeof(linux_flock)); + if (error) + return (error); + linux_to_bsd_flock(&linux_flock, bsd_flock); + fcntl_args.fd = args->fd; + fcntl_args.cmd = F_SETLK; + fcntl_args.arg = (long)bsd_flock; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_SETLKW: + error = copyin((caddr_t)args->arg, &linux_flock, + sizeof(linux_flock)); + if (error) + return (error); + linux_to_bsd_flock(&linux_flock, bsd_flock); + fcntl_args.fd = args->fd; + fcntl_args.cmd = F_SETLKW; + fcntl_args.arg = (long)bsd_flock; + return (fcntl(p, &fcntl_args)); + } + + args64.fd = args->fd; + args64.cmd = args->cmd; + args64.arg = args->arg; + return (fcntl_common(p, &args64)); +} + +#if defined(__i386__) +int +linux_fcntl64(struct proc *p, struct linux_fcntl64_args *args) +{ + struct fcntl_args fcntl_args; + struct l_flock64 linux_flock; + struct flock *bsd_flock; + int error; + caddr_t sg; + + sg = stackgap_init(); + bsd_flock = (struct flock *)stackgap_alloc(&sg, sizeof(bsd_flock)); + +#ifdef DEBUG + if (ldebug(fcntl64)) + printf(ARGS(fcntl64, "%d, %08x, *"), args->fd, args->cmd); +#endif + + switch (args->cmd) { + case LINUX_F_GETLK: + error = copyin((caddr_t)args->arg, &linux_flock, + sizeof(linux_flock)); + if (error) + return (error); + linux_to_bsd_flock64(&linux_flock, bsd_flock); + fcntl_args.fd = args->fd; + fcntl_args.cmd = F_GETLK; + fcntl_args.arg = (long)bsd_flock; + error = fcntl(p, &fcntl_args); + if (error) + return (error); + bsd_to_linux_flock64(bsd_flock, &linux_flock); + return (copyout(&linux_flock, (caddr_t)args->arg, + sizeof(linux_flock))); + + case LINUX_F_SETLK: + error = copyin((caddr_t)args->arg, &linux_flock, + sizeof(linux_flock)); + if (error) + return (error); + linux_to_bsd_flock64(&linux_flock, bsd_flock); + fcntl_args.fd = args->fd; + fcntl_args.cmd = F_SETLK; + fcntl_args.arg = (long)bsd_flock; + return (fcntl(p, &fcntl_args)); + + case LINUX_F_SETLKW: + error = copyin((caddr_t)args->arg, &linux_flock, + sizeof(linux_flock)); + if (error) + return (error); + linux_to_bsd_flock64(&linux_flock, bsd_flock); + fcntl_args.fd = args->fd; + fcntl_args.cmd = F_SETLKW; + fcntl_args.arg = (long)bsd_flock; + return (fcntl(p, &fcntl_args)); + } + + return (fcntl_common(p, args)); +} +#endif /* __i386__ */ diff --git a/sys/compat/linux/linux_ioctl.c b/sys/compat/linux/linux_ioctl.c index 2079fcd..b4fc8ce 100644 --- a/sys/compat/linux/linux_ioctl.c +++ b/sys/compat/linux/linux_ioctl.c @@ -1379,7 +1379,7 @@ linux_ioctl_socket(struct proc *p, struct linux_ioctl_args *args) struct ifnet *ifp; struct ifaddr *ifa; struct sockaddr_dl *sdl; - struct linux_ifreq *ifr = (struct linux_ifreq *)args->arg; + struct l_ifreq *ifr = (struct l_ifreq *)args->arg; /* Note that we don't actually respect the name in the ifreq * structure, as Linux interface names are all different. @@ -1424,7 +1424,7 @@ linux_ioctl_socket(struct proc *p, struct linux_ioctl_args *args) int linux_ioctl(struct proc *p, struct linux_ioctl_args *args) { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp; struct file *fp; struct handler_element *he; int error, cmd; @@ -1434,9 +1434,9 @@ linux_ioctl(struct proc *p, struct linux_ioctl_args *args) printf(ARGS(ioctl, "%d, %04lx, *"), args->fd, args->cmd); #endif + fdp = p->p_fd; if ((unsigned)args->fd >= fdp->fd_nfiles) return (EBADF); - fp = fdp->fd_ofiles[args->fd]; if (fp == NULL || (fp->f_flag & (FREAD|FWRITE)) == 0) return (EBADF); diff --git a/sys/compat/linux/linux_ipc.c b/sys/compat/linux/linux_ipc.c index e68580f..de9b47a 100644 --- a/sys/compat/linux/linux_ipc.c +++ b/sys/compat/linux/linux_ipc.c @@ -40,18 +40,18 @@ #include <compat/linux/linux_ipc.h> #include <compat/linux/linux_util.h> -struct linux_ipc_perm { - linux_key_t key; - unsigned short uid; - unsigned short gid; - unsigned short cuid; - unsigned short cgid; - unsigned short mode; - unsigned short seq; +struct l_ipc_perm { + l_key_t key; + l_uid16_t uid; + l_gid16_t gid; + l_uid16_t cuid; + l_gid16_t cgid; + l_ushort mode; + l_ushort seq; }; static void -linux_to_bsd_ipc_perm(struct linux_ipc_perm *lpp, struct ipc_perm *bpp) +linux_to_bsd_ipc_perm(struct l_ipc_perm *lpp, struct ipc_perm *bpp) { bpp->key = lpp->key; bpp->uid = lpp->uid; @@ -64,7 +64,7 @@ linux_to_bsd_ipc_perm(struct linux_ipc_perm *lpp, struct ipc_perm *bpp) static void -bsd_to_linux_ipc_perm(struct ipc_perm *bpp, struct linux_ipc_perm *lpp) +bsd_to_linux_ipc_perm(struct ipc_perm *bpp, struct l_ipc_perm *lpp) { lpp->key = bpp->key; lpp->uid = bpp->uid; @@ -75,33 +75,33 @@ bsd_to_linux_ipc_perm(struct ipc_perm *bpp, struct linux_ipc_perm *lpp) lpp->seq = bpp->seq; } -struct linux_semid_ds { - struct linux_ipc_perm sem_perm; - linux_time_t sem_otime; - linux_time_t sem_ctime; +struct l_semid_ds { + struct l_ipc_perm sem_perm; + l_time_t sem_otime; + l_time_t sem_ctime; void *sem_base; void *sem_pending; void *sem_pending_last; void *undo; - ushort sem_nsems; + l_ushort sem_nsems; }; -struct linux_shmid_ds { - struct linux_ipc_perm shm_perm; - int shm_segsz; - linux_time_t shm_atime; - linux_time_t shm_dtime; - linux_time_t shm_ctime; - ushort shm_cpid; - ushort shm_lpid; - short shm_nattch; - ushort private1; - void *private2; - void *private3; +struct l_shmid_ds { + struct l_ipc_perm shm_perm; + l_int shm_segsz; + l_time_t shm_atime; + l_time_t shm_dtime; + l_time_t shm_ctime; + l_ushort shm_cpid; + l_ushort shm_lpid; + l_short shm_nattch; + l_ushort private1; + void *private2; + void *private3; }; static void -linux_to_bsd_semid_ds(struct linux_semid_ds *lsp, struct semid_ds *bsp) +linux_to_bsd_semid_ds(struct l_semid_ds *lsp, struct semid_ds *bsp) { linux_to_bsd_ipc_perm(&lsp->sem_perm, &bsp->sem_perm); bsp->sem_otime = lsp->sem_otime; @@ -111,7 +111,7 @@ linux_to_bsd_semid_ds(struct linux_semid_ds *lsp, struct semid_ds *bsp) } static void -bsd_to_linux_semid_ds(struct semid_ds *bsp, struct linux_semid_ds *lsp) +bsd_to_linux_semid_ds(struct semid_ds *bsp, struct l_semid_ds *lsp) { bsd_to_linux_ipc_perm(&bsp->sem_perm, &lsp->sem_perm); lsp->sem_otime = bsp->sem_otime; @@ -121,7 +121,7 @@ bsd_to_linux_semid_ds(struct semid_ds *bsp, struct linux_semid_ds *lsp) } static void -linux_to_bsd_shmid_ds(struct linux_shmid_ds *lsp, struct shmid_ds *bsp) +linux_to_bsd_shmid_ds(struct l_shmid_ds *lsp, struct shmid_ds *bsp) { linux_to_bsd_ipc_perm(&lsp->shm_perm, &bsp->shm_perm); bsp->shm_segsz = lsp->shm_segsz; @@ -135,7 +135,7 @@ linux_to_bsd_shmid_ds(struct linux_shmid_ds *lsp, struct shmid_ds *bsp) } static void -bsd_to_linux_shmid_ds(struct shmid_ds *bsp, struct linux_shmid_ds *lsp) +bsd_to_linux_shmid_ds(struct shmid_ds *bsp, struct l_shmid_ds *lsp) { bsd_to_linux_ipc_perm(&bsp->shm_perm, &lsp->shm_perm); lsp->shm_segsz = bsp->shm_segsz; @@ -157,9 +157,9 @@ linux_semop(struct proc *p, struct linux_semop_args *args) int nsops; } */ bsd_args; - bsd_args.semid = args->arg1; - bsd_args.sops = (struct sembuf *)args->ptr; - bsd_args.nsops = args->arg2; + bsd_args.semid = args->semid; + bsd_args.sops = (struct sembuf *)args->tsops; + bsd_args.nsops = args->nsops; return semop(p, &bsd_args); } @@ -172,33 +172,32 @@ linux_semget(struct proc *p, struct linux_semget_args *args) int semflg; } */ bsd_args; - bsd_args.key = args->arg1; - bsd_args.nsems = args->arg2; - bsd_args.semflg = args->arg3; + bsd_args.key = args->key; + bsd_args.nsems = args->nsems; + bsd_args.semflg = args->semflg; return semget(p, &bsd_args); } int linux_semctl(struct proc *p, struct linux_semctl_args *args) { - struct linux_semid_ds linux_semid; - struct semid_ds bsd_semid; + struct l_semid_ds linux_semid; struct __semctl_args /* { - int semid; - int semnum; - int cmd; - union semun *arg; + int semid; + int semnum; + int cmd; + union semun *arg; } */ bsd_args; - int error; - caddr_t sg, unptr, dsp, ldsp; + int error; + union semun *unptr; + caddr_t sg; sg = stackgap_init(); - bsd_args.semid = args->arg1; - bsd_args.semnum = args->arg2; - bsd_args.cmd = args->arg3; - bsd_args.arg = (union semun *)args->ptr; + bsd_args.semid = args->semid; + bsd_args.semnum = args->semnum; + bsd_args.arg = (union semun *)&args->arg; - switch (args->arg3) { + switch (args->cmd) { case LINUX_IPC_RMID: bsd_args.cmd = IPC_RMID; break; @@ -219,48 +218,32 @@ linux_semctl(struct proc *p, struct linux_semctl_args *args) break; case LINUX_IPC_SET: bsd_args.cmd = IPC_SET; - error = copyin(args->ptr, &ldsp, sizeof(ldsp)); + error = copyin((caddr_t)args->arg.buf, &linux_semid, + sizeof(linux_semid)); if (error) - return error; - error = copyin(ldsp, (caddr_t)&linux_semid, sizeof(linux_semid)); - if (error) - return error; - linux_to_bsd_semid_ds(&linux_semid, &bsd_semid); + return (error); unptr = stackgap_alloc(&sg, sizeof(union semun)); - dsp = stackgap_alloc(&sg, sizeof(struct semid_ds)); - error = copyout((caddr_t)&bsd_semid, dsp, sizeof(bsd_semid)); - if (error) - return error; - error = copyout((caddr_t)&dsp, unptr, sizeof(dsp)); - if (error) - return error; - bsd_args.arg = (union semun *)unptr; + unptr->buf = stackgap_alloc(&sg, sizeof(struct semid_ds)); + linux_to_bsd_semid_ds(&linux_semid, unptr->buf); + bsd_args.arg = unptr; return __semctl(p, &bsd_args); case LINUX_IPC_STAT: bsd_args.cmd = IPC_STAT; - unptr = stackgap_alloc(&sg, sizeof(union semun *)); - dsp = stackgap_alloc(&sg, sizeof(struct semid_ds)); - error = copyout((caddr_t)&dsp, unptr, sizeof(dsp)); - if (error) - return error; - bsd_args.arg = (union semun *)unptr; + unptr = stackgap_alloc(&sg, sizeof(union semun)); + unptr->buf = stackgap_alloc(&sg, sizeof(struct semid_ds)); + bsd_args.arg = unptr; error = __semctl(p, &bsd_args); if (error) return error; - error = copyin(dsp, (caddr_t)&bsd_semid, sizeof(bsd_semid)); - if (error) - return error; - bsd_to_linux_semid_ds(&bsd_semid, &linux_semid); - error = copyin(args->ptr, &ldsp, sizeof(ldsp)); - if (error) - return error; - return copyout((caddr_t)&linux_semid, ldsp, sizeof(linux_semid)); + bsd_to_linux_semid_ds(unptr->buf, &linux_semid); + return copyout(&linux_semid, (caddr_t)args->arg.buf, + sizeof(linux_semid)); case LINUX_GETALL: /* FALLTHROUGH */ case LINUX_SETALL: /* FALLTHROUGH */ default: - uprintf("LINUX: 'ipc' typ=%d not implemented\n", args->arg3); + uprintf("linux: 'ipc' typ=%d not implemented\n", args->cmd); return EINVAL; } return __semctl(p, &bsd_args); @@ -276,10 +259,10 @@ linux_msgsnd(struct proc *p, struct linux_msgsnd_args *args) int msgflg; } */ bsd_args; - bsd_args.msqid = args->arg1; - bsd_args.msgp = args->ptr; - bsd_args.msgsz = args->arg2; - bsd_args.msgflg = args->arg3; + bsd_args.msqid = args->msqid; + bsd_args.msgp = args->msgp; + bsd_args.msgsz = args->msgsz; + bsd_args.msgflg = args->msgflg; return msgsnd(p, &bsd_args); } @@ -294,11 +277,11 @@ linux_msgrcv(struct proc *p, struct linux_msgrcv_args *args) int msgflg; } */ bsd_args; - bsd_args.msqid = args->arg1; - bsd_args.msgp = args->ptr; - bsd_args.msgsz = args->arg2; - bsd_args.msgtyp = 0; - bsd_args.msgflg = args->arg3; + bsd_args.msqid = args->msqid; + bsd_args.msgp = args->msgp; + bsd_args.msgsz = args->msgsz; + bsd_args.msgtyp = 0; /* XXX - args->msgtyp; */ + bsd_args.msgflg = args->msgflg; return msgrcv(p, &bsd_args); } @@ -310,8 +293,8 @@ linux_msgget(struct proc *p, struct linux_msgget_args *args) int msgflg; } */ bsd_args; - bsd_args.key = args->arg1; - bsd_args.msgflg = args->arg2; + bsd_args.key = args->key; + bsd_args.msgflg = args->msgflg; return msgget(p, &bsd_args); } @@ -325,11 +308,11 @@ linux_msgctl(struct proc *p, struct linux_msgctl_args *args) } */ bsd_args; int error; - bsd_args.msqid = args->arg1; - bsd_args.cmd = args->arg2; - bsd_args.buf = (struct msqid_ds *)args->ptr; + bsd_args.msqid = args->msqid; + bsd_args.cmd = args->cmd; + bsd_args.buf = (struct msqid_ds *)args->buf; error = msgctl(p, &bsd_args); - return ((args->arg2 == LINUX_IPC_RMID && error == EINVAL) ? 0 : error); + return ((args->cmd == LINUX_IPC_RMID && error == EINVAL) ? 0 : error); } int @@ -342,13 +325,13 @@ linux_shmat(struct proc *p, struct linux_shmat_args *args) } */ bsd_args; int error; - bsd_args.shmid = args->arg1; - bsd_args.shmaddr = args->ptr; - bsd_args.shmflg = args->arg2; + bsd_args.shmid = args->shmid; + bsd_args.shmaddr = args->shmaddr; + bsd_args.shmflg = args->shmflg; if ((error = shmat(p, &bsd_args))) return error; #ifdef __i386__ - if ((error = copyout(p->p_retval, (caddr_t)args->arg3, sizeof(int)))) + if ((error = copyout(p->p_retval, (caddr_t)args->raddr, sizeof(l_ulong)))) return error; p->p_retval[0] = 0; #endif @@ -362,7 +345,7 @@ linux_shmdt(struct proc *p, struct linux_shmdt_args *args) void *shmaddr; } */ bsd_args; - bsd_args.shmaddr = args->ptr; + bsd_args.shmaddr = args->shmaddr; return shmdt(p, &bsd_args); } @@ -375,17 +358,16 @@ linux_shmget(struct proc *p, struct linux_shmget_args *args) int shmflg; } */ bsd_args; - bsd_args.key = args->arg1; - bsd_args.size = args->arg2; - bsd_args.shmflg = args->arg3; + bsd_args.key = args->key; + bsd_args.size = args->size; + bsd_args.shmflg = args->shmflg; return shmget(p, &bsd_args); } int linux_shmctl(struct proc *p, struct linux_shmctl_args *args) { - struct shmid_ds bsd_shmid; - struct linux_shmid_ds linux_shmid; + struct l_shmid_ds linux_shmid; struct shmctl_args /* { int shmid; int cmd; @@ -394,46 +376,37 @@ linux_shmctl(struct proc *p, struct linux_shmctl_args *args) int error; caddr_t sg = stackgap_init(); - switch (args->arg2) { + switch (args->cmd) { case LINUX_IPC_STAT: - bsd_args.shmid = args->arg1; + bsd_args.shmid = args->shmid; bsd_args.cmd = IPC_STAT; bsd_args.buf = (struct shmid_ds*)stackgap_alloc(&sg, sizeof(struct shmid_ds)); if ((error = shmctl(p, &bsd_args))) return error; - if ((error = copyin((caddr_t)bsd_args.buf, (caddr_t)&bsd_shmid, - sizeof(struct shmid_ds)))) - return error; - bsd_to_linux_shmid_ds(&bsd_shmid, &linux_shmid); - return copyout((caddr_t)&linux_shmid, args->ptr, sizeof(linux_shmid)); + bsd_to_linux_shmid_ds(bsd_args.buf, &linux_shmid); + return copyout(&linux_shmid, (caddr_t)args->buf, sizeof(linux_shmid)); case LINUX_IPC_SET: - if ((error = copyin(args->ptr, (caddr_t)&linux_shmid, - sizeof(linux_shmid)))) + if ((error = copyin((caddr_t)args->buf, &linux_shmid, + sizeof(linux_shmid)))) return error; - linux_to_bsd_shmid_ds(&linux_shmid, &bsd_shmid); bsd_args.buf = (struct shmid_ds*)stackgap_alloc(&sg, sizeof(struct shmid_ds)); - if ((error = copyout((caddr_t)&bsd_shmid, (caddr_t)bsd_args.buf, - sizeof(struct shmid_ds)))) - return error; - bsd_args.shmid = args->arg1; + linux_to_bsd_shmid_ds(&linux_shmid, bsd_args.buf); + bsd_args.shmid = args->shmid; bsd_args.cmd = IPC_SET; return shmctl(p, &bsd_args); case LINUX_IPC_RMID: - bsd_args.shmid = args->arg1; + bsd_args.shmid = args->shmid; bsd_args.cmd = IPC_RMID; - if (NULL == args->ptr) + if (args->buf == NULL) bsd_args.buf = NULL; else { - if ((error = copyin(args->ptr, (caddr_t)&linux_shmid, + if ((error = copyin((caddr_t)args->buf, &linux_shmid, sizeof(linux_shmid)))) return error; - linux_to_bsd_shmid_ds(&linux_shmid, &bsd_shmid); bsd_args.buf = (struct shmid_ds*)stackgap_alloc(&sg, sizeof(struct shmid_ds)); - if ((error = copyout((caddr_t)&bsd_shmid, (caddr_t)bsd_args.buf, - sizeof(struct shmid_ds)))) - return error; + linux_to_bsd_shmid_ds(&linux_shmid, bsd_args.buf); } return shmctl(p, &bsd_args); @@ -443,7 +416,7 @@ linux_shmctl(struct proc *p, struct linux_shmctl_args *args) case LINUX_SHM_LOCK: case LINUX_SHM_UNLOCK: default: - uprintf("LINUX: 'ipc' typ=%d not implemented\n", args->arg2); + uprintf("linux: 'ipc' typ=%d not implemented\n", args->cmd); return EINVAL; } } diff --git a/sys/compat/linux/linux_ipc.h b/sys/compat/linux/linux_ipc.h index 946d963..d0db461 100644 --- a/sys/compat/linux/linux_ipc.h +++ b/sys/compat/linux/linux_ipc.h @@ -31,21 +31,86 @@ #ifndef _LINUX_IPC_H_ #define _LINUX_IPC_H_ -#ifndef __alpha__ +#ifdef __i386__ -#define linux_msgctl_args linux_ipc_args -#define linux_msgget_args linux_ipc_args -#define linux_msgrcv_args linux_ipc_args -#define linux_msgsnd_args linux_ipc_args +struct linux_msgctl_args +{ + l_int msqid; + l_int cmd; + struct l_msqid_ds *buf; +}; -#define linux_semctl_args linux_ipc_args -#define linux_semget_args linux_ipc_args -#define linux_semop_args linux_ipc_args +struct linux_msgget_args +{ + l_key_t key; + l_int msgflg; +}; -#define linux_shmat_args linux_ipc_args -#define linux_shmctl_args linux_ipc_args -#define linux_shmdt_args linux_ipc_args -#define linux_shmget_args linux_ipc_args +struct linux_msgrcv_args +{ + l_int msqid; + struct l_msgbuf *msgp; + l_size_t msgsz; + l_long msgtyp; + l_int msgflg; +}; + +struct linux_msgsnd_args +{ + l_int msqid; + struct l_msgbuf *msgp; + l_size_t msgsz; + l_int msgflg; +}; + +struct linux_semctl_args +{ + l_int semid; + l_int semnum; + l_int cmd; + union l_semun arg; +}; + +struct linux_semget_args +{ + l_key_t key; + l_int nsems; + l_int semflg; +}; + +struct linux_semop_args +{ + l_int semid; + struct l_sembuf *tsops; + l_uint nsops; +}; + +struct linux_shmat_args +{ + l_int shmid; + char *shmaddr; + l_int shmflg; + l_ulong *raddr; +}; + +struct linux_shmctl_args +{ + l_int shmid; + l_int cmd; + struct l_shmid_ds *buf; +}; + +struct linux_shmdt_args +{ + char *shmaddr; +}; + +struct linux_shmget_args +{ + l_key_t key; + l_size_t size; + l_int shmflg; +}; int linux_msgctl __P((struct proc *, struct linux_msgctl_args *)); int linux_msgget __P((struct proc *, struct linux_msgget_args *)); @@ -60,6 +125,7 @@ int linux_shmat __P((struct proc *, struct linux_shmat_args *)); int linux_shmctl __P((struct proc *, struct linux_shmctl_args *)); int linux_shmdt __P((struct proc *, struct linux_shmdt_args *)); int linux_shmget __P((struct proc *, struct linux_shmget_args *)); -#endif /*!__alpha__*/ + +#endif /* __i386__ */ #endif /* _LINUX_IPC_H_ */ diff --git a/sys/compat/linux/linux_mib.c b/sys/compat/linux/linux_mib.c index e15b2a4..fda251b 100644 --- a/sys/compat/linux/linux_mib.c +++ b/sys/compat/linux/linux_mib.c @@ -69,7 +69,7 @@ SYSCTL_PROC(_compat_linux, OID_AUTO, osname, 0, 0, linux_sysctl_osname, "A", "Linux kernel OS name"); -static char linux_osrelease[LINUX_MAX_UTSNAME] = "2.2.12"; +static char linux_osrelease[LINUX_MAX_UTSNAME] = "2.4.2"; static int linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS) diff --git a/sys/compat/linux/linux_misc.c b/sys/compat/linux/linux_misc.c index 6c270fc..a717d81 100644 --- a/sys/compat/linux/linux_misc.c +++ b/sys/compat/linux/linux_misc.c @@ -40,6 +40,7 @@ #include <sys/mount.h> #include <sys/mutex.h> #include <sys/namei.h> +#include <sys/poll.h> #include <sys/proc.h> #include <sys/blist.h> #include <sys/reboot.h> @@ -85,87 +86,79 @@ (((sig) <= LINUX_SIGTBLSZ) ? bsd_to_linux_signal[_SIG_IDX(sig)] : sig) #endif -struct linux_rlimit { - unsigned long rlim_cur; - unsigned long rlim_max; -}; - #ifndef __alpha__ -static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = -{ RLIMIT_CPU, RLIMIT_FSIZE, RLIMIT_DATA, RLIMIT_STACK, - RLIMIT_CORE, RLIMIT_RSS, RLIMIT_NPROC, RLIMIT_NOFILE, - RLIMIT_MEMLOCK, -1 +static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = { + RLIMIT_CPU, RLIMIT_FSIZE, RLIMIT_DATA, RLIMIT_STACK, + RLIMIT_CORE, RLIMIT_RSS, RLIMIT_NPROC, RLIMIT_NOFILE, + RLIMIT_MEMLOCK, -1 }; #endif /*!__alpha__*/ -struct linux_sysinfo { - long uptime; /* Seconds since boot */ - unsigned long loads[3]; /* 1, 5, and 15 minute load averages */ - unsigned long totalram; /* Total usable main memory size */ - unsigned long freeram; /* Available memory size */ - unsigned long sharedram; /* Amount of shared memory */ - unsigned long bufferram; /* Memory used by buffers */ - unsigned long totalswap; /* Total swap space size */ - unsigned long freeswap; /* swap space still available */ - unsigned short procs; /* Number of current processes */ - char _f[22]; /* Pads structure to 64 bytes */ +struct l_sysinfo { + l_long uptime; /* Seconds since boot */ + l_ulong loads[3]; /* 1, 5, and 15 minute load averages */ + l_ulong totalram; /* Total usable main memory size */ + l_ulong freeram; /* Available memory size */ + l_ulong sharedram; /* Amount of shared memory */ + l_ulong bufferram; /* Memory used by buffers */ + l_ulong totalswap; /* Total swap space size */ + l_ulong freeswap; /* swap space still available */ + l_ushort procs; /* Number of current processes */ + char _f[22]; /* Pads structure to 64 bytes */ }; - #ifndef __alpha__ int linux_sysinfo(struct proc *p, struct linux_sysinfo_args *args) { - struct linux_sysinfo sysinfo; - vm_object_t object; - int i; - struct timespec ts; - - /* Uptime is copied out of print_uptime() procedure in kern_shutdown.c */ - getnanouptime(&ts); - i = 0; - if (ts.tv_sec >= 86400) { - ts.tv_sec %= 86400; - i = 1; - } - if (i || ts.tv_sec >= 3600) { - ts.tv_sec %= 3600; - i = 1; - } - if (i || ts.tv_sec >= 60) { - ts.tv_sec %= 60; - i = 1; - } - sysinfo.uptime=ts.tv_sec; - - /* Use the information from the mib to get our load averages */ - for (i = 0; i < 3; i++) - sysinfo.loads[i] = averunnable.ldavg[i]; - - sysinfo.totalram = physmem * PAGE_SIZE; - sysinfo.freeram = sysinfo.totalram - cnt.v_wire_count * PAGE_SIZE; - - sysinfo.sharedram = 0; - for (object = TAILQ_FIRST(&vm_object_list); object != NULL; - object = TAILQ_NEXT(object, object_list)) - if (object->shadow_count > 1) - sysinfo.sharedram += object->resident_page_count; - - sysinfo.sharedram *= PAGE_SIZE; - - sysinfo.bufferram = 0; - - if (swapblist == NULL) { - sysinfo.totalswap= 0; - sysinfo.freeswap = 0; - } else { - sysinfo.totalswap = swapblist->bl_blocks * 1024; - sysinfo.freeswap = swapblist->bl_root->u.bmu_avail * PAGE_SIZE; - } - - sysinfo.procs = 20; /* Hack */ - - return copyout((caddr_t)&sysinfo, (caddr_t)args->info, - sizeof(struct linux_sysinfo)); + struct l_sysinfo sysinfo; + vm_object_t object; + int i; + struct timespec ts; + + /* Uptime is copied out of print_uptime() in kern_shutdown.c */ + getnanouptime(&ts); + i = 0; + if (ts.tv_sec >= 86400) { + ts.tv_sec %= 86400; + i = 1; + } + if (i || ts.tv_sec >= 3600) { + ts.tv_sec %= 3600; + i = 1; + } + if (i || ts.tv_sec >= 60) { + ts.tv_sec %= 60; + i = 1; + } + sysinfo.uptime=ts.tv_sec; + + /* Use the information from the mib to get our load averages */ + for (i = 0; i < 3; i++) + sysinfo.loads[i] = averunnable.ldavg[i]; + + sysinfo.totalram = physmem * PAGE_SIZE; + sysinfo.freeram = sysinfo.totalram - cnt.v_wire_count * PAGE_SIZE; + + sysinfo.sharedram = 0; + for (object = TAILQ_FIRST(&vm_object_list); object != NULL; + object = TAILQ_NEXT(object, object_list)) + if (object->shadow_count > 1) + sysinfo.sharedram += object->resident_page_count; + + sysinfo.sharedram *= PAGE_SIZE; + sysinfo.bufferram = 0; + + if (swapblist == NULL) { + sysinfo.totalswap= 0; + sysinfo.freeswap = 0; + } else { + sysinfo.totalswap = swapblist->bl_blocks * 1024; + sysinfo.freeswap = swapblist->bl_root->u.bmu_avail * PAGE_SIZE; + } + + sysinfo.procs = 20; /* Hack */ + + return copyout(&sysinfo, (caddr_t)args->info, sizeof(sysinfo)); } #endif /*!__alpha__*/ @@ -173,475 +166,427 @@ linux_sysinfo(struct proc *p, struct linux_sysinfo_args *args) int linux_alarm(struct proc *p, struct linux_alarm_args *args) { - struct itimerval it, old_it; - struct timeval tv; - int s; + struct itimerval it, old_it; + struct timeval tv; + int s; #ifdef DEBUG if (ldebug(alarm)) printf(ARGS(alarm, "%u"), args->secs); #endif - if (args->secs > 100000000) - return EINVAL; - it.it_value.tv_sec = (long)args->secs; - it.it_value.tv_usec = 0; - it.it_interval.tv_sec = 0; - it.it_interval.tv_usec = 0; - s = splsoftclock(); - old_it = p->p_realtimer; - getmicrouptime(&tv); - if (timevalisset(&old_it.it_value)) - callout_stop(&p->p_itcallout); - if (it.it_value.tv_sec != 0) { - callout_reset(&p->p_itcallout, tvtohz(&it.it_value), realitexpire, p); - timevaladd(&it.it_value, &tv); - } - p->p_realtimer = it; - splx(s); - if (timevalcmp(&old_it.it_value, &tv, >)) { - timevalsub(&old_it.it_value, &tv); - if (old_it.it_value.tv_usec != 0) - old_it.it_value.tv_sec++; - p->p_retval[0] = old_it.it_value.tv_sec; - } - return 0; + + if (args->secs > 100000000) + return EINVAL; + + it.it_value.tv_sec = (long)args->secs; + it.it_value.tv_usec = 0; + it.it_interval.tv_sec = 0; + it.it_interval.tv_usec = 0; + s = splsoftclock(); + old_it = p->p_realtimer; + getmicrouptime(&tv); + if (timevalisset(&old_it.it_value)) + callout_stop(&p->p_itcallout); + if (it.it_value.tv_sec != 0) { + callout_reset(&p->p_itcallout, tvtohz(&it.it_value), + realitexpire, p); + timevaladd(&it.it_value, &tv); + } + p->p_realtimer = it; + splx(s); + if (timevalcmp(&old_it.it_value, &tv, >)) { + timevalsub(&old_it.it_value, &tv); + if (old_it.it_value.tv_usec != 0) + old_it.it_value.tv_sec++; + p->p_retval[0] = old_it.it_value.tv_sec; + } + return 0; } #endif /*!__alpha__*/ int linux_brk(struct proc *p, struct linux_brk_args *args) { -#if 0 - struct vmspace *vm = p->p_vmspace; - vm_offset_t new, old; - int error; - - if ((vm_offset_t)args->dsend < (vm_offset_t)vm->vm_daddr) - return EINVAL; - if (((caddr_t)args->dsend - (caddr_t)vm->vm_daddr) - > p->p_rlimit[RLIMIT_DATA].rlim_cur) - return ENOMEM; - - old = round_page((vm_offset_t)vm->vm_daddr) + ctob(vm->vm_dsize); - new = round_page((vm_offset_t)args->dsend); - p->p_retval[0] = old; - if ((new-old) > 0) { - if (swap_pager_full) - return ENOMEM; - error = vm_map_find(&vm->vm_map, NULL, 0, &old, (new-old), FALSE, - VM_PROT_ALL, VM_PROT_ALL, 0); - if (error) - return error; - vm->vm_dsize += btoc((new-old)); - p->p_retval[0] = (int)(vm->vm_daddr + ctob(vm->vm_dsize)); - } - return 0; -#else - struct vmspace *vm = p->p_vmspace; - vm_offset_t new, old; - struct obreak_args /* { - char * nsize; - } */ tmp; + struct vmspace *vm = p->p_vmspace; + vm_offset_t new, old; + struct obreak_args /* { + char * nsize; + } */ tmp; #ifdef DEBUG if (ldebug(brk)) printf(ARGS(brk, "%p"), (void *)args->dsend); #endif - old = (vm_offset_t)vm->vm_daddr + ctob(vm->vm_dsize); - new = (vm_offset_t)args->dsend; - tmp.nsize = (char *) new; - if (((caddr_t)new > vm->vm_daddr) && !obreak(p, &tmp)) - p->p_retval[0] = (long)new; - else - p->p_retval[0] = (long)old; - - return 0; -#endif + old = (vm_offset_t)vm->vm_daddr + ctob(vm->vm_dsize); + new = (vm_offset_t)args->dsend; + tmp.nsize = (char *) new; + if (((caddr_t)new > vm->vm_daddr) && !obreak(p, &tmp)) + p->p_retval[0] = (long)new; + else + p->p_retval[0] = (long)old; + + return 0; } int linux_uselib(struct proc *p, struct linux_uselib_args *args) { - struct nameidata ni; - struct vnode *vp; - struct exec *a_out; - struct vattr attr; - vm_offset_t vmaddr; - unsigned long file_offset; - vm_offset_t buffer; - unsigned long bss_size; - int error; - caddr_t sg; - int locked; - - sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->library); + struct nameidata ni; + struct vnode *vp; + struct exec *a_out; + struct vattr attr; + vm_offset_t vmaddr; + unsigned long file_offset; + vm_offset_t buffer; + unsigned long bss_size; + int error; + caddr_t sg; + int locked; + + sg = stackgap_init(); + CHECKALTEXIST(p, &sg, args->library); #ifdef DEBUG if (ldebug(uselib)) printf(ARGS(uselib, "%s"), args->library); #endif - a_out = NULL; - locked = 0; - vp = NULL; - - NDINIT(&ni, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, args->library, p); - error = namei(&ni); - if (error) - goto cleanup; - - vp = ni.ni_vp; - /* - * XXX This looks like a bogus check - a LOCKLEAF namei should not succeed - * without returning a vnode. - */ - if (vp == NULL) { - error = ENOEXEC; /* ?? */ - goto cleanup; - } - NDFREE(&ni, NDF_ONLY_PNBUF); - - /* - * From here on down, we have a locked vnode that must be unlocked. - */ - locked++; - - /* - * Writable? - */ - if (vp->v_writecount) { - error = ETXTBSY; - goto cleanup; - } - - /* - * Executable? - */ - error = VOP_GETATTR(vp, &attr, p->p_ucred, p); - if (error) - goto cleanup; - - if ((vp->v_mount->mnt_flag & MNT_NOEXEC) || - ((attr.va_mode & 0111) == 0) || - (attr.va_type != VREG)) { - error = ENOEXEC; - goto cleanup; - } - - /* - * Sensible size? - */ - if (attr.va_size == 0) { - error = ENOEXEC; - goto cleanup; - } - - /* - * Can we access it? - */ - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); - if (error) - goto cleanup; - - error = VOP_OPEN(vp, FREAD, p->p_ucred, p); - if (error) - goto cleanup; - - /* - * Lock no longer needed - */ - VOP_UNLOCK(vp, 0, p); - locked = 0; - - /* - * Pull in executable header into kernel_map - */ - error = vm_mmap(kernel_map, (vm_offset_t *)&a_out, PAGE_SIZE, - VM_PROT_READ, VM_PROT_READ, 0, (caddr_t)vp, 0); - if (error) - goto cleanup; - - /* - * Is it a Linux binary ? - */ - if (((a_out->a_magic >> 16) & 0xff) != 0x64) { - error = ENOEXEC; - goto cleanup; - } - - /* While we are here, we should REALLY do some more checks */ - - /* - * Set file/virtual offset based on a.out variant. - */ - switch ((int)(a_out->a_magic & 0xffff)) { - case 0413: /* ZMAGIC */ - file_offset = 1024; - break; - case 0314: /* QMAGIC */ - file_offset = 0; - break; - default: - error = ENOEXEC; - goto cleanup; - } - - bss_size = round_page(a_out->a_bss); - - /* - * Check various fields in header for validity/bounds. - */ - if (a_out->a_text & PAGE_MASK || a_out->a_data & PAGE_MASK) { - error = ENOEXEC; - goto cleanup; - } - - /* text + data can't exceed file size */ - if (a_out->a_data + a_out->a_text > attr.va_size) { - error = EFAULT; - goto cleanup; - } - - /* To protect p->p_rlimit in the if condition. */ - mtx_assert(&Giant, MA_OWNED); - - /* - * text/data/bss must not exceed limits - * XXX: this is not complete. it should check current usage PLUS - * the resources needed by this library. - */ - if (a_out->a_text > MAXTSIZ || - a_out->a_data + bss_size > p->p_rlimit[RLIMIT_DATA].rlim_cur) { - error = ENOMEM; - goto cleanup; - } - - /* - * prevent more writers - */ - vp->v_flag |= VTEXT; - - /* - * Check if file_offset page aligned,. - * Currently we cannot handle misalinged file offsets, - * and so we read in the entire image (what a waste). - */ - if (file_offset & PAGE_MASK) { -#ifdef DEBUG -printf("uselib: Non page aligned binary %lu\n", file_offset); -#endif + a_out = NULL; + locked = 0; + vp = NULL; + + NDINIT(&ni, LOOKUP, FOLLOW|LOCKLEAF, UIO_USERSPACE, args->library, p); + error = namei(&ni); + if (error) + goto cleanup; + + vp = ni.ni_vp; /* - * Map text+data read/write/execute + * XXX - This looks like a bogus check. A LOCKLEAF namei should not + * succeed without returning a vnode. */ + if (vp == NULL) { + error = ENOEXEC; /* ?? */ + goto cleanup; + } + NDFREE(&ni, NDF_ONLY_PNBUF); - /* a_entry is the load address and is page aligned */ - vmaddr = trunc_page(a_out->a_entry); + /* + * From here on down, we have a locked vnode that must be unlocked. + */ + locked++; - /* get anon user mapping, read+write+execute */ - error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &vmaddr, - a_out->a_text + a_out->a_data, FALSE, - VM_PROT_ALL, VM_PROT_ALL, 0); - if (error) - goto cleanup; + /* Writable? */ + if (vp->v_writecount) { + error = ETXTBSY; + goto cleanup; + } - /* map file into kernel_map */ - error = vm_mmap(kernel_map, &buffer, - round_page(a_out->a_text + a_out->a_data + file_offset), - VM_PROT_READ, VM_PROT_READ, 0, - (caddr_t)vp, trunc_page(file_offset)); + /* Executable? */ + error = VOP_GETATTR(vp, &attr, p->p_ucred, p); if (error) - goto cleanup; + goto cleanup; - /* copy from kernel VM space to user space */ - error = copyout((caddr_t)(void *)(uintptr_t)(buffer + file_offset), - (caddr_t)vmaddr, a_out->a_text + a_out->a_data); + if ((vp->v_mount->mnt_flag & MNT_NOEXEC) || + ((attr.va_mode & 0111) == 0) || (attr.va_type != VREG)) { + error = ENOEXEC; + goto cleanup; + } - /* release temporary kernel space */ - vm_map_remove(kernel_map, buffer, - buffer + round_page(a_out->a_text + a_out->a_data + file_offset)); + /* Sensible size? */ + if (attr.va_size == 0) { + error = ENOEXEC; + goto cleanup; + } + /* Can we access it? */ + error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); if (error) - goto cleanup; - } - else { -#ifdef DEBUG -printf("uselib: Page aligned binary %lu\n", file_offset); -#endif + goto cleanup; + + error = VOP_OPEN(vp, FREAD, p->p_ucred, p); + if (error) + goto cleanup; + /* - * for QMAGIC, a_entry is 20 bytes beyond the load address - * to skip the executable header + * Lock no longer needed */ - vmaddr = trunc_page(a_out->a_entry); + VOP_UNLOCK(vp, 0, p); + locked = 0; + + /* Pull in executable header into kernel_map */ + error = vm_mmap(kernel_map, (vm_offset_t *)&a_out, PAGE_SIZE, + VM_PROT_READ, VM_PROT_READ, 0, (caddr_t)vp, 0); + if (error) + goto cleanup; + + /* Is it a Linux binary ? */ + if (((a_out->a_magic >> 16) & 0xff) != 0x64) { + error = ENOEXEC; + goto cleanup; + } /* - * Map it all into the process's space as a single copy-on-write - * "data" segment. + * While we are here, we should REALLY do some more checks */ - error = vm_mmap(&p->p_vmspace->vm_map, &vmaddr, - a_out->a_text + a_out->a_data, - VM_PROT_ALL, VM_PROT_ALL, MAP_PRIVATE | MAP_FIXED, - (caddr_t)vp, file_offset); - if (error) - goto cleanup; - } -#ifdef DEBUG -printf("mem=%08lx = %08lx %08lx\n", (long)vmaddr, ((long*)vmaddr)[0], ((long*)vmaddr)[1]); -#endif - if (bss_size != 0) { - /* - * Calculate BSS start address + + /* Set file/virtual offset based on a.out variant. */ + switch ((int)(a_out->a_magic & 0xffff)) { + case 0413: /* ZMAGIC */ + file_offset = 1024; + break; + case 0314: /* QMAGIC */ + file_offset = 0; + break; + default: + error = ENOEXEC; + goto cleanup; + } + + bss_size = round_page(a_out->a_bss); + + /* Check various fields in header for validity/bounds. */ + if (a_out->a_text & PAGE_MASK || a_out->a_data & PAGE_MASK) { + error = ENOEXEC; + goto cleanup; + } + + /* text + data can't exceed file size */ + if (a_out->a_data + a_out->a_text > attr.va_size) { + error = EFAULT; + goto cleanup; + } + + /* To protect p->p_rlimit in the if condition. */ + mtx_assert(&Giant, MA_OWNED); + + /* + * text/data/bss must not exceed limits + * XXX - this is not complete. it should check current usage PLUS + * the resources needed by this library. */ - vmaddr = trunc_page(a_out->a_entry) + a_out->a_text + a_out->a_data; + if (a_out->a_text > MAXTSIZ || + a_out->a_data + bss_size > p->p_rlimit[RLIMIT_DATA].rlim_cur) { + error = ENOMEM; + goto cleanup; + } + + /* prevent more writers */ + vp->v_flag |= VTEXT; /* - * allocate some 'anon' space + * Check if file_offset page aligned. Currently we cannot handle + * misalinged file offsets, and so we read in the entire image + * (what a waste). */ - error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &vmaddr, - bss_size, FALSE, - VM_PROT_ALL, VM_PROT_ALL, 0); - if (error) - goto cleanup; - } + if (file_offset & PAGE_MASK) { +#ifdef DEBUG + printf("uselib: Non page aligned binary %lu\n", file_offset); +#endif + /* Map text+data read/write/execute */ + + /* a_entry is the load address and is page aligned */ + vmaddr = trunc_page(a_out->a_entry); + + /* get anon user mapping, read+write+execute */ + error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &vmaddr, + a_out->a_text + a_out->a_data, FALSE, VM_PROT_ALL, + VM_PROT_ALL, 0); + if (error) + goto cleanup; + + /* map file into kernel_map */ + error = vm_mmap(kernel_map, &buffer, + round_page(a_out->a_text + a_out->a_data + file_offset), + VM_PROT_READ, VM_PROT_READ, 0, (caddr_t)vp, + trunc_page(file_offset)); + if (error) + goto cleanup; + + /* copy from kernel VM space to user space */ + error = copyout((caddr_t)(uintptr_t)(buffer + file_offset), + (caddr_t)vmaddr, a_out->a_text + a_out->a_data); + + /* release temporary kernel space */ + vm_map_remove(kernel_map, buffer, buffer + + round_page(a_out->a_text + a_out->a_data + file_offset)); + + if (error) + goto cleanup; + } else { +#ifdef DEBUG + printf("uselib: Page aligned binary %lu\n", file_offset); +#endif + /* + * for QMAGIC, a_entry is 20 bytes beyond the load address + * to skip the executable header + */ + vmaddr = trunc_page(a_out->a_entry); + + /* + * Map it all into the process's space as a single + * copy-on-write "data" segment. + */ + error = vm_mmap(&p->p_vmspace->vm_map, &vmaddr, + a_out->a_text + a_out->a_data, VM_PROT_ALL, VM_PROT_ALL, + MAP_PRIVATE | MAP_FIXED, (caddr_t)vp, file_offset); + if (error) + goto cleanup; + } +#ifdef DEBUG + printf("mem=%08lx = %08lx %08lx\n", (long)vmaddr, ((long*)vmaddr)[0], + ((long*)vmaddr)[1]); +#endif + if (bss_size != 0) { + /* Calculate BSS start address */ + vmaddr = trunc_page(a_out->a_entry) + a_out->a_text + + a_out->a_data; + + /* allocate some 'anon' space */ + error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &vmaddr, + bss_size, FALSE, VM_PROT_ALL, VM_PROT_ALL, 0); + if (error) + goto cleanup; + } cleanup: - /* - * Unlock vnode if needed - */ - if (locked) - VOP_UNLOCK(vp, 0, p); + /* Unlock vnode if needed */ + if (locked) + VOP_UNLOCK(vp, 0, p); - /* - * Release the kernel mapping. - */ - if (a_out) - vm_map_remove(kernel_map, (vm_offset_t)a_out, (vm_offset_t)a_out + PAGE_SIZE); + /* Release the kernel mapping. */ + if (a_out) + vm_map_remove(kernel_map, (vm_offset_t)a_out, + (vm_offset_t)a_out + PAGE_SIZE); - return error; + return error; } int -linux_newselect(struct proc *p, struct linux_newselect_args *args) +linux_select(struct proc *p, struct linux_select_args *args) { - struct select_args bsa; - struct timeval tv0, tv1, utv, *tvp; - caddr_t sg; - int error; + struct select_args bsa; + struct timeval tv0, tv1, utv, *tvp; + caddr_t sg; + int error; #ifdef DEBUG - if (ldebug(newselect)) - printf(ARGS(newselect, "%d, %p, %p, %p, %p"), - args->nfds, (void *)args->readfds, - (void *)args->writefds, (void *)args->exceptfds, - (void *)args->timeout); + if (ldebug(select)) + printf(ARGS(select, "%d, %p, %p, %p, %p"), args->nfds, + (void *)args->readfds, (void *)args->writefds, + (void *)args->exceptfds, (void *)args->timeout); #endif - error = 0; - bsa.nd = args->nfds; - bsa.in = args->readfds; - bsa.ou = args->writefds; - bsa.ex = args->exceptfds; - bsa.tv = args->timeout; - - /* - * Store current time for computation of the amount of - * time left. - */ - if (args->timeout) { - if ((error = copyin(args->timeout, &utv, sizeof(utv)))) - goto select_out; + + error = 0; + bsa.nd = args->nfds; + bsa.in = args->readfds; + bsa.ou = args->writefds; + bsa.ex = args->exceptfds; + bsa.tv = (struct timeval *)args->timeout; + + /* + * Store current time for computation of the amount of + * time left. + */ + if (args->timeout) { + if ((error = copyin((caddr_t)args->timeout, &utv, + sizeof(utv)))) + goto select_out; #ifdef DEBUG - if (ldebug(newselect)) - printf(LMSG("incoming timeout (%ld/%ld)"), - utv.tv_sec, utv.tv_usec); + if (ldebug(select)) + printf(LMSG("incoming timeout (%ld/%ld)"), + utv.tv_sec, utv.tv_usec); #endif - if (itimerfix(&utv)) { - /* - * The timeval was invalid. Convert it to something - * valid that will act as it does under Linux. - */ - sg = stackgap_init(); - tvp = stackgap_alloc(&sg, sizeof(utv)); - utv.tv_sec += utv.tv_usec / 1000000; - utv.tv_usec %= 1000000; - if (utv.tv_usec < 0) { - utv.tv_sec -= 1; - utv.tv_usec += 1000000; - } - if (utv.tv_sec < 0) - timevalclear(&utv); - if ((error = copyout(&utv, tvp, sizeof(utv)))) - goto select_out; - bsa.tv = tvp; + + if (itimerfix(&utv)) { + /* + * The timeval was invalid. Convert it to something + * valid that will act as it does under Linux. + */ + sg = stackgap_init(); + tvp = stackgap_alloc(&sg, sizeof(utv)); + utv.tv_sec += utv.tv_usec / 1000000; + utv.tv_usec %= 1000000; + if (utv.tv_usec < 0) { + utv.tv_sec -= 1; + utv.tv_usec += 1000000; + } + if (utv.tv_sec < 0) + timevalclear(&utv); + if ((error = copyout(&utv, tvp, sizeof(utv)))) + goto select_out; + bsa.tv = tvp; + } + microtime(&tv0); } - microtime(&tv0); - } - error = select(p, &bsa); + error = select(p, &bsa); #ifdef DEBUG - if (ldebug(newselect)) + if (ldebug(select)) printf(LMSG("real select returns %d"), error); #endif + if (error) { + /* + * See fs/select.c in the Linux kernel. Without this, + * Maelstrom doesn't work. + */ + if (error == ERESTART) + error = EINTR; + goto select_out; + } - if (error) { - /* - * See fs/select.c in the Linux kernel. Without this, - * Maelstrom doesn't work. - */ - if (error == ERESTART) - error = EINTR; - goto select_out; - } - - if (args->timeout) { - if (p->p_retval[0]) { - /* - * Compute how much time was left of the timeout, - * by subtracting the current time and the time - * before we started the call, and subtracting - * that result from the user-supplied value. - */ - microtime(&tv1); - timevalsub(&tv1, &tv0); - timevalsub(&utv, &tv1); - if (utv.tv_sec < 0) - timevalclear(&utv); - } else - timevalclear(&utv); + if (args->timeout) { + if (p->p_retval[0]) { + /* + * Compute how much time was left of the timeout, + * by subtracting the current time and the time + * before we started the call, and subtracting + * that result from the user-supplied value. + */ + microtime(&tv1); + timevalsub(&tv1, &tv0); + timevalsub(&utv, &tv1); + if (utv.tv_sec < 0) + timevalclear(&utv); + } else + timevalclear(&utv); #ifdef DEBUG - if (ldebug(newselect)) - printf(LMSG("outgoing timeout (%ld/%ld)"), - utv.tv_sec, utv.tv_usec); + if (ldebug(select)) + printf(LMSG("outgoing timeout (%ld/%ld)"), + utv.tv_sec, utv.tv_usec); #endif - if ((error = copyout(&utv, args->timeout, sizeof(utv)))) - goto select_out; - } + if ((error = copyout(&utv, (caddr_t)args->timeout, + sizeof(utv)))) + goto select_out; + } select_out: #ifdef DEBUG - if (ldebug(newselect)) - printf(LMSG("newselect_out -> %d"), error); + if (ldebug(select)) + printf(LMSG("select_out -> %d"), error); #endif - return error; + return error; } int linux_getpgid(struct proc *p, struct linux_getpgid_args *args) { - struct proc *curp; + struct proc *curp; #ifdef DEBUG if (ldebug(getpgid)) printf(ARGS(getpgid, "%d"), args->pid); #endif - if (args->pid != p->p_pid) { - if (!(curp = pfind(args->pid))) - return ESRCH; - p->p_retval[0] = curp->p_pgid; - PROC_UNLOCK(curp); - } - else - p->p_retval[0] = p->p_pgid; - return 0; + + if (args->pid != p->p_pid) { + if (!(curp = pfind(args->pid))) + return ESRCH; + p->p_retval[0] = curp->p_pgid; + PROC_UNLOCK(curp); + } else + p->p_retval[0] = p->p_pgid; + + return 0; } int @@ -670,7 +615,7 @@ linux_mremap(struct proc *p, struct linux_mremap_args *args) } if (args->new_len < args->old_len) { - bsd_args.addr = args->addr + args->new_len; + bsd_args.addr = (caddr_t)(args->addr + args->new_len); bsd_args.len = args->old_len - args->new_len; error = munmap(p, &bsd_args); } @@ -684,7 +629,7 @@ linux_msync(struct proc *p, struct linux_msync_args *args) { struct msync_args bsd_args; - bsd_args.addr = args->addr; + bsd_args.addr = (caddr_t)args->addr; bsd_args.len = args->len; bsd_args.flags = 0; /* XXX ignore */ @@ -695,28 +640,29 @@ linux_msync(struct proc *p, struct linux_msync_args *args) int linux_time(struct proc *p, struct linux_time_args *args) { - struct timeval tv; - linux_time_t tm; - int error; + struct timeval tv; + l_time_t tm; + int error; #ifdef DEBUG if (ldebug(time)) printf(ARGS(time, "*")); #endif - microtime(&tv); - tm = tv.tv_sec; - if (args->tm && (error = copyout(&tm, args->tm, sizeof(linux_time_t)))) - return error; - p->p_retval[0] = tm; - return 0; + + microtime(&tv); + tm = tv.tv_sec; + if (args->tm && (error = copyout(&tm, (caddr_t)args->tm, sizeof(tm)))) + return error; + p->p_retval[0] = tm; + return 0; } #endif /*!__alpha__*/ -struct linux_times_argv { - long tms_utime; - long tms_stime; - long tms_cutime; - long tms_cstime; +struct l_times_argv { + l_long tms_utime; + l_long tms_stime; + l_long tms_cutime; + l_long tms_cstime; }; #ifdef __alpha__ @@ -730,38 +676,38 @@ struct linux_times_argv { int linux_times(struct proc *p, struct linux_times_args *args) { - struct timeval tv; - struct linux_times_argv tms; - struct rusage ru; - int error; + struct timeval tv; + struct l_times_argv tms; + struct rusage ru; + int error; #ifdef DEBUG if (ldebug(times)) printf(ARGS(times, "*")); #endif - mtx_lock_spin(&sched_lock); - calcru(p, &ru.ru_utime, &ru.ru_stime, NULL); - mtx_unlock_spin(&sched_lock); - tms.tms_utime = CONVTCK(ru.ru_utime); - tms.tms_stime = CONVTCK(ru.ru_stime); + mtx_lock_spin(&sched_lock); + calcru(p, &ru.ru_utime, &ru.ru_stime, NULL); + mtx_unlock_spin(&sched_lock); - tms.tms_cutime = CONVTCK(p->p_stats->p_cru.ru_utime); - tms.tms_cstime = CONVTCK(p->p_stats->p_cru.ru_stime); + tms.tms_utime = CONVTCK(ru.ru_utime); + tms.tms_stime = CONVTCK(ru.ru_stime); - if ((error = copyout((caddr_t)&tms, (caddr_t)args->buf, - sizeof(struct linux_times_argv)))) - return error; + tms.tms_cutime = CONVTCK(p->p_stats->p_cru.ru_utime); + tms.tms_cstime = CONVTCK(p->p_stats->p_cru.ru_stime); + + if ((error = copyout(&tms, (caddr_t)args->buf, sizeof(tms)))) + return error; - microuptime(&tv); - p->p_retval[0] = (int)CONVTCK(tv); - return 0; + microuptime(&tv); + p->p_retval[0] = (int)CONVTCK(tv); + return 0; } int linux_newuname(struct proc *p, struct linux_newuname_args *args) { - struct linux_new_utsname utsname; + struct l_new_utsname utsname; char *osrelease, *osname; #ifdef DEBUG @@ -772,7 +718,7 @@ linux_newuname(struct proc *p, struct linux_newuname_args *args) osname = linux_get_osname(p); osrelease = linux_get_osrelease(p); - bzero(&utsname, sizeof(struct linux_new_utsname)); + bzero(&utsname, sizeof(utsname)); strncpy(utsname.sysname, osname, LINUX_MAX_UTSNAME-1); strncpy(utsname.nodename, hostname, LINUX_MAX_UTSNAME-1); strncpy(utsname.release, osrelease, LINUX_MAX_UTSNAME-1); @@ -780,54 +726,56 @@ linux_newuname(struct proc *p, struct linux_newuname_args *args) strncpy(utsname.machine, machine, LINUX_MAX_UTSNAME-1); strncpy(utsname.domainname, domainname, LINUX_MAX_UTSNAME-1); - return (copyout((caddr_t)&utsname, (caddr_t)args->buf, - sizeof(struct linux_new_utsname))); + return (copyout(&utsname, (caddr_t)args->buf, sizeof(utsname))); } -struct linux_utimbuf { - linux_time_t l_actime; - linux_time_t l_modtime; +#if defined(__i386__) +struct l_utimbuf { + l_time_t l_actime; + l_time_t l_modtime; }; int linux_utime(struct proc *p, struct linux_utime_args *args) { - struct utimes_args /* { - char *path; - struct timeval *tptr; - } */ bsdutimes; - struct timeval tv[2], *tvp; - struct linux_utimbuf lut; - int error; - caddr_t sg; - - sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->fname); + struct utimes_args /* { + char *path; + struct timeval *tptr; + } */ bsdutimes; + struct timeval tv[2], *tvp; + struct l_utimbuf lut; + int error; + caddr_t sg; + + sg = stackgap_init(); + CHECKALTEXIST(p, &sg, args->fname); #ifdef DEBUG if (ldebug(utime)) printf(ARGS(utime, "%s, *"), args->fname); #endif - if (args->times) { - if ((error = copyin(args->times, &lut, sizeof lut))) - return error; - tv[0].tv_sec = lut.l_actime; - tv[0].tv_usec = 0; - tv[1].tv_sec = lut.l_modtime; - tv[1].tv_usec = 0; - /* so that utimes can copyin */ - tvp = (struct timeval *)stackgap_alloc(&sg, sizeof(tv)); - if (tvp == NULL) - return (ENAMETOOLONG); - if ((error = copyout(tv, tvp, sizeof(tv)))) - return error; - bsdutimes.tptr = tvp; - } else - bsdutimes.tptr = NULL; - - bsdutimes.path = args->fname; - return utimes(p, &bsdutimes); + + if (args->times) { + if ((error = copyin((caddr_t)args->times, &lut, sizeof lut))) + return error; + tv[0].tv_sec = lut.l_actime; + tv[0].tv_usec = 0; + tv[1].tv_sec = lut.l_modtime; + tv[1].tv_usec = 0; + /* so that utimes can copyin */ + tvp = (struct timeval *)stackgap_alloc(&sg, sizeof(tv)); + if (tvp == NULL) + return (ENAMETOOLONG); + if ((error = copyout(tv, tvp, sizeof(tv)))) + return error; + bsdutimes.tptr = tvp; + } else + bsdutimes.tptr = NULL; + + bsdutimes.path = args->fname; + return utimes(p, &bsdutimes); } +#endif /* __i386__ */ #define __WCLONE 0x80000000 @@ -835,42 +783,45 @@ linux_utime(struct proc *p, struct linux_utime_args *args) int linux_waitpid(struct proc *p, struct linux_waitpid_args *args) { - struct wait_args /* { - int pid; - int *status; - int options; - struct rusage *rusage; - } */ tmp; - int error, tmpstat; + struct wait_args /* { + int pid; + int *status; + int options; + struct rusage *rusage; + } */ tmp; + int error, tmpstat; #ifdef DEBUG if (ldebug(waitpid)) printf(ARGS(waitpid, "%d, %p, %d"), args->pid, (void *)args->status, args->options); #endif - tmp.pid = args->pid; - tmp.status = args->status; - tmp.options = (args->options & (WNOHANG | WUNTRACED)); - /* WLINUXCLONE should be equal to __WCLONE, but we make sure */ - if (args->options & __WCLONE) - tmp.options |= WLINUXCLONE; - tmp.rusage = NULL; - - if ((error = wait4(p, &tmp)) != 0) - return error; - if (args->status) { - if ((error = copyin(args->status, &tmpstat, sizeof(int))) != 0) - return error; - tmpstat &= 0xffff; - if (WIFSIGNALED(tmpstat)) - tmpstat = (tmpstat & 0xffffff80) | - BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat)); - else if (WIFSTOPPED(tmpstat)) - tmpstat = (tmpstat & 0xffff00ff) | - (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8); - return copyout(&tmpstat, args->status, sizeof(int)); - } else + tmp.pid = args->pid; + tmp.status = args->status; + tmp.options = (args->options & (WNOHANG | WUNTRACED)); + /* WLINUXCLONE should be equal to __WCLONE, but we make sure */ + if (args->options & __WCLONE) + tmp.options |= WLINUXCLONE; + tmp.rusage = NULL; + + if ((error = wait4(p, &tmp)) != 0) + return error; + + if (args->status) { + if ((error = copyin((caddr_t)args->status, &tmpstat, + sizeof(int))) != 0) + return error; + tmpstat &= 0xffff; + if (WIFSIGNALED(tmpstat)) + tmpstat = (tmpstat & 0xffffff80) | + BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat)); + else if (WIFSTOPPED(tmpstat)) + tmpstat = (tmpstat & 0xffff00ff) | + (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8); + return copyout(&tmpstat, (caddr_t)args->status, sizeof(int)); + } + return 0; } #endif /*!__alpha__*/ @@ -878,13 +829,13 @@ linux_waitpid(struct proc *p, struct linux_waitpid_args *args) int linux_wait4(struct proc *p, struct linux_wait4_args *args) { - struct wait_args /* { - int pid; - int *status; - int options; - struct rusage *rusage; - } */ tmp; - int error, tmpstat; + struct wait_args /* { + int pid; + int *status; + int options; + struct rusage *rusage; + } */ tmp; + int error, tmpstat; #ifdef DEBUG if (ldebug(wait4)) @@ -892,31 +843,34 @@ linux_wait4(struct proc *p, struct linux_wait4_args *args) args->pid, (void *)args->status, args->options, (void *)args->rusage); #endif - tmp.pid = args->pid; - tmp.status = args->status; - tmp.options = (args->options & (WNOHANG | WUNTRACED)); - /* WLINUXCLONE should be equal to __WCLONE, but we make sure */ - if (args->options & __WCLONE) - tmp.options |= WLINUXCLONE; - tmp.rusage = args->rusage; - - if ((error = wait4(p, &tmp)) != 0) - return error; - SIGDELSET(p->p_siglist, SIGCHLD); - - if (args->status) { - if ((error = copyin(args->status, &tmpstat, sizeof(int))) != 0) - return error; - tmpstat &= 0xffff; - if (WIFSIGNALED(tmpstat)) - tmpstat = (tmpstat & 0xffffff80) | - BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat)); - else if (WIFSTOPPED(tmpstat)) - tmpstat = (tmpstat & 0xffff00ff) | - (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8); - return copyout(&tmpstat, args->status, sizeof(int)); - } else + tmp.pid = args->pid; + tmp.status = args->status; + tmp.options = (args->options & (WNOHANG | WUNTRACED)); + /* WLINUXCLONE should be equal to __WCLONE, but we make sure */ + if (args->options & __WCLONE) + tmp.options |= WLINUXCLONE; + tmp.rusage = (struct rusage *)args->rusage; + + if ((error = wait4(p, &tmp)) != 0) + return error; + + SIGDELSET(p->p_siglist, SIGCHLD); + + if (args->status) { + if ((error = copyin((caddr_t)args->status, &tmpstat, + sizeof(int))) != 0) + return error; + tmpstat &= 0xffff; + if (WIFSIGNALED(tmpstat)) + tmpstat = (tmpstat & 0xffffff80) | + BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat)); + else if (WIFSTOPPED(tmpstat)) + tmpstat = (tmpstat & 0xffff00ff) | + (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8); + return copyout(&tmpstat, (caddr_t)args->status, sizeof(int)); + } + return 0; } @@ -985,11 +939,10 @@ linux_setitimer(struct proc *p, struct linux_setitimer_args *args) (void *)args->itv, (void *)args->oitv); #endif bsa.which = args->which; - bsa.itv = args->itv; - bsa.oitv = args->oitv; + bsa.itv = (struct itimerval *)args->itv; + bsa.oitv = (struct itimerval *)args->oitv; if (args->itv) { - if ((error = copyin((caddr_t)args->itv, (caddr_t)&foo, - sizeof(foo)))) + if ((error = copyin((caddr_t)args->itv, &foo, sizeof(foo)))) return error; #ifdef DEBUG if (ldebug(setitimer)) { @@ -1012,7 +965,7 @@ linux_getitimer(struct proc *p, struct linux_getitimer_args *args) printf(ARGS(getitimer, "%p"), (void *)args->itv); #endif bsa.which = args->which; - bsa.itv = args->itv; + bsa.itv = (struct itimerval *)args->itv; return getitimer(p, &bsa); } @@ -1030,16 +983,14 @@ linux_nice(struct proc *p, struct linux_nice_args *args) #endif /*!__alpha__*/ int -linux_setgroups(p, uap) - struct proc *p; - struct linux_setgroups_args *uap; +linux_setgroups(struct proc *p, struct linux_setgroups_args *args) { struct ucred *newcred, *oldcred; - linux_gid_t linux_gidset[NGROUPS]; + l_gid_t linux_gidset[NGROUPS]; gid_t *bsd_gidset; int ngrp, error; - ngrp = uap->gidsetsize; + ngrp = args->gidsetsize; oldcred = p->p_ucred; /* @@ -1056,8 +1007,8 @@ linux_setgroups(p, uap) newcred = crdup(oldcred); if (ngrp > 0) { - error = copyin((caddr_t)uap->gidset, (caddr_t)linux_gidset, - ngrp * sizeof(linux_gid_t)); + error = copyin((caddr_t)args->grouplist, linux_gidset, + ngrp * sizeof(l_gid_t)); if (error) return (error); @@ -1080,12 +1031,10 @@ linux_setgroups(p, uap) } int -linux_getgroups(p, uap) - struct proc *p; - struct linux_getgroups_args *uap; +linux_getgroups(struct proc *p, struct linux_getgroups_args *args) { struct ucred *cred; - linux_gid_t linux_gidset[NGROUPS]; + l_gid_t linux_gidset[NGROUPS]; gid_t *bsd_gidset; int bsd_gidsetsz, ngrp, error; @@ -1099,7 +1048,7 @@ linux_getgroups(p, uap) * to prevent that. */ - if ((ngrp = uap->gidsetsize) == 0) { + if ((ngrp = args->gidsetsize) == 0) { p->p_retval[0] = bsd_gidsetsz; return (0); } @@ -1113,8 +1062,8 @@ linux_getgroups(p, uap) ngrp++; } - if ((error = copyout((caddr_t)linux_gidset, (caddr_t)uap->gidset, - ngrp * sizeof(linux_gid_t)))) + if ((error = copyout(linux_gidset, (caddr_t)args->grouplist, + ngrp * sizeof(l_gid_t)))) return (error); p->p_retval[0] = ngrp; @@ -1123,29 +1072,27 @@ linux_getgroups(p, uap) #ifndef __alpha__ int -linux_setrlimit(p, uap) - struct proc *p; - struct linux_setrlimit_args *uap; +linux_setrlimit(struct proc *p, struct linux_setrlimit_args *args) { struct __setrlimit_args bsd; - struct linux_rlimit rlim; + struct l_rlimit rlim; int error; caddr_t sg = stackgap_init(); #ifdef DEBUG if (ldebug(setrlimit)) printf(ARGS(setrlimit, "%d, %p"), - uap->resource, (void *)uap->rlim); + args->resource, (void *)args->rlim); #endif - if (uap->resource >= LINUX_RLIM_NLIMITS) + if (args->resource >= LINUX_RLIM_NLIMITS) return (EINVAL); - bsd.which = linux_to_bsd_resource[uap->resource]; + bsd.which = linux_to_bsd_resource[args->resource]; if (bsd.which == -1) return (EINVAL); - error = copyin(uap->rlim, &rlim, sizeof(rlim)); + error = copyin((caddr_t)args->rlim, &rlim, sizeof(rlim)); if (error) return (error); @@ -1156,25 +1103,23 @@ linux_setrlimit(p, uap) } int -linux_getrlimit(p, uap) - struct proc *p; - struct linux_getrlimit_args *uap; +linux_old_getrlimit(struct proc *p, struct linux_old_getrlimit_args *args) { struct __getrlimit_args bsd; - struct linux_rlimit rlim; + struct l_rlimit rlim; int error; caddr_t sg = stackgap_init(); #ifdef DEBUG - if (ldebug(getrlimit)) - printf(ARGS(getrlimit, "%d, %p"), - uap->resource, (void *)uap->rlim); + if (ldebug(old_getrlimit)) + printf(ARGS(old_getrlimit, "%d, %p"), + args->resource, (void *)args->rlim); #endif - if (uap->resource >= LINUX_RLIM_NLIMITS) + if (args->resource >= LINUX_RLIM_NLIMITS) return (EINVAL); - bsd.which = linux_to_bsd_resource[uap->resource]; + bsd.which = linux_to_bsd_resource[args->resource]; if (bsd.which == -1) return (EINVAL); @@ -1189,24 +1134,54 @@ linux_getrlimit(p, uap) rlim.rlim_max = (unsigned long)bsd.rlp->rlim_max; if (rlim.rlim_max == ULONG_MAX) rlim.rlim_max = LONG_MAX; - return (copyout(&rlim, uap->rlim, sizeof(rlim))); + return (copyout(&rlim, (caddr_t)args->rlim, sizeof(rlim))); +} + +int +linux_getrlimit(struct proc *p, struct linux_getrlimit_args *args) +{ + struct __getrlimit_args bsd; + struct l_rlimit rlim; + int error; + caddr_t sg = stackgap_init(); + +#ifdef DEBUG + if (ldebug(getrlimit)) + printf(ARGS(getrlimit, "%d, %p"), + args->resource, (void *)args->rlim); +#endif + + if (args->resource >= LINUX_RLIM_NLIMITS) + return (EINVAL); + + bsd.which = linux_to_bsd_resource[args->resource]; + if (bsd.which == -1) + return (EINVAL); + + bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit)); + error = getrlimit(p, &bsd); + if (error) + return (error); + + rlim.rlim_cur = (l_ulong)bsd.rlp->rlim_cur; + rlim.rlim_max = (l_ulong)bsd.rlp->rlim_max; + return (copyout(&rlim, (caddr_t)args->rlim, sizeof(rlim))); } #endif /*!__alpha__*/ int -linux_sched_setscheduler(p, uap) - struct proc *p; - struct linux_sched_setscheduler_args *uap; +linux_sched_setscheduler(struct proc *p, + struct linux_sched_setscheduler_args *args) { struct sched_setscheduler_args bsd; #ifdef DEBUG if (ldebug(sched_setscheduler)) printf(ARGS(sched_setscheduler, "%d, %d, %p"), - uap->pid, uap->policy, (const void *)uap->param); + args->pid, args->policy, (const void *)args->param); #endif - switch (uap->policy) { + switch (args->policy) { case LINUX_SCHED_OTHER: bsd.policy = SCHED_OTHER; break; @@ -1220,25 +1195,24 @@ linux_sched_setscheduler(p, uap) return EINVAL; } - bsd.pid = uap->pid; - bsd.param = uap->param; + bsd.pid = args->pid; + bsd.param = (struct sched_param *)args->param; return sched_setscheduler(p, &bsd); } int -linux_sched_getscheduler(p, uap) - struct proc *p; - struct linux_sched_getscheduler_args *uap; +linux_sched_getscheduler(struct proc *p, + struct linux_sched_getscheduler_args *args) { struct sched_getscheduler_args bsd; int error; #ifdef DEBUG if (ldebug(sched_getscheduler)) - printf(ARGS(sched_getscheduler, "%d"), uap->pid); + printf(ARGS(sched_getscheduler, "%d"), args->pid); #endif - bsd.pid = uap->pid; + bsd.pid = args->pid; error = sched_getscheduler(p, &bsd); switch (p->p_retval[0]) { @@ -1257,18 +1231,17 @@ linux_sched_getscheduler(p, uap) } int -linux_sched_get_priority_max(p, uap) - struct proc *p; - struct linux_sched_get_priority_max_args *uap; +linux_sched_get_priority_max(struct proc *p, + struct linux_sched_get_priority_max_args *args) { struct sched_get_priority_max_args bsd; #ifdef DEBUG if (ldebug(sched_get_priority_max)) - printf(ARGS(sched_get_priority_max, "%d"), uap->policy); + printf(ARGS(sched_get_priority_max, "%d"), args->policy); #endif - switch (uap->policy) { + switch (args->policy) { case LINUX_SCHED_OTHER: bsd.policy = SCHED_OTHER; break; @@ -1285,18 +1258,17 @@ linux_sched_get_priority_max(p, uap) } int -linux_sched_get_priority_min(p, uap) - struct proc *p; - struct linux_sched_get_priority_min_args *uap; +linux_sched_get_priority_min(struct proc *p, + struct linux_sched_get_priority_min_args *args) { struct sched_get_priority_min_args bsd; #ifdef DEBUG if (ldebug(sched_get_priority_min)) - printf(ARGS(sched_get_priority_min, "%d"), uap->policy); + printf(ARGS(sched_get_priority_min, "%d"), args->policy); #endif - switch (uap->policy) { + switch (args->policy) { case LINUX_SCHED_OTHER: bsd.policy = SCHED_OTHER; break; @@ -1323,10 +1295,43 @@ linux_reboot(struct proc *p, struct linux_reboot_args *args) #ifdef DEBUG if (ldebug(reboot)) - printf(ARGS(reboot, "0x%x"), args->opt); + printf(ARGS(reboot, "0x%x"), args->cmd); #endif - if (args->opt == REBOOT_CAD_ON || args->opt == REBOOT_CAD_OFF) + if (args->cmd == REBOOT_CAD_ON || args->cmd == REBOOT_CAD_OFF) return (0); - bsd_args.opt = args->opt == REBOOT_HALT ? RB_HALT : 0; + bsd_args.opt = (args->cmd == REBOOT_HALT) ? RB_HALT : 0; return (reboot(p, &bsd_args)); } + +/* + * The FreeBSD native getpid(2), getgid(2) and getuid(2) also modify + * p->p_retval[1] when COMPAT_43 or COMPAT_SUNOS is defined. This + * globbers registers that are assumed to be preserved. The following + * lightweight syscalls fixes this. See also linux_getgid16() and + * linux_getuid16() in linux_uid16.c. + * + * linux_getpid() - MP SAFE + * linux_getgid() - MP SAFE + * linux_getuid() - MP SAFE + */ + +int +linux_getpid(struct proc *p, struct linux_getpid_args *args) +{ + p->p_retval[0] = p->p_pid; + return (0); +} + +int +linux_getgid(struct proc *p, struct linux_getgid_args *args) +{ + p->p_retval[0] = p->p_ucred->cr_rgid; + return (0); +} + +int +linux_getuid(struct proc *p, struct linux_getuid_args *args) +{ + p->p_retval[0] = p->p_ucred->cr_ruid; + return (0); +} diff --git a/sys/compat/linux/linux_signal.c b/sys/compat/linux/linux_signal.c index 8a2f8b3..24a540f 100644 --- a/sys/compat/linux/linux_signal.c +++ b/sys/compat/linux/linux_signal.c @@ -42,7 +42,7 @@ #include <compat/linux/linux_util.h> void -linux_to_bsd_sigset(linux_sigset_t *lss, sigset_t *bss) +linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss) { int b, l; @@ -63,7 +63,7 @@ linux_to_bsd_sigset(linux_sigset_t *lss, sigset_t *bss) } void -bsd_to_linux_sigset(sigset_t *bss, linux_sigset_t *lss) +bsd_to_linux_sigset(sigset_t *bss, l_sigset_t *lss) { int b, l; @@ -84,7 +84,7 @@ bsd_to_linux_sigset(sigset_t *bss, linux_sigset_t *lss) } static void -linux_to_bsd_sigaction(linux_sigaction_t *lsa, struct sigaction *bsa) +linux_to_bsd_sigaction(l_sigaction_t *lsa, struct sigaction *bsa) { linux_to_bsd_sigset(&lsa->lsa_mask, &bsa->sa_mask); @@ -107,7 +107,7 @@ linux_to_bsd_sigaction(linux_sigaction_t *lsa, struct sigaction *bsa) } static void -bsd_to_linux_sigaction(struct sigaction *bsa, linux_sigaction_t *lsa) +bsd_to_linux_sigaction(struct sigaction *bsa, l_sigaction_t *lsa) { bsd_to_linux_sigset(&bsa->sa_mask, &lsa->lsa_mask); @@ -131,8 +131,8 @@ bsd_to_linux_sigaction(struct sigaction *bsa, linux_sigaction_t *lsa) } int -linux_do_sigaction(struct proc *p, int linux_sig, linux_sigaction_t *linux_nsa, - linux_sigaction_t *linux_osa) +linux_do_sigaction(struct proc *p, int linux_sig, l_sigaction_t *linux_nsa, + l_sigaction_t *linux_osa) { struct sigaction *nsa, *osa; struct sigaction_args sa_args; @@ -178,7 +178,7 @@ linux_do_sigaction(struct proc *p, int linux_sig, linux_sigaction_t *linux_nsa, int linux_signal(struct proc *p, struct linux_signal_args *args) { - linux_sigaction_t nsa, osa; + l_sigaction_t nsa, osa; int error; #ifdef DEBUG @@ -201,7 +201,7 @@ linux_signal(struct proc *p, struct linux_signal_args *args) int linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) { - linux_sigaction_t nsa, osa; + l_sigaction_t nsa, osa; int error; #ifdef DEBUG @@ -211,11 +211,11 @@ linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) (void *)args->oact, (long)args->sigsetsize); #endif - if (args->sigsetsize != sizeof(linux_sigset_t)) + if (args->sigsetsize != sizeof(l_sigset_t)) return (EINVAL); if (args->act != NULL) { - error = copyin(args->act, &nsa, sizeof(linux_sigaction_t)); + error = copyin(args->act, &nsa, sizeof(l_sigaction_t)); if (error) return (error); } @@ -225,15 +225,15 @@ linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) args->oact ? &osa : NULL); if (args->oact != NULL && !error) { - error = copyout(&osa, args->oact, sizeof(linux_sigaction_t)); + error = copyout(&osa, args->oact, sizeof(l_sigaction_t)); } return (error); } static int -linux_do_sigprocmask(struct proc *p, int how, linux_sigset_t *new, - linux_sigset_t *old) +linux_do_sigprocmask(struct proc *p, int how, l_sigset_t *new, + l_sigset_t *old) { int error; sigset_t mask; @@ -274,8 +274,8 @@ linux_do_sigprocmask(struct proc *p, int how, linux_sigset_t *new, int linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) { - linux_osigset_t mask; - linux_sigset_t set, oset; + l_osigset_t mask; + l_sigset_t set, oset; int error; #ifdef DEBUG @@ -284,7 +284,7 @@ linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) #endif if (args->mask != NULL) { - error = copyin(args->mask, &mask, sizeof(linux_osigset_t)); + error = copyin(args->mask, &mask, sizeof(l_osigset_t)); if (error) return (error); LINUX_SIGEMPTYSET(set); @@ -297,7 +297,7 @@ linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) if (args->omask != NULL && !error) { mask = oset.__bits[0]; - error = copyout(&mask, args->omask, sizeof(linux_osigset_t)); + error = copyout(&mask, args->omask, sizeof(l_osigset_t)); } return (error); @@ -307,7 +307,7 @@ linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) int linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) { - linux_sigset_t set, oset; + l_sigset_t set, oset; int error; #ifdef DEBUG @@ -317,11 +317,11 @@ linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) (void *)args->omask, (long)args->sigsetsize); #endif - if (args->sigsetsize != sizeof(linux_sigset_t)) + if (args->sigsetsize != sizeof(l_sigset_t)) return EINVAL; if (args->mask != NULL) { - error = copyin(args->mask, &set, sizeof(linux_sigset_t)); + error = copyin(args->mask, &set, sizeof(l_sigset_t)); if (error) return (error); } @@ -331,7 +331,7 @@ linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) args->omask ? &oset : NULL); if (args->omask != NULL && !error) { - error = copyout(&oset, args->omask, sizeof(linux_sigset_t)); + error = copyout(&oset, args->omask, sizeof(l_sigset_t)); } return (error); @@ -339,13 +339,13 @@ linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) #ifndef __alpha__ int -linux_siggetmask(struct proc *p, struct linux_siggetmask_args *args) +linux_sgetmask(struct proc *p, struct linux_sgetmask_args *args) { - linux_sigset_t mask; + l_sigset_t mask; #ifdef DEBUG - if (ldebug(siggetmask)) - printf(ARGS(siggetmask, "")); + if (ldebug(sgetmask)) + printf(ARGS(sgetmask, "")); #endif PROC_LOCK(p); @@ -356,14 +356,14 @@ linux_siggetmask(struct proc *p, struct linux_siggetmask_args *args) } int -linux_sigsetmask(struct proc *p, struct linux_sigsetmask_args *args) +linux_ssetmask(struct proc *p, struct linux_ssetmask_args *args) { - linux_sigset_t lset; + l_sigset_t lset; sigset_t bset; #ifdef DEBUG - if (ldebug(sigsetmask)) - printf(ARGS(sigsetmask, "%08lx"), (unsigned long)args->mask); + if (ldebug(ssetmask)) + printf(ARGS(ssetmask, "%08lx"), (unsigned long)args->mask); #endif PROC_LOCK(p); @@ -382,8 +382,8 @@ int linux_sigpending(struct proc *p, struct linux_sigpending_args *args) { sigset_t bset; - linux_sigset_t lset; - linux_osigset_t mask; + l_sigset_t lset; + l_osigset_t mask; #ifdef DEBUG if (ldebug(sigpending)) diff --git a/sys/compat/linux/linux_signal.h b/sys/compat/linux/linux_signal.h index 2330b28..e9dcec0 100644 --- a/sys/compat/linux/linux_signal.h +++ b/sys/compat/linux/linux_signal.h @@ -31,9 +31,9 @@ #ifndef _LINUX_SIGNAL_H_ #define _LINUX_SIGNAL_H_ -void linux_to_bsd_sigset __P((linux_sigset_t *, sigset_t *)); -void bsd_to_linux_sigset __P((sigset_t *, linux_sigset_t *)); -int linux_do_sigaction __P((struct proc *, int, linux_sigaction_t *, - linux_sigaction_t *)); +void linux_to_bsd_sigset __P((l_sigset_t *, sigset_t *)); +void bsd_to_linux_sigset __P((sigset_t *, l_sigset_t *)); +int linux_do_sigaction __P((struct proc *, int, l_sigaction_t *, + l_sigaction_t *)); #endif /* _LINUX_SIGNAL_H_ */ diff --git a/sys/compat/linux/linux_socket.c b/sys/compat/linux/linux_socket.c index e47c725..ac73dde 100644 --- a/sys/compat/linux/linux_socket.c +++ b/sys/compat/linux/linux_socket.c @@ -423,7 +423,7 @@ linux_connect(struct proc *p, struct linux_connect_args *args) error = EISCONN; if (fp->f_flag & FNONBLOCK) { so = (struct socket *)fp->f_data; - if ((u_int)so->so_emuldata == 0) + if (so->so_emuldata == 0) error = so->so_error; so->so_emuldata = (void *)1; } @@ -870,38 +870,39 @@ linux_getsockopt(struct proc *p, struct linux_getsockopt_args *args) int linux_socketcall(struct proc *p, struct linux_socketcall_args *args) { + void *arg = (void *)args->args; switch (args->what) { case LINUX_SOCKET: - return (linux_socket(p, args->args)); + return (linux_socket(p, arg)); case LINUX_BIND: - return (linux_bind(p, args->args)); + return (linux_bind(p, arg)); case LINUX_CONNECT: - return (linux_connect(p, args->args)); + return (linux_connect(p, arg)); case LINUX_LISTEN: - return (linux_listen(p, args->args)); + return (linux_listen(p, arg)); case LINUX_ACCEPT: - return (linux_accept(p, args->args)); + return (linux_accept(p, arg)); case LINUX_GETSOCKNAME: - return (linux_getsockname(p, args->args)); + return (linux_getsockname(p, arg)); case LINUX_GETPEERNAME: - return (linux_getpeername(p, args->args)); + return (linux_getpeername(p, arg)); case LINUX_SOCKETPAIR: - return (linux_socketpair(p, args->args)); + return (linux_socketpair(p, arg)); case LINUX_SEND: - return (linux_send(p, args->args)); + return (linux_send(p, arg)); case LINUX_RECV: - return (linux_recv(p, args->args)); + return (linux_recv(p, arg)); case LINUX_SENDTO: - return (linux_sendto(p, args->args)); + return (linux_sendto(p, arg)); case LINUX_RECVFROM: - return (linux_recvfrom(p, args->args)); + return (linux_recvfrom(p, arg)); case LINUX_SHUTDOWN: - return (linux_shutdown(p, args->args)); + return (linux_shutdown(p, arg)); case LINUX_SETSOCKOPT: - return (linux_setsockopt(p, args->args)); + return (linux_setsockopt(p, arg)); case LINUX_GETSOCKOPT: - return (linux_getsockopt(p, args->args)); + return (linux_getsockopt(p, arg)); case LINUX_SENDMSG: do { int error; @@ -911,7 +912,7 @@ linux_socketcall(struct proc *p, struct linux_socketcall_args *args) int s; const struct msghdr *msg; int flags; - } *uap = args->args; + } *uap = arg; error = copyin(&uap->msg->msg_control, &control, sizeof(caddr_t)); @@ -939,10 +940,10 @@ linux_socketcall(struct proc *p, struct linux_socketcall_args *args) return (error); } done: - return (sendmsg(p, args->args)); + return (sendmsg(p, arg)); } while (0); case LINUX_RECVMSG: - return (linux_recvmsg(p, args->args)); + return (linux_recvmsg(p, arg)); } uprintf("LINUX: 'socket' typ=%d not implemented\n", args->what); diff --git a/sys/compat/linux/linux_stats.c b/sys/compat/linux/linux_stats.c index 75364fb..5d1572b 100644 --- a/sys/compat/linux/linux_stats.c +++ b/sys/compat/linux/linux_stats.c @@ -37,6 +37,7 @@ #include <sys/mount.h> #include <sys/namei.h> #include <sys/stat.h> +#include <sys/sysctl.h> #include <sys/systm.h> #include <sys/vnode.h> @@ -44,93 +45,41 @@ #include <machine/../linux/linux_proto.h> #include <compat/linux/linux_util.h> -#include <sys/sysctl.h> - -struct linux_newstat { -#ifdef __alpha__ - u_int stat_dev; - u_int stat_ino; - u_int stat_mode; - u_int stat_nlink; - u_int stat_uid; - u_int stat_gid; - u_int stat_rdev; - long stat_size; - u_long stat_atime; - u_long stat_mtime; - u_long stat_ctime; - u_int stat_blksize; - int stat_blocks; - u_int stat_flags; - u_int stat_gen; -#else - u_short stat_dev; - u_short __pad1; - u_long stat_ino; - u_short stat_mode; - u_short stat_nlink; - u_short stat_uid; - u_short stat_gid; - u_short stat_rdev; - u_short __pad2; - u_long stat_size; - u_long stat_blksize; - u_long stat_blocks; - u_long stat_atime; - u_long __unused1; - u_long stat_mtime; - u_long __unused2; - u_long stat_ctime; - u_long __unused3; - u_long __unused4; - u_long __unused5; -#endif -}; - - -struct linux_ustat -{ - int f_tfree; - u_long f_tinode; - char f_fname[6]; - char f_fpack[6]; -}; - static int newstat_copyout(struct stat *buf, void *ubuf) { - struct linux_newstat tbuf; + struct l_newstat tbuf; struct cdevsw *cdevsw; dev_t dev; - tbuf.stat_dev = uminor(buf->st_dev) | (umajor(buf->st_dev) << 8); - tbuf.stat_ino = buf->st_ino; - tbuf.stat_mode = buf->st_mode; - tbuf.stat_nlink = buf->st_nlink; - tbuf.stat_uid = buf->st_uid; - tbuf.stat_gid = buf->st_gid; - tbuf.stat_rdev = buf->st_rdev; - tbuf.stat_size = buf->st_size; - tbuf.stat_atime = buf->st_atime; - tbuf.stat_mtime = buf->st_mtime; - tbuf.stat_ctime = buf->st_ctime; - tbuf.stat_blksize = buf->st_blksize; - tbuf.stat_blocks = buf->st_blocks; + tbuf.st_dev = uminor(buf->st_dev) | (umajor(buf->st_dev) << 8); + tbuf.st_ino = buf->st_ino; + tbuf.st_mode = buf->st_mode; + tbuf.st_nlink = buf->st_nlink; + tbuf.st_uid = buf->st_uid; + tbuf.st_gid = buf->st_gid; + tbuf.st_rdev = buf->st_rdev; + tbuf.st_size = buf->st_size; + tbuf.st_atime = buf->st_atime; + tbuf.st_mtime = buf->st_mtime; + tbuf.st_ctime = buf->st_ctime; + tbuf.st_blksize = buf->st_blksize; + tbuf.st_blocks = buf->st_blocks; /* Lie about disk drives which are character devices * in FreeBSD but block devices under Linux. */ - if (S_ISCHR(tbuf.stat_mode) && + if (S_ISCHR(tbuf.st_mode) && (dev = udev2dev(buf->st_rdev, 0)) != NODEV) { cdevsw = devsw(dev); if (cdevsw != NULL && (cdevsw->d_flags & D_DISK)) { - tbuf.stat_mode &= ~S_IFMT; - tbuf.stat_mode |= S_IFBLK; + tbuf.st_mode &= ~S_IFMT; + tbuf.st_mode |= S_IFBLK; /* XXX this may not be quite right */ /* Map major number to 0 */ - tbuf.stat_dev = uminor(buf->st_dev) & 0xf; - tbuf.stat_rdev = buf->st_rdev & 0xff; + tbuf.st_dev = uminor(buf->st_dev) & 0xf; + tbuf.st_rdev = buf->st_rdev & 0xff; } } @@ -154,7 +103,7 @@ linux_newstat(struct proc *p, struct linux_newstat_args *args) #endif NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - args->path, p); + args->path, p); error = namei(&nd); if (error) return (error); @@ -168,42 +117,35 @@ linux_newstat(struct proc *p, struct linux_newstat_args *args) return (newstat_copyout(&buf, args->buf)); } -/* - * Get file status; this version does not follow links. - */ int -linux_newlstat(p, uap) - struct proc *p; - struct linux_newlstat_args *uap; +linux_newlstat(struct proc *p, struct linux_newlstat_args *args) { int error; - struct vnode *vp; struct stat sb; struct nameidata nd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, uap->path); + CHECKALTEXIST(p, &sg, args->path); #ifdef DEBUG if (ldebug(newlstat)) - printf(ARGS(newlstat, "%s, *"), uap->path); + printf(ARGS(newlstat, "%s, *"), args->path); #endif NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - uap->path, p); + args->path, p); error = namei(&nd); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - vp = nd.ni_vp; - error = vn_stat(vp, &sb, p); - vput(vp); + error = vn_stat(nd.ni_vp, &sb, p); + vput(nd.ni_vp); if (error) return (error); - return (newstat_copyout(&sb, uap->buf)); + return (newstat_copyout(&sb, args->buf)); } int @@ -214,13 +156,12 @@ linux_newfstat(struct proc *p, struct linux_newfstat_args *args) struct stat buf; int error; - fdp = p->p_fd; - #ifdef DEBUG if (ldebug(newfstat)) printf(ARGS(newfstat, "%d, *"), args->fd); #endif + fdp = p->p_fd; if ((unsigned)args->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[args->fd]) == NULL) return (EBADF); @@ -232,21 +173,22 @@ linux_newfstat(struct proc *p, struct linux_newfstat_args *args) return (error); } -struct linux_statfs_buf { - int ftype; - int fbsize; - int fblocks; - int fbfree; - int fbavail; - int ffiles; - int fffree; - linux_fsid_t ffsid; - int fnamelen; - int fspare[6]; +/* XXX - All fields of type l_int are defined as l_long on i386 */ +struct l_statfs { + l_int f_type; + l_int f_bsize; + l_int f_blocks; + l_int f_bfree; + l_int f_bavail; + l_int f_files; + l_int f_ffree; + l_fsid_t f_fsid; + l_int f_namelen; + l_int f_spare[6]; }; #ifndef VT_NWFS -#define VT_NWFS VT_TFS /* XXX - bug compatibility with sys/fs/nwfs/nwfs_node.h */ +#define VT_NWFS VT_TFS /* XXX - bug compat. with sys/fs/nwfs/nwfs_node.h */ #endif #define LINUX_CODA_SUPER_MAGIC 0x73757245L @@ -299,7 +241,7 @@ linux_statfs(struct proc *p, struct linux_statfs_args *args) struct nameidata *ndp; struct statfs *bsd_statfs; struct nameidata nd; - struct linux_statfs_buf linux_statfs_buf; + struct l_statfs linux_statfs; int error; caddr_t sg; @@ -323,18 +265,18 @@ linux_statfs(struct proc *p, struct linux_statfs_args *args) if (error) return error; bsd_statfs->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - linux_statfs_buf.ftype = bsd_to_linux_ftype(bsd_statfs->f_type); - linux_statfs_buf.fbsize = bsd_statfs->f_bsize; - linux_statfs_buf.fblocks = bsd_statfs->f_blocks; - linux_statfs_buf.fbfree = bsd_statfs->f_bfree; - linux_statfs_buf.fbavail = bsd_statfs->f_bavail; - linux_statfs_buf.fffree = bsd_statfs->f_ffree; - linux_statfs_buf.ffiles = bsd_statfs->f_files; - linux_statfs_buf.ffsid.val[0] = bsd_statfs->f_fsid.val[0]; - linux_statfs_buf.ffsid.val[1] = bsd_statfs->f_fsid.val[1]; - linux_statfs_buf.fnamelen = MAXNAMLEN; - return copyout((caddr_t)&linux_statfs_buf, (caddr_t)args->buf, - sizeof(struct linux_statfs_buf)); + linux_statfs.f_type = bsd_to_linux_ftype(bsd_statfs->f_type); + linux_statfs.f_bsize = bsd_statfs->f_bsize; + linux_statfs.f_blocks = bsd_statfs->f_blocks; + linux_statfs.f_bfree = bsd_statfs->f_bfree; + linux_statfs.f_bavail = bsd_statfs->f_bavail; + linux_statfs.f_ffree = bsd_statfs->f_ffree; + linux_statfs.f_files = bsd_statfs->f_files; + linux_statfs.f_fsid.val[0] = bsd_statfs->f_fsid.val[0]; + linux_statfs.f_fsid.val[1] = bsd_statfs->f_fsid.val[1]; + linux_statfs.f_namelen = MAXNAMLEN; + return copyout((caddr_t)&linux_statfs, (caddr_t)args->buf, + sizeof(linux_statfs)); } int @@ -343,7 +285,7 @@ linux_fstatfs(struct proc *p, struct linux_fstatfs_args *args) struct file *fp; struct mount *mp; struct statfs *bsd_statfs; - struct linux_statfs_buf linux_statfs_buf; + struct l_statfs linux_statfs; int error; #ifdef DEBUG @@ -359,26 +301,32 @@ linux_fstatfs(struct proc *p, struct linux_fstatfs_args *args) if (error) return error; bsd_statfs->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - linux_statfs_buf.ftype = bsd_to_linux_ftype(bsd_statfs->f_type); - linux_statfs_buf.fbsize = bsd_statfs->f_bsize; - linux_statfs_buf.fblocks = bsd_statfs->f_blocks; - linux_statfs_buf.fbfree = bsd_statfs->f_bfree; - linux_statfs_buf.fbavail = bsd_statfs->f_bavail; - linux_statfs_buf.fffree = bsd_statfs->f_ffree; - linux_statfs_buf.ffiles = bsd_statfs->f_files; - linux_statfs_buf.ffsid.val[0] = bsd_statfs->f_fsid.val[0]; - linux_statfs_buf.ffsid.val[1] = bsd_statfs->f_fsid.val[1]; - linux_statfs_buf.fnamelen = MAXNAMLEN; - return copyout((caddr_t)&linux_statfs_buf, (caddr_t)args->buf, - sizeof(struct linux_statfs_buf)); + linux_statfs.f_type = bsd_to_linux_ftype(bsd_statfs->f_type); + linux_statfs.f_bsize = bsd_statfs->f_bsize; + linux_statfs.f_blocks = bsd_statfs->f_blocks; + linux_statfs.f_bfree = bsd_statfs->f_bfree; + linux_statfs.f_bavail = bsd_statfs->f_bavail; + linux_statfs.f_ffree = bsd_statfs->f_ffree; + linux_statfs.f_files = bsd_statfs->f_files; + linux_statfs.f_fsid.val[0] = bsd_statfs->f_fsid.val[0]; + linux_statfs.f_fsid.val[1] = bsd_statfs->f_fsid.val[1]; + linux_statfs.f_namelen = MAXNAMLEN; + return copyout((caddr_t)&linux_statfs, (caddr_t)args->buf, + sizeof(linux_statfs)); } +struct l_ustat +{ + l_daddr_t f_tfree; + l_ino_t f_tinode; + char f_fname[6]; + char f_fpack[6]; +}; + int -linux_ustat(p, uap) - struct proc *p; - struct linux_ustat_args *uap; +linux_ustat(struct proc *p, struct linux_ustat_args *args) { - struct linux_ustat lu; + struct l_ustat lu; dev_t dev; struct vnode *vp; struct statfs *stat; @@ -386,7 +334,7 @@ linux_ustat(p, uap) #ifdef DEBUG if (ldebug(ustat)) - printf(ARGS(ustat, "%d, *"), uap->dev); + printf(ARGS(ustat, "%d, *"), args->dev); #endif /* @@ -402,7 +350,7 @@ linux_ustat(p, uap) * dev_t returned from previous syscalls. Just return a bzeroed * ustat in that case. */ - dev = makedev(uap->dev >> 8, uap->dev & 0xFF); + dev = makedev(args->dev >> 8, args->dev & 0xFF); if (vfinddev(dev, VCHR, &vp)) { if (vp->v_mount == NULL) return (EINVAL); @@ -415,5 +363,127 @@ linux_ustat(p, uap) lu.f_tinode = stat->f_ffree; } - return (copyout(&lu, uap->ubuf, sizeof(lu))); + return (copyout(&lu, args->ubuf, sizeof(lu))); } + +#if defined(__i386__) + +static int +stat64_copyout(struct stat *buf, void *ubuf) +{ + struct l_stat64 lbuf; + + bzero(&lbuf, sizeof(lbuf)); + lbuf.st_dev = uminor(buf->st_dev) | (umajor(buf->st_dev) << 8); + lbuf.st_ino = buf->st_ino; + lbuf.st_mode = buf->st_mode; + lbuf.st_nlink = buf->st_nlink; + lbuf.st_uid = buf->st_uid; + lbuf.st_gid = buf->st_gid; + lbuf.st_rdev = buf->st_rdev; + lbuf.st_size = buf->st_size; + lbuf.st_atime = buf->st_atime; + lbuf.st_mtime = buf->st_mtime; + lbuf.st_ctime = buf->st_ctime; + lbuf.st_blksize = buf->st_blksize; + lbuf.st_blocks = buf->st_blocks; + + /* + * The __st_ino field makes all the difference. In the Linux kernel + * it is conditionally compiled based on STAT64_HAS_BROKEN_ST_INO, + * but without the assignment to __st_ino the runtime linker refuses + * to mmap(2) any shared libraries. I guess it's broken alright :-) + */ + lbuf.__st_ino = buf->st_ino; + + return (copyout(&lbuf, ubuf, sizeof(lbuf))); +} + +int +linux_stat64(struct proc *p, struct linux_stat64_args *args) +{ + struct stat buf; + struct nameidata nd; + int error; + caddr_t sg; + + sg = stackgap_init(); + CHECKALTEXIST(p, &sg, args->filename); + +#ifdef DEBUG + if (ldebug(stat64)) + printf(ARGS(stat64, "%s, *"), args->filename); +#endif + + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, + args->filename, p); + error = namei(&nd); + if (error) + return (error); + NDFREE(&nd, NDF_ONLY_PNBUF); + + error = vn_stat(nd.ni_vp, &buf, p); + vput(nd.ni_vp); + if (error) + return (error); + + return (stat64_copyout(&buf, args->statbuf)); +} + +int +linux_lstat64(struct proc *p, struct linux_lstat64_args *args) +{ + int error; + struct stat sb; + struct nameidata nd; + caddr_t sg; + + sg = stackgap_init(); + CHECKALTEXIST(p, &sg, args->filename); + +#ifdef DEBUG + if (ldebug(lstat64)) + printf(ARGS(lstat64, "%s, *"), args->filename); +#endif + + NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, + args->filename, p); + error = namei(&nd); + if (error) + return (error); + NDFREE(&nd, NDF_ONLY_PNBUF); + + error = vn_stat(nd.ni_vp, &sb, p); + vput(nd.ni_vp); + if (error) + return (error); + + return (stat64_copyout(&sb, args->statbuf)); +} + +int +linux_fstat64(struct proc *p, struct linux_fstat64_args *args) +{ + struct filedesc *fdp; + struct file *fp; + struct stat buf; + int error; + +#ifdef DEBUG + if (ldebug(fstat64)) + printf(ARGS(fstat64, "%d, *"), args->fd); +#endif + + fdp = p->p_fd; + if ((unsigned)args->fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[args->fd]) == NULL) + return (EBADF); + + error = fo_stat(fp, &buf, p); + if (!error) + error = stat64_copyout(&buf, args->statbuf); + + return (error); +} + +#endif /* __i386__ */ diff --git a/sys/compat/linux/linux_sysctl.c b/sys/compat/linux/linux_sysctl.c new file mode 100644 index 0000000..14c5a6f --- /dev/null +++ b/sys/compat/linux/linux_sysctl.c @@ -0,0 +1,120 @@ +/*- + * Copyright (c) 2001 Marcel Moolenaar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#include "opt_compat.h" + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/sysproto.h> + +#include <machine/../linux/linux.h> +#include <machine/../linux/linux_proto.h> +#include <compat/linux/linux_util.h> + +#define LINUX_CTL_KERN 1 +#define LINUX_CTL_VM 2 +#define LINUX_CTL_NET 3 +#define LINUX_CTL_PROC 4 +#define LINUX_CTL_FS 5 +#define LINUX_CTL_DEBUG 6 +#define LINUX_CTL_DEV 7 +#define LINUX_CTL_BUS 8 + +/* CTL_KERN names */ +#define LINUX_KERN_OSTYPE 1 +#define LINUX_KERN_OSRELEASE 2 +#define LINUX_KERN_OSREV 3 +#define LINUX_KERN_VERSION 4 + +static int +handle_string(struct l___sysctl_args *la, char *value) +{ + int error; + + if (la->oldval != NULL) { + l_int len = strlen(value); + error = copyout(value, la->oldval, len + 1); + if (!error && la->oldlenp != NULL) + error = copyout(&len, la->oldlenp, sizeof(len)); + if (error) + return (error); + } + + if (la->newval != NULL) + return (ENOTDIR); + + return (0); +} + +int +linux_sysctl(struct proc *p, struct linux_sysctl_args *args) +{ + struct l___sysctl_args la; + l_int *mib; + int error, i; + caddr_t sg; + + error = copyin((caddr_t)args->args, &la, sizeof(la)); + if (error) + return (error); + + if (la.nlen == 0 || la.nlen > LINUX_CTL_MAXNAME) + return (ENOTDIR); + + sg = stackgap_init(); + mib = stackgap_alloc(&sg, la.nlen * sizeof(l_int)); + error = copyin(la.name, mib, la.nlen * sizeof(l_int)); + if (error) + return (error); + + switch (mib[0]) { + case LINUX_CTL_KERN: + if (la.nlen < 2) + break; + + switch (mib[1]) { + case LINUX_KERN_VERSION: + return (handle_string(&la, version)); + default: + break; + } + break; + default: + break; + } + + printf("linux: sysctl: unhandled name="); + for (i = 0; i < la.nlen; i++) + printf("%c%d", (i) ? ',' : '{', mib[i]); + printf("}\n"); + + return (ENOTDIR); +} diff --git a/sys/i386/linux/linux.h b/sys/i386/linux/linux.h index b4eec098..594ebfc 100644 --- a/sys/i386/linux/linux.h +++ b/sys/i386/linux/linux.h @@ -38,21 +38,75 @@ /* * debugging support */ -extern u_char linux_debug_map[]; +extern u_char linux_debug_map[]; #define ldebug(name) isclr(linux_debug_map, LINUX_SYS_linux_ ## name) -#define ARGS(nm, fmt) "Linux-emul(%ld): "#nm"("fmt")\n", (long)p->p_pid -#define LMSG(fmt) "Linux-emul(%ld): "fmt"\n", (long)p->p_pid +#define ARGS(nm, fmt) "linux(%ld): "#nm"("fmt")\n", (long)p->p_pid +#define LMSG(fmt) "linux(%ld): "fmt"\n", (long)p->p_pid #ifdef MALLOC_DECLARE MALLOC_DECLARE(M_LINUX); #endif /* + * Provide a seperate set of types for the Linux types. + */ +typedef int l_int; +typedef int32_t l_long; +typedef int64_t l_longlong; +typedef short l_short; +typedef unsigned int l_uint; +typedef uint32_t l_ulong; +typedef uint64_t l_ulonglong; +typedef unsigned short l_ushort; + +typedef char *l_caddr_t; +typedef l_long l_clock_t; +typedef l_int l_daddr_t; +typedef l_ushort l_dev_t; +typedef l_uint l_gid_t; +typedef l_ushort l_gid16_t; +typedef l_ulong l_ino_t; +typedef l_int l_key_t; +typedef l_longlong l_loff_t; +typedef l_ushort l_mode_t; +typedef l_long l_off_t; +typedef l_int l_pid_t; +typedef l_uint l_size_t; +typedef l_long l_suseconds_t; +typedef l_long l_time_t; +typedef l_uint l_uid_t; +typedef l_ushort l_uid16_t; + +typedef struct { + l_int val[2]; +} l_fsid_t; + +typedef struct { + l_time_t tv_sec; + l_suseconds_t tv_usec; +} l_timeval; + +#define l_fd_set fd_set + +/* * Miscellaneous */ #define LINUX_NAME_MAX 255 #define LINUX_MAX_UTSNAME 65 +#define LINUX_CTL_MAXNAME 10 + +struct l___sysctl_args +{ + l_int *name; + l_int nlen; + void *oldval; + l_size_t *oldlenp; + void *newval; + l_size_t newlen; + l_ulong __spare[4]; +}; + /* Scheduling policies */ #define LINUX_SCHED_OTHER 0 #define LINUX_SCHED_FIFO 1 @@ -72,6 +126,11 @@ MALLOC_DECLARE(M_LINUX); #define LINUX_RLIM_NLIMITS 10 +struct l_rlimit { + l_ulong rlim_cur; + l_ulong rlim_max; +}; + /* mmap options */ #define LINUX_MAP_SHARED 0x0001 #define LINUX_MAP_PRIVATE 0x0002 @@ -79,25 +138,55 @@ MALLOC_DECLARE(M_LINUX); #define LINUX_MAP_ANON 0x0020 #define LINUX_MAP_GROWSDOWN 0x0100 -typedef char * linux_caddr_t; -typedef long linux_clock_t; -typedef u_short linux_dev_t; -typedef u_short linux_gid_t; -typedef u_long linux_ino_t; -typedef int linux_key_t; /* XXX */ -typedef u_short linux_mode_t; -typedef u_short linux_nlink_t; -typedef long linux_off_t; -typedef int linux_pid_t; -typedef u_int linux_size_t; -typedef long linux_time_t; -typedef u_short linux_uid_t; +/* + * stat family of syscalls + */ +struct l_timespec { + l_ulong tv_sec; + l_ulong tv_nsec; +}; -typedef struct { - long val[2]; -} linux_fsid_t; +struct l_newstat { + l_ushort st_dev; + l_ushort __pad1; + l_ulong st_ino; + l_ushort st_mode; + l_ushort st_nlink; + l_ushort st_uid; + l_ushort st_gid; + l_ushort st_rdev; + l_ushort __pad2; + l_ulong st_size; + l_ulong st_blksize; + l_ulong st_blocks; + struct l_timespec st_atimespec; + struct l_timespec st_mtimespec; + struct l_timespec st_ctimespec; + l_ulong __unused4; + l_ulong __unused5; +}; + +struct l_stat64 { + l_ushort st_dev; + u_char __pad0[10]; + l_ulong __st_ino; + l_uint st_mode; + l_uint st_nlink; + l_ulong st_uid; + l_ulong st_gid; + l_ushort st_rdev; + u_char __pad3[10]; + l_longlong st_size; + l_ulong st_blksize; + l_ulong st_blocks; + l_ulong __pad4; + struct l_timespec st_atimespec; + struct l_timespec st_mtimespec; + struct l_timespec st_ctimespec; + l_ulonglong st_ino; +}; -struct linux_new_utsname { +struct l_new_utsname { char sysname[LINUX_MAX_UTSNAME]; char nodename[LINUX_MAX_UTSNAME]; char release[LINUX_MAX_UTSNAME]; @@ -174,117 +263,114 @@ struct linux_new_utsname { #define LINUX_SS_ONSTACK 1 #define LINUX_SS_DISABLE 2 - int linux_to_bsd_sigaltstack(int lsa); int bsd_to_linux_sigaltstack(int bsa); - -typedef void (*linux_handler_t)(int); -typedef u_long linux_osigset_t; +typedef void (*l_handler_t)(l_int); +typedef l_ulong l_osigset_t; typedef struct { - u_int __bits[LINUX_NSIG_WORDS]; -} linux_sigset_t; + l_uint __bits[LINUX_NSIG_WORDS]; +} l_sigset_t; typedef struct { - linux_handler_t lsa_handler; - linux_osigset_t lsa_mask; - u_long lsa_flags; + l_handler_t lsa_handler; + l_osigset_t lsa_mask; + l_ulong lsa_flags; void (*lsa_restorer)(void); -} linux_osigaction_t; +} l_osigaction_t; typedef struct { - linux_handler_t lsa_handler; - u_long lsa_flags; + l_handler_t lsa_handler; + l_ulong lsa_flags; void (*lsa_restorer)(void); - linux_sigset_t lsa_mask; -} linux_sigaction_t; + l_sigset_t lsa_mask; +} l_sigaction_t; typedef struct { - void *ss_sp; - int ss_flags; - linux_size_t ss_size; -} linux_stack_t; + void *ss_sp; + l_int ss_flags; + l_size_t ss_size; +} l_stack_t; /* The Linux sigcontext, pretty much a standard 386 trapframe. */ -struct linux_sigcontext { - int sc_gs; - int sc_fs; - int sc_es; - int sc_ds; - int sc_edi; - int sc_esi; - int sc_ebp; - int sc_esp; - int sc_ebx; - int sc_edx; - int sc_ecx; - int sc_eax; - int sc_trapno; - int sc_err; - int sc_eip; - int sc_cs; - int sc_eflags; - int sc_esp_at_signal; - int sc_ss; - int sc_387; - int sc_mask; - int sc_cr2; +struct l_sigcontext { + l_int sc_gs; + l_int sc_fs; + l_int sc_es; + l_int sc_ds; + l_int sc_edi; + l_int sc_esi; + l_int sc_ebp; + l_int sc_esp; + l_int sc_ebx; + l_int sc_edx; + l_int sc_ecx; + l_int sc_eax; + l_int sc_trapno; + l_int sc_err; + l_int sc_eip; + l_int sc_cs; + l_int sc_eflags; + l_int sc_esp_at_signal; + l_int sc_ss; + l_int sc_387; + l_int sc_mask; + l_int sc_cr2; }; -struct linux_ucontext { - unsigned long uc_flags; - void *uc_link; - linux_stack_t uc_stack; - struct linux_sigcontext uc_mcontext; - linux_sigset_t uc_sigmask; +struct l_ucontext { + l_ulong uc_flags; + void *uc_link; + l_stack_t uc_stack; + struct l_sigcontext uc_mcontext; + l_sigset_t uc_sigmask; }; - #define LINUX_SI_MAX_SIZE 128 -#define LINUX_SI_PAD_SIZE ((LINUX_SI_MAX_SIZE/sizeof(int)) - 3) - -typedef struct siginfo { - int lsi_signo; - int lsi_errno; - int lsi_code; +#define LINUX_SI_PAD_SIZE ((LINUX_SI_MAX_SIZE/sizeof(l_int)) - 3) +typedef struct l_siginfo { + l_int lsi_signo; + l_int lsi_errno; + l_int lsi_code; union { - int _pad[LINUX_SI_PAD_SIZE]; + l_int _pad[LINUX_SI_PAD_SIZE]; + struct { - linux_pid_t _pid; - linux_uid_t _uid; + l_pid_t _pid; + l_uid16_t _uid; } _kill; struct { - unsigned int _timer1; - unsigned int _timer2; + l_uint _timer1; + l_uint _timer2; } _timer; - + struct { - linux_pid_t _pid; /* sender's pid */ - linux_uid_t _uid; /* sender's uid */ + l_pid_t _pid; /* sender's pid */ + l_uid16_t _uid; /* sender's uid */ union sigval _sigval; } _rt; struct { - linux_pid_t _pid; /* which child */ - linux_uid_t _uid; /* sender's uid */ - int _status; /* exit code */ - linux_clock_t _utime; - linux_clock_t _stime; + l_pid_t _pid; /* which child */ + l_uid16_t _uid; /* sender's uid */ + l_int _status; /* exit code */ + l_clock_t _utime; + l_clock_t _stime; } _sigchld; struct { - void *_addr; /* faulting insn/memory ref. */ + void *_addr; /* faulting insn/memory ref. */ } _sigfault; struct { - int _band; /* POLL_IN, POLL_OUT, POLL_MSG */ - int _fd; + l_int _band; /* POLL_IN,POLL_OUT,POLL_MSG */ + l_int _fd; } _sigpoll; } _sifields; -} linux_siginfo_t; +} l_siginfo_t; #define lsi_pid _sifields._kill._pid #define lsi_uid _sifields._kill._uid @@ -298,22 +384,22 @@ typedef struct siginfo { #define lsi_band _sifields._sigpoll._band #define lsi_fd _sifields._sigpoll._fd -struct linux_fpreg { +struct l_fpreg { u_int16_t significand[4]; u_int16_t exponent; }; -struct linux_fpxreg { +struct l_fpxreg { u_int16_t significand[4]; u_int16_t exponent; u_int16_t padding[3]; }; -struct linux_xmmreg { +struct l_xmmreg { u_int32_t element[4]; }; -struct linux_fpstate { +struct l_fpstate { /* Regular FPU environment */ u_int32_t cw; u_int32_t sw; @@ -322,7 +408,7 @@ struct linux_fpstate { u_int32_t cssel; u_int32_t dataoff; u_int32_t datasel; - struct linux_fpreg _st[8]; + struct l_fpreg _st[8]; u_int16_t status; u_int16_t magic; /* 0xffff = regular FPU data */ @@ -330,8 +416,8 @@ struct linux_fpstate { u_int32_t _fxsr_env[6]; /* env is ignored */ u_int32_t mxcsr; u_int32_t reserved; - struct linux_fpxreg _fxsr_st[8]; /* reg data is ignored */ - struct linux_xmmreg _xmm[8]; + struct l_fpxreg _fxsr_st[8]; /* reg data is ignored */ + struct l_xmmreg _xmm[8]; u_int32_t padding[56]; }; @@ -341,21 +427,21 @@ struct linux_fpstate { * This means that we need to pass the pointer to the handler too. * It is appended to the frame to not interfere with the rest of it. */ -struct linux_sigframe { - int sf_sig; - struct linux_sigcontext sf_sc; - struct linux_fpstate sf_fpstate; - u_int sf_extramask[LINUX_NSIG_WORDS-1]; - linux_handler_t sf_handler; +struct l_sigframe { + l_int sf_sig; + struct l_sigcontext sf_sc; + struct l_fpstate sf_fpstate; + l_uint sf_extramask[LINUX_NSIG_WORDS-1]; + l_handler_t sf_handler; }; -struct linux_rt_sigframe { - int sf_sig; - linux_siginfo_t *sf_siginfo; - struct linux_ucontext *sf_ucontext; - linux_siginfo_t sf_si; - struct linux_ucontext sf_sc; - linux_handler_t sf_handler; +struct l_rt_sigframe { + l_int sf_sig; + l_siginfo_t *sf_siginfo; + struct l_ucontext *sf_ucontext; + l_siginfo_t sf_si; + struct l_ucontext sf_sc; + l_handler_t sf_handler; }; extern int bsd_to_linux_signal[]; @@ -457,6 +543,14 @@ int linux_ioctl_unregister_handler(struct linux_ioctl_handler *h); #define LINUX_SETVAL 16 #define LINUX_SETALL 17 +union l_semun { + l_int val; + struct l_semid_ds *buf; + l_ushort *array; + struct l_seminfo *__buf; + void *__pad; +}; + /* * Socket defines */ @@ -517,44 +611,65 @@ int linux_ioctl_unregister_handler(struct linux_ioctl_handler *h); #define LINUX_IP_ADD_MEMBERSHIP 35 #define LINUX_IP_DROP_MEMBERSHIP 36 -struct linux_sockaddr { - u_short sa_family; - char sa_data[14]; +struct l_sockaddr { + l_ushort sa_family; + char sa_data[14]; }; -struct linux_ifmap { - u_long mem_start; - u_long mem_end; - u_short base_addr; - u_char irq; - u_char dma; - u_char port; +struct l_ifmap { + l_ulong mem_start; + l_ulong mem_end; + l_ushort base_addr; + u_char irq; + u_char dma; + u_char port; }; #define LINUX_IFHWADDRLEN 6 #define LINUX_IFNAMSIZ 16 -struct linux_ifreq { +struct l_ifreq { union { char ifrn_name[LINUX_IFNAMSIZ]; } ifr_ifrn; union { - struct linux_sockaddr ifru_addr; - struct linux_sockaddr ifru_dstaddr; - struct linux_sockaddr ifru_broadaddr; - struct linux_sockaddr ifru_netmask; - struct linux_sockaddr ifru_hwaddr; - short ifru_flags; - int ifru_metric; - int ifru_mtu; - struct linux_ifmap ifru_map; - char ifru_slave[LINUX_IFNAMSIZ]; /* Just fits the size */ - linux_caddr_t ifru_data; + struct l_sockaddr ifru_addr; + struct l_sockaddr ifru_dstaddr; + struct l_sockaddr ifru_broadaddr; + struct l_sockaddr ifru_netmask; + struct l_sockaddr ifru_hwaddr; + l_short ifru_flags; + l_int ifru_metric; + l_int ifru_mtu; + struct l_ifmap ifru_map; + char ifru_slave[LINUX_IFNAMSIZ]; + l_caddr_t ifru_data; } ifr_ifru; }; #define ifr_name ifr_ifrn.ifrn_name /* interface name */ #define ifr_hwaddr ifr_ifru.ifru_hwaddr /* MAC address */ +/* + * poll() + */ +#define LINUX_POLLIN 0x0001 +#define LINUX_POLLPRI 0x0002 +#define LINUX_POLLOUT 0x0004 +#define LINUX_POLLERR 0x0008 +#define LINUX_POLLHUP 0x0010 +#define LINUX_POLLNVAL 0x0020 +#define LINUX_POLLRDNORM 0x0040 +#define LINUX_POLLRDBAND 0x0080 +#define LINUX_POLLWRNORM 0x0100 +#define LINUX_POLLWRBAND 0x0200 +#define LINUX_POLLMSG 0x0400 + +struct l_pollfd { + l_int fd; + l_short events; + l_short revents; +}; + #endif /* !_I386_LINUX_LINUX_H_ */ diff --git a/sys/i386/linux/linux_dummy.c b/sys/i386/linux/linux_dummy.c index b63a285..983ccec 100644 --- a/sys/i386/linux/linux_dummy.c +++ b/sys/i386/linux/linux_dummy.c @@ -34,41 +34,16 @@ #include <i386/linux/linux.h> #include <i386/linux/linux_proto.h> +#include <compat/linux/linux_util.h> -#define DUMMY(s) \ -int \ -linux_ ## s(struct proc *p, struct linux_ ## s ## _args *args) \ -{ \ - return (unsupported_msg(p, #s)); \ -} \ -struct __hack - -static int -unsupported_msg(struct proc *p, const char *fname) -{ - printf("linux: syscall %s is obsoleted or not implemented (pid=%ld)\n", - fname, (long)p->p_pid); - return (ENOSYS); -} - -DUMMY(setup); -DUMMY(break); DUMMY(stat); DUMMY(stime); DUMMY(ptrace); DUMMY(fstat); -DUMMY(stty); -DUMMY(gtty); -DUMMY(ftime); -DUMMY(prof); -DUMMY(lock); -DUMMY(mpx); -DUMMY(ulimit); DUMMY(olduname); -DUMMY(ksyslog); +DUMMY(syslog); DUMMY(uname); DUMMY(vhangup); -DUMMY(idle); DUMMY(vm86old); DUMMY(swapoff); DUMMY(adjtimex); @@ -79,16 +54,10 @@ DUMMY(get_kernel_syms); DUMMY(quotactl); DUMMY(bdflush); DUMMY(sysfs); -DUMMY(afs_syscall); -DUMMY(setfsuid); -DUMMY(setfsgid); DUMMY(getsid); -DUMMY(sysctl); -DUMMY(getresuid); DUMMY(vm86); DUMMY(query_module); DUMMY(nfsservctl); -DUMMY(getresgid); DUMMY(prctl); DUMMY(rt_sigpending); DUMMY(rt_sigtimedwait); @@ -96,12 +65,14 @@ DUMMY(rt_sigqueueinfo); DUMMY(capget); DUMMY(capset); DUMMY(sendfile); -DUMMY(getpmsg); -DUMMY(putpmsg); -DUMMY(ugetrlimit); DUMMY(mmap2); DUMMY(truncate64); DUMMY(ftruncate64); -DUMMY(stat64); -DUMMY(lstat64); -DUMMY(fstat64); +DUMMY(lchown); +DUMMY(fchown); +DUMMY(chown); +DUMMY(setfsuid); +DUMMY(setfsgid); +DUMMY(pivot_root); +DUMMY(mincore); +DUMMY(madvise); diff --git a/sys/i386/linux/linux_genassym.c b/sys/i386/linux/linux_genassym.c index 3e3fbad..9cef0a5 100644 --- a/sys/i386/linux/linux_genassym.c +++ b/sys/i386/linux/linux_genassym.c @@ -5,11 +5,9 @@ #include <i386/linux/linux.h> -ASSYM(LINUX_SIGF_HANDLER, offsetof(struct linux_sigframe, sf_handler)); -ASSYM(LINUX_SIGF_SC, offsetof(struct linux_sigframe, sf_sc)); -ASSYM(LINUX_SC_GS, offsetof(struct linux_sigcontext, sc_gs)); -ASSYM(LINUX_SC_EFLAGS, offsetof(struct linux_sigcontext, sc_eflags)); -ASSYM(LINUX_RT_SIGF_HANDLER, offsetof(struct linux_rt_sigframe, sf_handler)); -ASSYM(LINUX_RT_SIGF_UC, offsetof(struct linux_rt_sigframe, sf_sc)); - - +ASSYM(LINUX_SIGF_HANDLER, offsetof(struct l_sigframe, sf_handler)); +ASSYM(LINUX_SIGF_SC, offsetof(struct l_sigframe, sf_sc)); +ASSYM(LINUX_SC_GS, offsetof(struct l_sigcontext, sc_gs)); +ASSYM(LINUX_SC_EFLAGS, offsetof(struct l_sigcontext, sc_eflags)); +ASSYM(LINUX_RT_SIGF_HANDLER, offsetof(struct l_rt_sigframe, sf_handler)); +ASSYM(LINUX_RT_SIGF_UC, offsetof(struct l_rt_sigframe, sf_sc)); diff --git a/sys/i386/linux/linux_machdep.c b/sys/i386/linux/linux_machdep.c index ce8d52b..dfae7f4 100644 --- a/sys/i386/linux/linux_machdep.c +++ b/sys/i386/linux/linux_machdep.c @@ -54,24 +54,24 @@ #include <compat/linux/linux_signal.h> #include <compat/linux/linux_util.h> -struct linux_descriptor { - unsigned int entry_number; - unsigned long base_addr; - unsigned int limit; - unsigned int seg_32bit:1; - unsigned int contents:2; - unsigned int read_exec_only:1; - unsigned int limit_in_pages:1; - unsigned int seg_not_present:1; - unsigned int useable:1; +struct l_descriptor { + l_uint entry_number; + l_ulong base_addr; + l_uint limit; + l_uint seg_32bit:1; + l_uint contents:2; + l_uint read_exec_only:1; + l_uint limit_in_pages:1; + l_uint seg_not_present:1; + l_uint useable:1; }; -struct linux_select_argv { - int nfds; - fd_set *readfds; - fd_set *writefds; - fd_set *exceptfds; - struct timeval *timeout; +struct l_old_select_argv { + l_int nfds; + l_fd_set *readfds; + l_fd_set *writefds; + l_fd_set *exceptfds; + struct l_timeval *timeout; }; int @@ -118,51 +118,142 @@ linux_execve(struct proc *p, struct linux_execve_args *args) return (execve(p, &bsd)); } +struct l_ipc_kludge { + struct l_msgbuf *msgp; + l_long msgtyp; +}; + int linux_ipc(struct proc *p, struct linux_ipc_args *args) { - switch (args->what) { - case LINUX_SEMOP: - return (linux_semop(p, args)); - case LINUX_SEMGET: - return (linux_semget(p, args)); - case LINUX_SEMCTL: - return (linux_semctl(p, args)); - case LINUX_MSGSND: - return (linux_msgsnd(p, args)); - case LINUX_MSGRCV: - return (linux_msgrcv(p, args)); - case LINUX_MSGGET: - return (linux_msgget(p, args)); - case LINUX_MSGCTL: - return (linux_msgctl(p, args)); - case LINUX_SHMAT: - return (linux_shmat(p, args)); - case LINUX_SHMDT: - return (linux_shmdt(p, args)); - case LINUX_SHMGET: - return (linux_shmget(p, args)); - case LINUX_SHMCTL: - return (linux_shmctl(p, args)); + + switch (args->what & 0xFFFF) { + case LINUX_SEMOP: { + struct linux_semop_args a; + + a.semid = args->arg1; + a.tsops = args->ptr; + a.nsops = args->arg2; + return (linux_semop(p, &a)); + } + case LINUX_SEMGET: { + struct linux_semget_args a; + + a.key = args->arg1; + a.nsems = args->arg2; + a.semflg = args->arg3; + return (linux_semget(p, &a)); + } + case LINUX_SEMCTL: { + struct linux_semctl_args a; + int error; + + a.semid = args->arg1; + a.semnum = args->arg2; + a.cmd = args->arg3; + error = copyin((caddr_t)args->ptr, &a.arg, sizeof(a.arg)); + if (error) + return (error); + return (linux_semctl(p, &a)); + } + case LINUX_MSGSND: { + struct linux_msgsnd_args a; + + a.msqid = args->arg1; + a.msgp = args->ptr; + a.msgsz = args->arg2; + a.msgflg = args->arg3; + return (linux_msgsnd(p, &a)); + } + case LINUX_MSGRCV: { + struct linux_msgrcv_args a; + + a.msqid = args->arg1; + a.msgsz = args->arg2; + a.msgflg = args->arg3; + if ((args->what >> 16) == 0) { + struct l_ipc_kludge tmp; + int error; + + if (args->ptr == NULL) + return (EINVAL); + error = copyin((caddr_t)args->ptr, &tmp, sizeof(tmp)); + if (error) + return (error); + a.msgp = tmp.msgp; + a.msgtyp = tmp.msgtyp; + } else { + a.msgp = args->ptr; + a.msgtyp = args->arg5; + } + return (linux_msgrcv(p, &a)); + } + case LINUX_MSGGET: { + struct linux_msgget_args a; + + a.key = args->arg1; + a.msgflg = args->arg2; + return (linux_msgget(p, &a)); + } + case LINUX_MSGCTL: { + struct linux_msgctl_args a; + + a.msqid = args->arg1; + a.cmd = args->arg2; + a.buf = args->ptr; + return (linux_msgctl(p, &a)); + } + case LINUX_SHMAT: { + struct linux_shmat_args a; + + a.shmid = args->arg1; + a.shmaddr = args->ptr; + a.shmflg = args->arg2; + a.raddr = (l_ulong *)args->arg3; + return (linux_shmat(p, &a)); } + case LINUX_SHMDT: { + struct linux_shmdt_args a; - uprintf("LINUX: 'ipc' typ=%d not implemented\n", args->what); - return (ENOSYS); + a.shmaddr = args->ptr; + return (linux_shmdt(p, &a)); + } + case LINUX_SHMGET: { + struct linux_shmget_args a; + + a.key = args->arg1; + a.size = args->arg2; + a.shmflg = args->arg3; + return (linux_shmget(p, &a)); + } + case LINUX_SHMCTL: { + struct linux_shmctl_args a; + + a.shmid = args->arg1; + a.cmd = args->arg2; + a.buf = args->ptr; + return (linux_shmctl(p, &a)); + } + default: + break; + } + + return (EINVAL); } int -linux_select(struct proc *p, struct linux_select_args *args) +linux_old_select(struct proc *p, struct linux_old_select_args *args) { - struct linux_select_argv linux_args; - struct linux_newselect_args newsel; + struct l_old_select_argv linux_args; + struct linux_select_args newsel; int error; -#ifdef SELECT_DEBUG - if (ldebug(select)) - printf(ARGS(select, "%x"), args->ptr); +#ifdef DEBUG + if (ldebug(old_select)) + printf(ARGS(old_select, "%x"), args->ptr); #endif - error = copyin(args->ptr, &linux_args, sizeof(linux_args)); + error = copyin((caddr_t)args->ptr, &linux_args, sizeof(linux_args)); if (error) return (error); @@ -171,7 +262,7 @@ linux_select(struct proc *p, struct linux_select_args *args) newsel.writefds = linux_args.writefds; newsel.exceptfds = linux_args.exceptfds; newsel.timeout = linux_args.timeout; - return (linux_newselect(p, &newsel)); + return (linux_select(p, &newsel)); } int @@ -222,7 +313,6 @@ linux_clone(struct proc *p, struct linux_clone_args *args) int error, ff = RFPROC | RFSTOPPED; struct proc *p2; int exit_signal; - vm_offset_t start; #ifdef DEBUG if (ldebug(clone)) { @@ -243,9 +333,6 @@ linux_clone(struct proc *p, struct linux_clone_args *args) if (exit_signal <= LINUX_SIGTBLSZ) exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)]; - /* RFTHREAD probably not necessary here, but it shouldn't hurt */ - ff |= RFTHREAD; - if (args->flags & CLONE_VM) ff |= RFMEM; if (args->flags & CLONE_SIGHAND) @@ -253,44 +340,44 @@ linux_clone(struct proc *p, struct linux_clone_args *args) if (!(args->flags & CLONE_FILES)) ff |= RFFDG; - error = 0; - start = 0; - - if ((error = fork1(p, ff, &p2)) != 0) - return (error); + mtx_lock(&Giant); + error = fork1(p, ff, &p2); + if (error == 0) { + p->p_retval[0] = p2->p_pid; + p->p_retval[1] = 0; - PROC_LOCK(p2); - p2->p_sigparent = exit_signal; - PROC_UNLOCK(p2); - p2->p_frame->tf_esp = (unsigned int)args->stack; + PROC_LOCK(p2); + p2->p_sigparent = exit_signal; + p2->p_frame->tf_esp = (unsigned int)args->stack; #ifdef DEBUG - if (ldebug(clone)) - printf(LMSG("clone: successful rfork to %ld"), - (long)p2->p_pid); + if (ldebug(clone)) + printf(LMSG("clone: successful rfork to %ld"), + (long)p2->p_pid); #endif - /* - * Make this runnable after we are finished with it. - */ - mtx_lock_spin(&sched_lock); - p2->p_stat = SRUN; - setrunqueue(p2); - mtx_unlock_spin(&sched_lock); + /* + * Make this runnable after we are finished with it. + */ + mtx_lock_spin(&sched_lock); + p2->p_stat = SRUN; + setrunqueue(p2); + mtx_unlock_spin(&sched_lock); + PROC_UNLOCK(p2); + } + mtx_unlock(&Giant); - p->p_retval[0] = p2->p_pid; - p->p_retval[1] = 0; - return (0); + return (error); } /* XXX move */ -struct linux_mmap_argv { - linux_caddr_t addr; - int len; - int prot; - int flags; - int fd; - int pos; +struct l_mmap_argv { + l_caddr_t addr; + l_int len; + l_int prot; + l_int flags; + l_int fd; + l_int pos; }; #define STACK_SIZE (2 * 1024 * 1024) @@ -309,9 +396,9 @@ linux_mmap(struct proc *p, struct linux_mmap_args *args) off_t pos; } */ bsd_args; int error; - struct linux_mmap_argv linux_args; + struct l_mmap_argv linux_args; - error = copyin(args->ptr, &linux_args, sizeof(linux_args)); + error = copyin((caddr_t)args->ptr, &linux_args, sizeof(linux_args)); if (error) return (error); @@ -488,7 +575,7 @@ linux_modify_ldt(p, uap) caddr_t sg; struct sysarch_args args; struct i386_ldt_args *ldt; - struct linux_descriptor ld; + struct l_descriptor ld; union descriptor *desc; sg = stackgap_init(); @@ -552,8 +639,8 @@ linux_modify_ldt(p, uap) int linux_sigaction(struct proc *p, struct linux_sigaction_args *args) { - linux_osigaction_t osa; - linux_sigaction_t act, oact; + l_osigaction_t osa; + l_sigaction_t act, oact; int error; #ifdef DEBUG @@ -563,7 +650,8 @@ linux_sigaction(struct proc *p, struct linux_sigaction_args *args) #endif if (args->nsa != NULL) { - error = copyin(args->nsa, &osa, sizeof(linux_osigaction_t)); + error = copyin((caddr_t)args->nsa, &osa, + sizeof(l_osigaction_t)); if (error) return (error); act.lsa_handler = osa.lsa_handler; @@ -581,7 +669,8 @@ linux_sigaction(struct proc *p, struct linux_sigaction_args *args) osa.lsa_flags = oact.lsa_flags; osa.lsa_restorer = oact.lsa_restorer; osa.lsa_mask = oact.lsa_mask.__bits[0]; - error = copyout(&osa, args->osa, sizeof(linux_osigaction_t)); + error = copyout(&osa, (caddr_t)args->osa, + sizeof(l_osigaction_t)); } return (error); @@ -597,7 +686,7 @@ linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args) { struct sigsuspend_args bsd; sigset_t *sigmask; - linux_sigset_t mask; + l_sigset_t mask; caddr_t sg = stackgap_init(); #ifdef DEBUG @@ -618,7 +707,7 @@ linux_rt_sigsuspend(p, uap) struct proc *p; struct linux_rt_sigsuspend_args *uap; { - linux_sigset_t lmask; + l_sigset_t lmask; sigset_t *bmask; struct sigsuspend_args bsd; caddr_t sg = stackgap_init(); @@ -630,10 +719,10 @@ linux_rt_sigsuspend(p, uap) (void *)uap->newset, uap->sigsetsize); #endif - if (uap->sigsetsize != sizeof(linux_sigset_t)) + if (uap->sigsetsize != sizeof(l_sigset_t)) return (EINVAL); - error = copyin(uap->newset, &lmask, sizeof(linux_sigset_t)); + error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); if (error) return (error); @@ -670,7 +759,7 @@ linux_sigaltstack(p, uap) { struct sigaltstack_args bsd; stack_t *ss, *oss; - linux_stack_t lss; + l_stack_t lss; int error; caddr_t sg = stackgap_init(); @@ -682,7 +771,7 @@ linux_sigaltstack(p, uap) if (uap->uss == NULL) { ss = NULL; } else { - error = copyin(uap->uss, &lss, sizeof(linux_stack_t)); + error = copyin(uap->uss, &lss, sizeof(l_stack_t)); if (error) return (error); @@ -703,7 +792,7 @@ linux_sigaltstack(p, uap) lss.ss_sp = oss->ss_sp; lss.ss_size = oss->ss_size; lss.ss_flags = bsd_to_linux_sigaltstack(oss->ss_flags); - error = copyout(&lss, uap->uoss, sizeof(linux_stack_t)); + error = copyout(&lss, uap->uoss, sizeof(l_stack_t)); } return (error); diff --git a/sys/i386/linux/linux_proto.h b/sys/i386/linux/linux_proto.h index 225f638..6105da1 100644 --- a/sys/i386/linux/linux_proto.h +++ b/sys/i386/linux/linux_proto.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/i386/linux/syscalls.master,v 1.40 2001/04/01 06:37:40 alc Exp + * created from FreeBSD: src/sys/i386/linux/syscalls.master,v 1.43 2001/09/08 18:48:40 marcel Exp */ #ifndef _LINUX_SYSPROTO_H_ @@ -18,548 +18,631 @@ struct proc; #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) -struct linux_setup_args { +#if BYTE_ORDER == LITTLE_ENDIAN +#define PADL_(t) 0 +#define PADR_(t) PAD_(t) +#else +#define PADL_(t) PAD_(t) +#define PADR_(t) 0 +#endif + +struct linux_fork_args { register_t dummy; }; -struct linux_fork_args { - register_t dummy; +struct linux_open_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; -struct linux_open_args { - char * path; char path_[PAD_(char *)]; - int flags; char flags_[PAD_(int)]; - int mode; char mode_[PAD_(int)]; +struct linux_waitpid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char status_l_[PADL_(l_int *)]; l_int * status; char status_r_[PADR_(l_int *)]; + char options_l_[PADL_(l_int)]; l_int options; char options_r_[PADR_(l_int)]; }; -struct linux_waitpid_args { - int pid; char pid_[PAD_(int)]; - int * status; char status_[PAD_(int *)]; - int options; char options_[PAD_(int)]; +struct linux_creat_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; -struct linux_creat_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; +struct linux_link_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; -struct linux_link_args { - char * path; char path_[PAD_(char *)]; - char * to; char to_[PAD_(char *)]; +struct linux_unlink_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_unlink_args { - char * path; char path_[PAD_(char *)]; +struct linux_execve_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char argp_l_[PADL_(char **)]; char ** argp; char argp_r_[PADR_(char **)]; + char envp_l_[PADL_(char **)]; char ** envp; char envp_r_[PADR_(char **)]; }; -struct linux_execve_args { - char * path; char path_[PAD_(char *)]; - char ** argp; char argp_[PAD_(char **)]; - char ** envp; char envp_[PAD_(char **)]; +struct linux_chdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_chdir_args { - char * path; char path_[PAD_(char *)]; +struct linux_time_args { + char tm_l_[PADL_(l_time_t *)]; l_time_t * tm; char tm_r_[PADR_(l_time_t *)]; }; -struct linux_time_args { - linux_time_t * tm; char tm_[PAD_(linux_time_t *)]; +struct linux_mknod_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; + char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)]; }; -struct linux_mknod_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; - int dev; char dev_[PAD_(int)]; +struct linux_chmod_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; }; -struct linux_chmod_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; +struct linux_lchown16_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; + char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_t)]; }; -struct linux_lchown_args { - char * path; char path_[PAD_(char *)]; - int uid; char uid_[PAD_(int)]; - int gid; char gid_[PAD_(int)]; +struct linux_stat_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char up_l_[PADL_(struct ostat *)]; struct ostat * up; char up_r_[PADR_(struct ostat *)]; }; -struct linux_break_args { - char * nsize; char nsize_[PAD_(char *)]; +struct linux_lseek_args { + char fdes_l_[PADL_(l_uint)]; l_uint fdes; char fdes_r_[PADR_(l_uint)]; + char off_l_[PADL_(l_off_t)]; l_off_t off; char off_r_[PADR_(l_off_t)]; + char whence_l_[PADL_(l_int)]; l_int whence; char whence_r_[PADR_(l_int)]; }; -struct linux_stat_args { - char * path; char path_[PAD_(char *)]; - struct ostat * up; char up_[PAD_(struct ostat *)]; +struct linux_getpid_args { + register_t dummy; }; -struct linux_lseek_args { - int fdes; char fdes_[PAD_(int)]; - long off; char off_[PAD_(long)]; - int whence; char whence_[PAD_(int)]; +struct linux_mount_args { + char specialfile_l_[PADL_(char *)]; char * specialfile; char specialfile_r_[PADR_(char *)]; + char dir_l_[PADL_(char *)]; char * dir; char dir_r_[PADR_(char *)]; + char filesystemtype_l_[PADL_(char *)]; char * filesystemtype; char filesystemtype_r_[PADR_(char *)]; + char rwflag_l_[PADL_(l_ulong)]; l_ulong rwflag; char rwflag_r_[PADR_(l_ulong)]; + char data_l_[PADL_(void *)]; void * data; char data_r_[PADR_(void *)]; }; -struct linux_mount_args { - char * specialfile; char specialfile_[PAD_(char *)]; - char * dir; char dir_[PAD_(char *)]; - char * filesystemtype; char filesystemtype_[PAD_(char *)]; - u_long rwflag; char rwflag_[PAD_(u_long)]; - void * data; char data_[PAD_(void *)]; +struct linux_oldumount_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_umount_args { - char * path; char path_[PAD_(char *)]; +struct linux_setuid16_args { + char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; }; -struct linux_stime_args { +struct linux_getuid16_args { register_t dummy; }; -struct linux_ptrace_args { +struct linux_stime_args { register_t dummy; }; -struct linux_alarm_args { - unsigned int secs; char secs_[PAD_(unsigned int)]; -}; -struct linux_fstat_args { - int fd; char fd_[PAD_(int)]; - struct ostat * up; char up_[PAD_(struct ostat *)]; -}; -struct linux_pause_args { +struct linux_ptrace_args { register_t dummy; }; -struct linux_utime_args { - char * fname; char fname_[PAD_(char *)]; - struct linux_utimbuf * times; char times_[PAD_(struct linux_utimbuf *)]; +struct linux_alarm_args { + char secs_l_[PADL_(l_uint)]; l_uint secs; char secs_r_[PADR_(l_uint)]; }; -struct linux_stty_args { - register_t dummy; +struct linux_fstat_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char up_l_[PADL_(struct ostat *)]; struct ostat * up; char up_r_[PADR_(struct ostat *)]; }; -struct linux_gtty_args { +struct linux_pause_args { register_t dummy; }; -struct linux_access_args { - char * path; char path_[PAD_(char *)]; - int flags; char flags_[PAD_(int)]; +struct linux_utime_args { + char fname_l_[PADL_(char *)]; char * fname; char fname_r_[PADR_(char *)]; + char times_l_[PADL_(struct l_utimbuf *)]; struct l_utimbuf * times; char times_r_[PADR_(struct l_utimbuf *)]; }; -struct linux_nice_args { - int inc; char inc_[PAD_(int)]; +struct linux_access_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; -struct linux_ftime_args { - register_t dummy; +struct linux_nice_args { + char inc_l_[PADL_(l_int)]; l_int inc; char inc_r_[PADR_(l_int)]; }; -struct linux_kill_args { - int pid; char pid_[PAD_(int)]; - int signum; char signum_[PAD_(int)]; +struct linux_kill_args { + char pid_l_[PADL_(l_int)]; l_int pid; char pid_r_[PADR_(l_int)]; + char signum_l_[PADL_(l_int)]; l_int signum; char signum_r_[PADR_(l_int)]; }; -struct linux_rename_args { - char * from; char from_[PAD_(char *)]; - char * to; char to_[PAD_(char *)]; +struct linux_rename_args { + char from_l_[PADL_(char *)]; char * from; char from_r_[PADR_(char *)]; + char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; -struct linux_mkdir_args { - char * path; char path_[PAD_(char *)]; - int mode; char mode_[PAD_(int)]; +struct linux_mkdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; -struct linux_rmdir_args { - char * path; char path_[PAD_(char *)]; +struct linux_rmdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; -struct linux_pipe_args { - int * pipefds; char pipefds_[PAD_(int *)]; +struct linux_pipe_args { + char pipefds_l_[PADL_(l_ulong *)]; l_ulong * pipefds; char pipefds_r_[PADR_(l_ulong *)]; }; -struct linux_times_args { - struct linux_times_argv * buf; char buf_[PAD_(struct linux_times_argv *)]; +struct linux_times_args { + char buf_l_[PADL_(struct l_times_argv *)]; struct l_times_argv * buf; char buf_r_[PADR_(struct l_times_argv *)]; }; -struct linux_prof_args { - register_t dummy; +struct linux_brk_args { + char dsend_l_[PADL_(l_ulong)]; l_ulong dsend; char dsend_r_[PADR_(l_ulong)]; }; -struct linux_brk_args { - char * dsend; char dsend_[PAD_(char *)]; +struct linux_setgid16_args { + char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_t)]; }; -struct linux_signal_args { - int sig; char sig_[PAD_(int)]; - linux_handler_t handler; char handler_[PAD_(linux_handler_t)]; +struct linux_getgid16_args { + register_t dummy; }; -struct linux_umount2_args { - char * path; char path_[PAD_(char *)]; - int flags; char flags_[PAD_(int)]; +struct linux_signal_args { + char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; + char handler_l_[PADL_(l_handler_t)]; l_handler_t handler; char handler_r_[PADR_(l_handler_t)]; }; -struct linux_lock_args { +struct linux_geteuid16_args { register_t dummy; }; -struct linux_ioctl_args { - int fd; char fd_[PAD_(int)]; - u_long cmd; char cmd_[PAD_(u_long)]; - int arg; char arg_[PAD_(int)]; +struct linux_getegid16_args { + register_t dummy; }; -struct linux_fcntl_args { - int fd; char fd_[PAD_(int)]; - int cmd; char cmd_[PAD_(int)]; - int arg; char arg_[PAD_(int)]; +struct linux_umount_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; -struct linux_mpx_args { - register_t dummy; +struct linux_ioctl_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; }; -struct linux_ulimit_args { - register_t dummy; +struct linux_fcntl_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; }; -struct linux_olduname_args { +struct linux_olduname_args { register_t dummy; }; -struct linux_ustat_args { - linux_dev_t dev; char dev_[PAD_(linux_dev_t)]; - struct linux_ustat * ubuf; char ubuf_[PAD_(struct linux_ustat *)]; +struct linux_ustat_args { + char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)]; + char ubuf_l_[PADL_(struct l_ustat *)]; struct l_ustat * ubuf; char ubuf_r_[PADR_(struct l_ustat *)]; }; -struct linux_sigaction_args { - int sig; char sig_[PAD_(int)]; - linux_osigaction_t * nsa; char nsa_[PAD_(linux_osigaction_t *)]; - linux_osigaction_t * osa; char osa_[PAD_(linux_osigaction_t *)]; +struct linux_sigaction_args { + char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; + char nsa_l_[PADL_(l_osigaction_t *)]; l_osigaction_t * nsa; char nsa_r_[PADR_(l_osigaction_t *)]; + char osa_l_[PADL_(l_osigaction_t *)]; l_osigaction_t * osa; char osa_r_[PADR_(l_osigaction_t *)]; }; -struct linux_siggetmask_args { +struct linux_sgetmask_args { register_t dummy; }; -struct linux_sigsetmask_args { - linux_osigset_t mask; char mask_[PAD_(linux_osigset_t)]; +struct linux_ssetmask_args { + char mask_l_[PADL_(l_osigset_t)]; l_osigset_t mask; char mask_r_[PADR_(l_osigset_t)]; }; -struct linux_sigsuspend_args { - int restart; char restart_[PAD_(int)]; - linux_osigset_t oldmask; char oldmask_[PAD_(linux_osigset_t)]; - linux_osigset_t mask; char mask_[PAD_(linux_osigset_t)]; +struct linux_setreuid16_args { + char ruid_l_[PADL_(l_uid16_t)]; l_uid16_t ruid; char ruid_r_[PADR_(l_uid16_t)]; + char euid_l_[PADL_(l_uid16_t)]; l_uid16_t euid; char euid_r_[PADR_(l_uid16_t)]; }; -struct linux_sigpending_args { - linux_osigset_t * mask; char mask_[PAD_(linux_osigset_t *)]; +struct linux_setregid16_args { + char rgid_l_[PADL_(l_gid16_t)]; l_gid16_t rgid; char rgid_r_[PADR_(l_gid16_t)]; + char egid_l_[PADL_(l_gid16_t)]; l_gid16_t egid; char egid_r_[PADR_(l_gid16_t)]; }; -struct linux_setrlimit_args { - u_int resource; char resource_[PAD_(u_int)]; - struct ogetrlimit * rlim; char rlim_[PAD_(struct ogetrlimit *)]; +struct linux_sigsuspend_args { + char hist0_l_[PADL_(l_int)]; l_int hist0; char hist0_r_[PADR_(l_int)]; + char hist1_l_[PADL_(l_int)]; l_int hist1; char hist1_r_[PADR_(l_int)]; + char mask_l_[PADL_(l_osigset_t)]; l_osigset_t mask; char mask_r_[PADR_(l_osigset_t)]; }; -struct linux_getrlimit_args { - u_int resource; char resource_[PAD_(u_int)]; - struct ogetrlimit * rlim; char rlim_[PAD_(struct ogetrlimit *)]; +struct linux_sigpending_args { + char mask_l_[PADL_(l_osigset_t *)]; l_osigset_t * mask; char mask_r_[PADR_(l_osigset_t *)]; }; -struct linux_getgroups_args { - u_int gidsetsize; char gidsetsize_[PAD_(u_int)]; - linux_gid_t * gidset; char gidset_[PAD_(linux_gid_t *)]; +struct linux_setrlimit_args { + char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)]; + char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)]; }; -struct linux_setgroups_args { - u_int gidsetsize; char gidsetsize_[PAD_(u_int)]; - linux_gid_t * gidset; char gidset_[PAD_(linux_gid_t *)]; +struct linux_old_getrlimit_args { + char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)]; + char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)]; }; -struct linux_select_args { - struct linux_select_argv * ptr; char ptr_[PAD_(struct linux_select_argv *)]; +struct linux_getgroups16_args { + char gidsetsize_l_[PADL_(l_uint)]; l_uint gidsetsize; char gidsetsize_r_[PADR_(l_uint)]; + char gidset_l_[PADL_(l_gid16_t *)]; l_gid16_t * gidset; char gidset_r_[PADR_(l_gid16_t *)]; }; -struct linux_symlink_args { - char * path; char path_[PAD_(char *)]; - char * to; char to_[PAD_(char *)]; +struct linux_setgroups16_args { + char gidsetsize_l_[PADL_(l_uint)]; l_uint gidsetsize; char gidsetsize_r_[PADR_(l_uint)]; + char gidset_l_[PADL_(l_gid16_t *)]; l_gid16_t * gidset; char gidset_r_[PADR_(l_gid16_t *)]; }; -struct linux_readlink_args { - char * name; char name_[PAD_(char *)]; - char * buf; char buf_[PAD_(char *)]; - int count; char count_[PAD_(int)]; +struct linux_old_select_args { + char ptr_l_[PADL_(struct l_old_select_argv *)]; struct l_old_select_argv * ptr; char ptr_r_[PADR_(struct l_old_select_argv *)]; }; -struct linux_uselib_args { - char * library; char library_[PAD_(char *)]; +struct linux_symlink_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; -struct linux_reboot_args { - int magic1; char magic1_[PAD_(int)]; - int magic2; char magic2_[PAD_(int)]; - int opt; char opt_[PAD_(int)]; +struct linux_readlink_args { + char name_l_[PADL_(char *)]; char * name; char name_r_[PADR_(char *)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char count_l_[PADL_(l_int)]; l_int count; char count_r_[PADR_(l_int)]; }; -struct linux_readdir_args { - int fd; char fd_[PAD_(int)]; - struct linux_dirent * dent; char dent_[PAD_(struct linux_dirent *)]; - unsigned int count; char count_[PAD_(unsigned int)]; +struct linux_uselib_args { + char library_l_[PADL_(char *)]; char * library; char library_r_[PADR_(char *)]; }; -struct linux_mmap_args { - struct linux_mmap_argv * ptr; char ptr_[PAD_(struct linux_mmap_argv *)]; +struct linux_reboot_args { + char magic1_l_[PADL_(l_int)]; l_int magic1; char magic1_r_[PADR_(l_int)]; + char magic2_l_[PADL_(l_int)]; l_int magic2; char magic2_r_[PADR_(l_int)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(void *)]; void * arg; char arg_r_[PADR_(void *)]; }; -struct linux_truncate_args { - char * path; char path_[PAD_(char *)]; - long length; char length_[PAD_(long)]; +struct linux_readdir_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char dent_l_[PADL_(struct l_dirent *)]; struct l_dirent * dent; char dent_r_[PADR_(struct l_dirent *)]; + char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; }; -struct linux_statfs_args { - char * path; char path_[PAD_(char *)]; - struct linux_statfs_buf * buf; char buf_[PAD_(struct linux_statfs_buf *)]; +struct linux_mmap_args { + char ptr_l_[PADL_(struct l_mmap_argv *)]; struct l_mmap_argv * ptr; char ptr_r_[PADR_(struct l_mmap_argv *)]; }; -struct linux_fstatfs_args { - int fd; char fd_[PAD_(int)]; - struct linux_statfs_buf * buf; char buf_[PAD_(struct linux_statfs_buf *)]; +struct linux_truncate_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char length_l_[PADL_(l_ulong)]; l_ulong length; char length_r_[PADR_(l_ulong)]; }; -struct linux_ioperm_args { - unsigned int start; char start_[PAD_(unsigned int)]; - unsigned int length; char length_[PAD_(unsigned int)]; - int enable; char enable_[PAD_(int)]; +struct linux_statfs_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char buf_l_[PADL_(struct l_statfs_buf *)]; struct l_statfs_buf * buf; char buf_r_[PADR_(struct l_statfs_buf *)]; }; -struct linux_socketcall_args { - int what; char what_[PAD_(int)]; - void * args; char args_[PAD_(void *)]; +struct linux_fstatfs_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(struct l_statfs_buf *)]; struct l_statfs_buf * buf; char buf_r_[PADR_(struct l_statfs_buf *)]; }; -struct linux_ksyslog_args { - int what; char what_[PAD_(int)]; +struct linux_ioperm_args { + char start_l_[PADL_(l_ulong)]; l_ulong start; char start_r_[PADR_(l_ulong)]; + char length_l_[PADL_(l_ulong)]; l_ulong length; char length_r_[PADR_(l_ulong)]; + char enable_l_[PADL_(l_int)]; l_int enable; char enable_r_[PADR_(l_int)]; }; -struct linux_setitimer_args { - u_int which; char which_[PAD_(u_int)]; - struct itimerval * itv; char itv_[PAD_(struct itimerval *)]; - struct itimerval * oitv; char oitv_[PAD_(struct itimerval *)]; +struct linux_socketcall_args { + char what_l_[PADL_(l_int)]; l_int what; char what_r_[PADR_(l_int)]; + char args_l_[PADL_(l_ulong)]; l_ulong args; char args_r_[PADR_(l_ulong)]; }; -struct linux_getitimer_args { - u_int which; char which_[PAD_(u_int)]; - struct itimerval * itv; char itv_[PAD_(struct itimerval *)]; +struct linux_syslog_args { + char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)]; }; -struct linux_newstat_args { - char * path; char path_[PAD_(char *)]; - struct linux_newstat * buf; char buf_[PAD_(struct linux_newstat *)]; +struct linux_setitimer_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)]; + char oitv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * oitv; char oitv_r_[PADR_(struct l_itimerval *)]; }; -struct linux_newlstat_args { - char * path; char path_[PAD_(char *)]; - struct linux_newstat * buf; char buf_[PAD_(struct linux_newstat *)]; +struct linux_getitimer_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)]; }; -struct linux_newfstat_args { - int fd; char fd_[PAD_(int)]; - struct linux_newstat * buf; char buf_[PAD_(struct linux_newstat *)]; +struct linux_newstat_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)]; }; -struct linux_uname_args { - register_t dummy; +struct linux_newlstat_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)]; }; -struct linux_iopl_args { - int level; char level_[PAD_(int)]; +struct linux_newfstat_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)]; }; -struct linux_vhangup_args { +struct linux_uname_args { register_t dummy; }; -struct linux_idle_args { +struct linux_iopl_args { + char level_l_[PADL_(l_ulong)]; l_ulong level; char level_r_[PADR_(l_ulong)]; +}; +struct linux_vhangup_args { register_t dummy; }; -struct linux_vm86old_args { +struct linux_vm86old_args { register_t dummy; }; -struct linux_wait4_args { - int pid; char pid_[PAD_(int)]; - int * status; char status_[PAD_(int *)]; - int options; char options_[PAD_(int)]; - struct rusage * rusage; char rusage_[PAD_(struct rusage *)]; +struct linux_wait4_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char status_l_[PADL_(l_uint *)]; l_uint * status; char status_r_[PADR_(l_uint *)]; + char options_l_[PADL_(l_int)]; l_int options; char options_r_[PADR_(l_int)]; + char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)]; }; -struct linux_swapoff_args { +struct linux_swapoff_args { register_t dummy; }; -struct linux_sysinfo_args { - struct sysinfo * info; char info_[PAD_(struct sysinfo *)]; +struct linux_sysinfo_args { + char info_l_[PADL_(struct l_sysinfo *)]; struct l_sysinfo * info; char info_r_[PADR_(struct l_sysinfo *)]; }; -struct linux_ipc_args { - int what; char what_[PAD_(int)]; - int arg1; char arg1_[PAD_(int)]; - int arg2; char arg2_[PAD_(int)]; - int arg3; char arg3_[PAD_(int)]; - caddr_t ptr; char ptr_[PAD_(caddr_t)]; +struct linux_ipc_args { + char what_l_[PADL_(l_uint)]; l_uint what; char what_r_[PADR_(l_uint)]; + char arg1_l_[PADL_(l_int)]; l_int arg1; char arg1_r_[PADR_(l_int)]; + char arg2_l_[PADL_(l_int)]; l_int arg2; char arg2_r_[PADR_(l_int)]; + char arg3_l_[PADL_(l_int)]; l_int arg3; char arg3_r_[PADR_(l_int)]; + char ptr_l_[PADL_(void *)]; void * ptr; char ptr_r_[PADR_(void *)]; + char arg5_l_[PADL_(l_long)]; l_long arg5; char arg5_r_[PADR_(l_long)]; }; -struct linux_sigreturn_args { - struct linux_sigframe * sfp; char sfp_[PAD_(struct linux_sigframe *)]; +struct linux_sigreturn_args { + char sfp_l_[PADL_(struct l_sigframe *)]; struct l_sigframe * sfp; char sfp_r_[PADR_(struct l_sigframe *)]; }; -struct linux_clone_args { - int flags; char flags_[PAD_(int)]; - void * stack; char stack_[PAD_(void *)]; +struct linux_clone_args { + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; + char stack_l_[PADL_(void *)]; void * stack; char stack_r_[PADR_(void *)]; }; -struct linux_newuname_args { - struct linux_new_utsname * buf; char buf_[PAD_(struct linux_new_utsname *)]; +struct linux_newuname_args { + char buf_l_[PADL_(struct l_new_utsname *)]; struct l_new_utsname * buf; char buf_r_[PADR_(struct l_new_utsname *)]; }; -struct linux_modify_ldt_args { - int func; char func_[PAD_(int)]; - void * ptr; char ptr_[PAD_(void *)]; - size_t bytecount; char bytecount_[PAD_(size_t)]; +struct linux_modify_ldt_args { + char func_l_[PADL_(l_int)]; l_int func; char func_r_[PADR_(l_int)]; + char ptr_l_[PADL_(void *)]; void * ptr; char ptr_r_[PADR_(void *)]; + char bytecount_l_[PADL_(l_ulong)]; l_ulong bytecount; char bytecount_r_[PADR_(l_ulong)]; }; -struct linux_adjtimex_args { +struct linux_adjtimex_args { register_t dummy; }; -struct linux_sigprocmask_args { - int how; char how_[PAD_(int)]; - linux_osigset_t * mask; char mask_[PAD_(linux_osigset_t *)]; - linux_osigset_t * omask; char omask_[PAD_(linux_osigset_t *)]; +struct linux_sigprocmask_args { + char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)]; + char mask_l_[PADL_(l_osigset_t *)]; l_osigset_t * mask; char mask_r_[PADR_(l_osigset_t *)]; + char omask_l_[PADL_(l_osigset_t *)]; l_osigset_t * omask; char omask_r_[PADR_(l_osigset_t *)]; }; -struct linux_create_module_args { +struct linux_create_module_args { register_t dummy; }; -struct linux_init_module_args { +struct linux_init_module_args { register_t dummy; }; -struct linux_delete_module_args { +struct linux_delete_module_args { register_t dummy; }; -struct linux_get_kernel_syms_args { +struct linux_get_kernel_syms_args { register_t dummy; }; -struct linux_quotactl_args { +struct linux_quotactl_args { register_t dummy; }; -struct linux_getpgid_args { - int pid; char pid_[PAD_(int)]; +struct linux_getpgid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; }; -struct linux_bdflush_args { +struct linux_bdflush_args { register_t dummy; }; -struct linux_sysfs_args { - int option; char option_[PAD_(int)]; - u_long arg1; char arg1_[PAD_(u_long)]; - u_long arg2; char arg2_[PAD_(u_long)]; +struct linux_sysfs_args { + char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)]; + char arg1_l_[PADL_(l_ulong)]; l_ulong arg1; char arg1_r_[PADR_(l_ulong)]; + char arg2_l_[PADL_(l_ulong)]; l_ulong arg2; char arg2_r_[PADR_(l_ulong)]; }; -struct linux_personality_args { - int per; char per_[PAD_(int)]; +struct linux_personality_args { + char per_l_[PADL_(l_ulong)]; l_ulong per; char per_r_[PADR_(l_ulong)]; }; -struct linux_afs_syscall_args { - register_t dummy; +struct linux_setfsuid16_args { + char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; }; -struct linux_setfsuid_args { - linux_uid_t uid; char uid_[PAD_(linux_uid_t)]; +struct linux_setfsgid16_args { + char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_t)]; }; -struct linux_setfsgid_args { - linux_gid_t gid; char gid_[PAD_(linux_gid_t)]; +struct linux_llseek_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char ohigh_l_[PADL_(l_ulong)]; l_ulong ohigh; char ohigh_r_[PADR_(l_ulong)]; + char olow_l_[PADL_(l_ulong)]; l_ulong olow; char olow_r_[PADR_(l_ulong)]; + char res_l_[PADL_(l_loff_t *)]; l_loff_t * res; char res_r_[PADR_(l_loff_t *)]; + char whence_l_[PADL_(l_uint)]; l_uint whence; char whence_r_[PADR_(l_uint)]; }; -struct linux_llseek_args { - int fd; char fd_[PAD_(int)]; - u_int32_t ohigh; char ohigh_[PAD_(u_int32_t)]; - u_int32_t olow; char olow_[PAD_(u_int32_t)]; - caddr_t res; char res_[PAD_(caddr_t)]; - int whence; char whence_[PAD_(int)]; +struct linux_getdents_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char dent_l_[PADL_(void *)]; void * dent; char dent_r_[PADR_(void *)]; + char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; }; -struct linux_getdents_args { - int fd; char fd_[PAD_(int)]; - void * dent; char dent_[PAD_(void *)]; - unsigned count; char count_[PAD_(unsigned)]; +struct linux_select_args { + char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)]; + char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)]; + char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)]; + char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)]; + char timeout_l_[PADL_(struct l_timeval *)]; struct l_timeval * timeout; char timeout_r_[PADR_(struct l_timeval *)]; }; -struct linux_newselect_args { - int nfds; char nfds_[PAD_(int)]; - fd_set * readfds; char readfds_[PAD_(fd_set *)]; - fd_set * writefds; char writefds_[PAD_(fd_set *)]; - fd_set * exceptfds; char exceptfds_[PAD_(fd_set *)]; - struct timeval * timeout; char timeout_[PAD_(struct timeval *)]; +struct linux_msync_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char fl_l_[PADL_(l_int)]; l_int fl; char fl_r_[PADR_(l_int)]; }; -struct linux_msync_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - int len; char len_[PAD_(int)]; - int fl; char fl_[PAD_(int)]; +struct linux_getsid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; }; -struct linux_getsid_args { - linux_pid_t pid; char pid_[PAD_(linux_pid_t)]; +struct linux_fdatasync_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; }; -struct linux_fdatasync_args { - int fd; char fd_[PAD_(int)]; +struct linux_sysctl_args { + char args_l_[PADL_(struct l___sysctl_args *)]; struct l___sysctl_args * args; char args_r_[PADR_(struct l___sysctl_args *)]; }; -struct linux_sysctl_args { - register_t dummy; +struct linux_sched_setscheduler_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)]; + char param_l_[PADL_(struct l_sched_param *)]; struct l_sched_param * param; char param_r_[PADR_(struct l_sched_param *)]; }; -struct linux_sched_setscheduler_args { - pid_t pid; char pid_[PAD_(pid_t)]; - int policy; char policy_[PAD_(int)]; - const struct sched_param * param; char param_[PAD_(const struct sched_param *)]; +struct linux_sched_getscheduler_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; }; -struct linux_sched_getscheduler_args { - pid_t pid; char pid_[PAD_(pid_t)]; +struct linux_sched_get_priority_max_args { + char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)]; }; -struct linux_sched_get_priority_max_args { - int policy; char policy_[PAD_(int)]; +struct linux_sched_get_priority_min_args { + char policy_l_[PADL_(l_int)]; l_int policy; char policy_r_[PADR_(l_int)]; }; -struct linux_sched_get_priority_min_args { - int policy; char policy_[PAD_(int)]; +struct linux_mremap_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char old_len_l_[PADL_(l_ulong)]; l_ulong old_len; char old_len_r_[PADR_(l_ulong)]; + char new_len_l_[PADL_(l_ulong)]; l_ulong new_len; char new_len_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; + char new_addr_l_[PADL_(l_ulong)]; l_ulong new_addr; char new_addr_r_[PADR_(l_ulong)]; }; -struct linux_mremap_args { - caddr_t addr; char addr_[PAD_(caddr_t)]; - int old_len; char old_len_[PAD_(int)]; - int new_len; char new_len_[PAD_(int)]; - int flags; char flags_[PAD_(int)]; +struct linux_setresuid16_args { + char ruid_l_[PADL_(l_uid16_t)]; l_uid16_t ruid; char ruid_r_[PADR_(l_uid16_t)]; + char euid_l_[PADL_(l_uid16_t)]; l_uid16_t euid; char euid_r_[PADR_(l_uid16_t)]; + char suid_l_[PADL_(l_uid16_t)]; l_uid16_t suid; char suid_r_[PADR_(l_uid16_t)]; }; -struct linux_getresuid_args { - linux_uid_t * ruid; char ruid_[PAD_(linux_uid_t *)]; - linux_uid_t * euid; char euid_[PAD_(linux_uid_t *)]; - linux_uid_t * suid; char suid_[PAD_(linux_uid_t *)]; +struct linux_getresuid16_args { + char ruid_l_[PADL_(l_uid16_t *)]; l_uid16_t * ruid; char ruid_r_[PADR_(l_uid16_t *)]; + char euid_l_[PADL_(l_uid16_t *)]; l_uid16_t * euid; char euid_r_[PADR_(l_uid16_t *)]; + char suid_l_[PADL_(l_uid16_t *)]; l_uid16_t * suid; char suid_r_[PADR_(l_uid16_t *)]; }; -struct linux_vm86_args { +struct linux_vm86_args { register_t dummy; }; -struct linux_query_module_args { +struct linux_query_module_args { register_t dummy; }; -struct linux_nfsservctl_args { +struct linux_nfsservctl_args { register_t dummy; }; -struct linux_getresgid_args { - linux_gid_t * rgid; char rgid_[PAD_(linux_gid_t *)]; - linux_gid_t * egid; char egid_[PAD_(linux_gid_t *)]; - linux_gid_t * sgid; char sgid_[PAD_(linux_gid_t *)]; +struct linux_setresgid16_args { + char rgid_l_[PADL_(l_gid16_t)]; l_gid16_t rgid; char rgid_r_[PADR_(l_gid16_t)]; + char egid_l_[PADL_(l_gid16_t)]; l_gid16_t egid; char egid_r_[PADR_(l_gid16_t)]; + char sgid_l_[PADL_(l_gid16_t)]; l_gid16_t sgid; char sgid_r_[PADR_(l_gid16_t)]; }; -struct linux_prctl_args { +struct linux_getresgid16_args { + char rgid_l_[PADL_(l_gid16_t *)]; l_gid16_t * rgid; char rgid_r_[PADR_(l_gid16_t *)]; + char egid_l_[PADL_(l_gid16_t *)]; l_gid16_t * egid; char egid_r_[PADR_(l_gid16_t *)]; + char sgid_l_[PADL_(l_gid16_t *)]; l_gid16_t * sgid; char sgid_r_[PADR_(l_gid16_t *)]; +}; +struct linux_prctl_args { register_t dummy; }; -struct linux_rt_sigreturn_args { - struct linux_ucontext * ucp; char ucp_[PAD_(struct linux_ucontext *)]; +struct linux_rt_sigreturn_args { + char ucp_l_[PADL_(struct l_ucontext *)]; struct l_ucontext * ucp; char ucp_r_[PADR_(struct l_ucontext *)]; }; -struct linux_rt_sigaction_args { - int sig; char sig_[PAD_(int)]; - linux_sigaction_t * act; char act_[PAD_(linux_sigaction_t *)]; - linux_sigaction_t * oact; char oact_[PAD_(linux_sigaction_t *)]; - size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; +struct linux_rt_sigaction_args { + char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; + char act_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * act; char act_r_[PADR_(l_sigaction_t *)]; + char oact_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * oact; char oact_r_[PADR_(l_sigaction_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; -struct linux_rt_sigprocmask_args { - int how; char how_[PAD_(int)]; - linux_sigset_t * mask; char mask_[PAD_(linux_sigset_t *)]; - linux_sigset_t * omask; char omask_[PAD_(linux_sigset_t *)]; - size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; +struct linux_rt_sigprocmask_args { + char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)]; + char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)]; + char omask_l_[PADL_(l_sigset_t *)]; l_sigset_t * omask; char omask_r_[PADR_(l_sigset_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; -struct linux_rt_sigpending_args { +struct linux_rt_sigpending_args { register_t dummy; }; -struct linux_rt_sigtimedwait_args { +struct linux_rt_sigtimedwait_args { register_t dummy; }; -struct linux_rt_sigqueueinfo_args { +struct linux_rt_sigqueueinfo_args { register_t dummy; }; -struct linux_rt_sigsuspend_args { - linux_sigset_t * newset; char newset_[PAD_(linux_sigset_t *)]; - size_t sigsetsize; char sigsetsize_[PAD_(size_t)]; +struct linux_rt_sigsuspend_args { + char newset_l_[PADL_(l_sigset_t *)]; l_sigset_t * newset; char newset_r_[PADR_(l_sigset_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; -struct linux_pread_args { - int fd; char fd_[PAD_(int)]; - char * buf; char buf_[PAD_(char *)]; - size_t nbyte; char nbyte_[PAD_(size_t)]; - off_t offset; char offset_[PAD_(off_t)]; +struct linux_pread_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; }; -struct linux_pwrite_args { - int fd; char fd_[PAD_(int)]; - const char * buf; char buf_[PAD_(const char *)]; - size_t nbyte; char nbyte_[PAD_(size_t)]; - off_t offset; char offset_[PAD_(off_t)]; +struct linux_pwrite_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; }; -struct linux_chown_args { - char * path; char path_[PAD_(char *)]; - int uid; char uid_[PAD_(int)]; - int gid; char gid_[PAD_(int)]; +struct linux_chown16_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; + char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_t)]; }; -struct linux_getcwd_args { - char * buf; char buf_[PAD_(char *)]; - unsigned long bufsize; char bufsize_[PAD_(unsigned long)]; +struct linux_getcwd_args { + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char bufsize_l_[PADL_(l_ulong)]; l_ulong bufsize; char bufsize_r_[PADR_(l_ulong)]; }; -struct linux_capget_args { +struct linux_capget_args { register_t dummy; }; -struct linux_capset_args { +struct linux_capset_args { register_t dummy; }; -struct linux_sigaltstack_args { - const linux_stack_t * uss; char uss_[PAD_(const linux_stack_t *)]; - linux_stack_t * uoss; char uoss_[PAD_(linux_stack_t *)]; +struct linux_sigaltstack_args { + char uss_l_[PADL_(l_stack_t *)]; l_stack_t * uss; char uss_r_[PADR_(l_stack_t *)]; + char uoss_l_[PADL_(l_stack_t *)]; l_stack_t * uoss; char uoss_r_[PADR_(l_stack_t *)]; }; -struct linux_sendfile_args { +struct linux_sendfile_args { register_t dummy; }; -struct linux_getpmsg_args { +struct linux_vfork_args { register_t dummy; }; -struct linux_putpmsg_args { - register_t dummy; +struct linux_getrlimit_args { + char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)]; + char rlim_l_[PADL_(struct l_rlimit *)]; struct l_rlimit * rlim; char rlim_r_[PADR_(struct l_rlimit *)]; }; -struct linux_vfork_args { - register_t dummy; +struct linux_mmap2_args { + char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_ulong)]; l_ulong len; char len_r_[PADR_(l_ulong)]; + char prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char pgoff_l_[PADL_(l_ulong)]; l_ulong pgoff; char pgoff_r_[PADR_(l_ulong)]; }; -struct linux_ugetrlimit_args { - register_t dummy; +struct linux_truncate64_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char length_l_[PADL_(l_loff_t)]; l_loff_t length; char length_r_[PADR_(l_loff_t)]; }; -struct linux_mmap2_args { - register_t dummy; +struct linux_ftruncate64_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char length_l_[PADL_(l_loff_t)]; l_loff_t length; char length_r_[PADR_(l_loff_t)]; }; -struct linux_truncate64_args { - register_t dummy; +struct linux_stat64_args { + char filename_l_[PADL_(char *)]; char * filename; char filename_r_[PADR_(char *)]; + char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; + char flags_l_[PADL_(l_long)]; l_long flags; char flags_r_[PADR_(l_long)]; }; -struct linux_ftruncate64_args { - register_t dummy; +struct linux_lstat64_args { + char filename_l_[PADL_(char *)]; char * filename; char filename_r_[PADR_(char *)]; + char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; + char flags_l_[PADL_(l_long)]; l_long flags; char flags_r_[PADR_(l_long)]; +}; +struct linux_fstat64_args { + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; + char flags_l_[PADL_(l_long)]; l_long flags; char flags_r_[PADR_(l_long)]; }; -struct linux_stat64_args { +struct linux_lchown_args { + char filename_l_[PADL_(char *)]; char * filename; char filename_r_[PADR_(char *)]; + char user_l_[PADL_(l_uid_t)]; l_uid_t user; char user_r_[PADR_(l_uid_t)]; + char group_l_[PADL_(l_gid_t)]; l_gid_t group; char group_r_[PADR_(l_gid_t)]; +}; +struct linux_getuid_args { register_t dummy; }; -struct linux_lstat64_args { +struct linux_getgid_args { register_t dummy; }; -struct linux_fstat64_args { +struct linux_getgroups_args { + char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)]; + char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)]; +}; +struct linux_setgroups_args { + char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)]; + char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)]; +}; +struct linux_fchown_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char user_l_[PADL_(l_uid_t)]; l_uid_t user; char user_r_[PADR_(l_uid_t)]; + char group_l_[PADL_(l_gid_t)]; l_gid_t group; char group_r_[PADR_(l_gid_t)]; +}; +struct linux_chown_args { + char filename_l_[PADL_(char *)]; char * filename; char filename_r_[PADR_(char *)]; + char user_l_[PADL_(l_uid_t)]; l_uid_t user; char user_r_[PADR_(l_uid_t)]; + char group_l_[PADL_(l_gid_t)]; l_gid_t group; char group_r_[PADR_(l_gid_t)]; +}; +struct linux_setfsuid_args { + char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)]; +}; +struct linux_setfsgid_args { + char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)]; +}; +struct linux_pivot_root_args { + char new_root_l_[PADL_(char *)]; char * new_root; char new_root_r_[PADR_(char *)]; + char put_old_l_[PADL_(char *)]; char * put_old; char put_old_r_[PADR_(char *)]; +}; +struct linux_mincore_args { + char start_l_[PADL_(l_ulong)]; l_ulong start; char start_r_[PADR_(l_ulong)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char vec_l_[PADL_(u_char *)]; u_char * vec; char vec_r_[PADR_(u_char *)]; +}; +struct linux_madvise_args { register_t dummy; }; -int linux_setup __P((struct proc *, struct linux_setup_args *)); +struct linux_getdents64_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char dirent_l_[PADL_(void *)]; void * dirent; char dirent_r_[PADR_(void *)]; + char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; +}; +struct linux_fcntl64_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; + char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; +}; int linux_fork __P((struct proc *, struct linux_fork_args *)); int linux_open __P((struct proc *, struct linux_open_args *)); int linux_waitpid __P((struct proc *, struct linux_waitpid_args *)); @@ -571,50 +654,51 @@ int linux_chdir __P((struct proc *, struct linux_chdir_args *)); int linux_time __P((struct proc *, struct linux_time_args *)); int linux_mknod __P((struct proc *, struct linux_mknod_args *)); int linux_chmod __P((struct proc *, struct linux_chmod_args *)); -int linux_lchown __P((struct proc *, struct linux_lchown_args *)); -int linux_break __P((struct proc *, struct linux_break_args *)); +int linux_lchown16 __P((struct proc *, struct linux_lchown16_args *)); int linux_stat __P((struct proc *, struct linux_stat_args *)); int linux_lseek __P((struct proc *, struct linux_lseek_args *)); +int linux_getpid __P((struct proc *, struct linux_getpid_args *)); int linux_mount __P((struct proc *, struct linux_mount_args *)); -int linux_umount __P((struct proc *, struct linux_umount_args *)); +int linux_oldumount __P((struct proc *, struct linux_oldumount_args *)); +int linux_setuid16 __P((struct proc *, struct linux_setuid16_args *)); +int linux_getuid16 __P((struct proc *, struct linux_getuid16_args *)); int linux_stime __P((struct proc *, struct linux_stime_args *)); int linux_ptrace __P((struct proc *, struct linux_ptrace_args *)); int linux_alarm __P((struct proc *, struct linux_alarm_args *)); int linux_fstat __P((struct proc *, struct linux_fstat_args *)); int linux_pause __P((struct proc *, struct linux_pause_args *)); int linux_utime __P((struct proc *, struct linux_utime_args *)); -int linux_stty __P((struct proc *, struct linux_stty_args *)); -int linux_gtty __P((struct proc *, struct linux_gtty_args *)); int linux_access __P((struct proc *, struct linux_access_args *)); int linux_nice __P((struct proc *, struct linux_nice_args *)); -int linux_ftime __P((struct proc *, struct linux_ftime_args *)); int linux_kill __P((struct proc *, struct linux_kill_args *)); int linux_rename __P((struct proc *, struct linux_rename_args *)); int linux_mkdir __P((struct proc *, struct linux_mkdir_args *)); int linux_rmdir __P((struct proc *, struct linux_rmdir_args *)); int linux_pipe __P((struct proc *, struct linux_pipe_args *)); int linux_times __P((struct proc *, struct linux_times_args *)); -int linux_prof __P((struct proc *, struct linux_prof_args *)); int linux_brk __P((struct proc *, struct linux_brk_args *)); +int linux_setgid16 __P((struct proc *, struct linux_setgid16_args *)); +int linux_getgid16 __P((struct proc *, struct linux_getgid16_args *)); int linux_signal __P((struct proc *, struct linux_signal_args *)); -int linux_umount2 __P((struct proc *, struct linux_umount2_args *)); -int linux_lock __P((struct proc *, struct linux_lock_args *)); +int linux_geteuid16 __P((struct proc *, struct linux_geteuid16_args *)); +int linux_getegid16 __P((struct proc *, struct linux_getegid16_args *)); +int linux_umount __P((struct proc *, struct linux_umount_args *)); int linux_ioctl __P((struct proc *, struct linux_ioctl_args *)); int linux_fcntl __P((struct proc *, struct linux_fcntl_args *)); -int linux_mpx __P((struct proc *, struct linux_mpx_args *)); -int linux_ulimit __P((struct proc *, struct linux_ulimit_args *)); int linux_olduname __P((struct proc *, struct linux_olduname_args *)); int linux_ustat __P((struct proc *, struct linux_ustat_args *)); int linux_sigaction __P((struct proc *, struct linux_sigaction_args *)); -int linux_siggetmask __P((struct proc *, struct linux_siggetmask_args *)); -int linux_sigsetmask __P((struct proc *, struct linux_sigsetmask_args *)); +int linux_sgetmask __P((struct proc *, struct linux_sgetmask_args *)); +int linux_ssetmask __P((struct proc *, struct linux_ssetmask_args *)); +int linux_setreuid16 __P((struct proc *, struct linux_setreuid16_args *)); +int linux_setregid16 __P((struct proc *, struct linux_setregid16_args *)); int linux_sigsuspend __P((struct proc *, struct linux_sigsuspend_args *)); int linux_sigpending __P((struct proc *, struct linux_sigpending_args *)); int linux_setrlimit __P((struct proc *, struct linux_setrlimit_args *)); -int linux_getrlimit __P((struct proc *, struct linux_getrlimit_args *)); -int linux_getgroups __P((struct proc *, struct linux_getgroups_args *)); -int linux_setgroups __P((struct proc *, struct linux_setgroups_args *)); -int linux_select __P((struct proc *, struct linux_select_args *)); +int linux_old_getrlimit __P((struct proc *, struct linux_old_getrlimit_args *)); +int linux_getgroups16 __P((struct proc *, struct linux_getgroups16_args *)); +int linux_setgroups16 __P((struct proc *, struct linux_setgroups16_args *)); +int linux_old_select __P((struct proc *, struct linux_old_select_args *)); int linux_symlink __P((struct proc *, struct linux_symlink_args *)); int linux_readlink __P((struct proc *, struct linux_readlink_args *)); int linux_uselib __P((struct proc *, struct linux_uselib_args *)); @@ -626,7 +710,7 @@ int linux_statfs __P((struct proc *, struct linux_statfs_args *)); int linux_fstatfs __P((struct proc *, struct linux_fstatfs_args *)); int linux_ioperm __P((struct proc *, struct linux_ioperm_args *)); int linux_socketcall __P((struct proc *, struct linux_socketcall_args *)); -int linux_ksyslog __P((struct proc *, struct linux_ksyslog_args *)); +int linux_syslog __P((struct proc *, struct linux_syslog_args *)); int linux_setitimer __P((struct proc *, struct linux_setitimer_args *)); int linux_getitimer __P((struct proc *, struct linux_getitimer_args *)); int linux_newstat __P((struct proc *, struct linux_newstat_args *)); @@ -635,7 +719,6 @@ int linux_newfstat __P((struct proc *, struct linux_newfstat_args *)); int linux_uname __P((struct proc *, struct linux_uname_args *)); int linux_iopl __P((struct proc *, struct linux_iopl_args *)); int linux_vhangup __P((struct proc *, struct linux_vhangup_args *)); -int linux_idle __P((struct proc *, struct linux_idle_args *)); int linux_vm86old __P((struct proc *, struct linux_vm86old_args *)); int linux_wait4 __P((struct proc *, struct linux_wait4_args *)); int linux_swapoff __P((struct proc *, struct linux_swapoff_args *)); @@ -656,12 +739,11 @@ int linux_getpgid __P((struct proc *, struct linux_getpgid_args *)); int linux_bdflush __P((struct proc *, struct linux_bdflush_args *)); int linux_sysfs __P((struct proc *, struct linux_sysfs_args *)); int linux_personality __P((struct proc *, struct linux_personality_args *)); -int linux_afs_syscall __P((struct proc *, struct linux_afs_syscall_args *)); -int linux_setfsuid __P((struct proc *, struct linux_setfsuid_args *)); -int linux_setfsgid __P((struct proc *, struct linux_setfsgid_args *)); +int linux_setfsuid16 __P((struct proc *, struct linux_setfsuid16_args *)); +int linux_setfsgid16 __P((struct proc *, struct linux_setfsgid16_args *)); int linux_llseek __P((struct proc *, struct linux_llseek_args *)); int linux_getdents __P((struct proc *, struct linux_getdents_args *)); -int linux_newselect __P((struct proc *, struct linux_newselect_args *)); +int linux_select __P((struct proc *, struct linux_select_args *)); int linux_msync __P((struct proc *, struct linux_msync_args *)); int linux_getsid __P((struct proc *, struct linux_getsid_args *)); int linux_fdatasync __P((struct proc *, struct linux_fdatasync_args *)); @@ -671,11 +753,13 @@ int linux_sched_getscheduler __P((struct proc *, struct linux_sched_getscheduler int linux_sched_get_priority_max __P((struct proc *, struct linux_sched_get_priority_max_args *)); int linux_sched_get_priority_min __P((struct proc *, struct linux_sched_get_priority_min_args *)); int linux_mremap __P((struct proc *, struct linux_mremap_args *)); -int linux_getresuid __P((struct proc *, struct linux_getresuid_args *)); +int linux_setresuid16 __P((struct proc *, struct linux_setresuid16_args *)); +int linux_getresuid16 __P((struct proc *, struct linux_getresuid16_args *)); int linux_vm86 __P((struct proc *, struct linux_vm86_args *)); int linux_query_module __P((struct proc *, struct linux_query_module_args *)); int linux_nfsservctl __P((struct proc *, struct linux_nfsservctl_args *)); -int linux_getresgid __P((struct proc *, struct linux_getresgid_args *)); +int linux_setresgid16 __P((struct proc *, struct linux_setresgid16_args *)); +int linux_getresgid16 __P((struct proc *, struct linux_getresgid16_args *)); int linux_prctl __P((struct proc *, struct linux_prctl_args *)); int linux_rt_sigreturn __P((struct proc *, struct linux_rt_sigreturn_args *)); int linux_rt_sigaction __P((struct proc *, struct linux_rt_sigaction_args *)); @@ -686,22 +770,34 @@ int linux_rt_sigqueueinfo __P((struct proc *, struct linux_rt_sigqueueinfo_args int linux_rt_sigsuspend __P((struct proc *, struct linux_rt_sigsuspend_args *)); int linux_pread __P((struct proc *, struct linux_pread_args *)); int linux_pwrite __P((struct proc *, struct linux_pwrite_args *)); -int linux_chown __P((struct proc *, struct linux_chown_args *)); +int linux_chown16 __P((struct proc *, struct linux_chown16_args *)); int linux_getcwd __P((struct proc *, struct linux_getcwd_args *)); int linux_capget __P((struct proc *, struct linux_capget_args *)); int linux_capset __P((struct proc *, struct linux_capset_args *)); int linux_sigaltstack __P((struct proc *, struct linux_sigaltstack_args *)); int linux_sendfile __P((struct proc *, struct linux_sendfile_args *)); -int linux_getpmsg __P((struct proc *, struct linux_getpmsg_args *)); -int linux_putpmsg __P((struct proc *, struct linux_putpmsg_args *)); int linux_vfork __P((struct proc *, struct linux_vfork_args *)); -int linux_ugetrlimit __P((struct proc *, struct linux_ugetrlimit_args *)); +int linux_getrlimit __P((struct proc *, struct linux_getrlimit_args *)); int linux_mmap2 __P((struct proc *, struct linux_mmap2_args *)); int linux_truncate64 __P((struct proc *, struct linux_truncate64_args *)); int linux_ftruncate64 __P((struct proc *, struct linux_ftruncate64_args *)); int linux_stat64 __P((struct proc *, struct linux_stat64_args *)); int linux_lstat64 __P((struct proc *, struct linux_lstat64_args *)); int linux_fstat64 __P((struct proc *, struct linux_fstat64_args *)); +int linux_lchown __P((struct proc *, struct linux_lchown_args *)); +int linux_getuid __P((struct proc *, struct linux_getuid_args *)); +int linux_getgid __P((struct proc *, struct linux_getgid_args *)); +int linux_getgroups __P((struct proc *, struct linux_getgroups_args *)); +int linux_setgroups __P((struct proc *, struct linux_setgroups_args *)); +int linux_fchown __P((struct proc *, struct linux_fchown_args *)); +int linux_chown __P((struct proc *, struct linux_chown_args *)); +int linux_setfsuid __P((struct proc *, struct linux_setfsuid_args *)); +int linux_setfsgid __P((struct proc *, struct linux_setfsgid_args *)); +int linux_pivot_root __P((struct proc *, struct linux_pivot_root_args *)); +int linux_mincore __P((struct proc *, struct linux_mincore_args *)); +int linux_madvise __P((struct proc *, struct linux_madvise_args *)); +int linux_getdents64 __P((struct proc *, struct linux_getdents64_args *)); +int linux_fcntl64 __P((struct proc *, struct linux_fcntl64_args *)); #ifdef COMPAT_43 @@ -709,5 +805,7 @@ int linux_fstat64 __P((struct proc *, struct linux_fstat64_args *)); #endif /* COMPAT_43 */ #undef PAD_ +#undef PADL_ +#undef PADR_ #endif /* !_LINUX_SYSPROTO_H_ */ diff --git a/sys/i386/linux/linux_syscall.h b/sys/i386/linux/linux_syscall.h index c4e3dad..19f4a92 100644 --- a/sys/i386/linux/linux_syscall.h +++ b/sys/i386/linux/linux_syscall.h @@ -3,10 +3,9 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/i386/linux/syscalls.master,v 1.40 2001/04/01 06:37:40 alc Exp + * created from FreeBSD: src/sys/i386/linux/syscalls.master,v 1.43 2001/09/08 18:48:40 marcel Exp */ -#define LINUX_SYS_linux_setup 0 #define LINUX_SYS_exit 1 #define LINUX_SYS_linux_fork 2 #define LINUX_SYS_read 3 @@ -22,26 +21,22 @@ #define LINUX_SYS_linux_time 13 #define LINUX_SYS_linux_mknod 14 #define LINUX_SYS_linux_chmod 15 -#define LINUX_SYS_linux_lchown 16 -#define LINUX_SYS_linux_break 17 +#define LINUX_SYS_linux_lchown16 16 #define LINUX_SYS_linux_stat 18 #define LINUX_SYS_linux_lseek 19 -#define LINUX_SYS_getpid 20 +#define LINUX_SYS_linux_getpid 20 #define LINUX_SYS_linux_mount 21 -#define LINUX_SYS_linux_umount 22 -#define LINUX_SYS_setuid 23 -#define LINUX_SYS_getuid 24 +#define LINUX_SYS_linux_oldumount 22 +#define LINUX_SYS_linux_setuid16 23 +#define LINUX_SYS_linux_getuid16 24 #define LINUX_SYS_linux_stime 25 #define LINUX_SYS_linux_ptrace 26 #define LINUX_SYS_linux_alarm 27 #define LINUX_SYS_linux_fstat 28 #define LINUX_SYS_linux_pause 29 #define LINUX_SYS_linux_utime 30 -#define LINUX_SYS_linux_stty 31 -#define LINUX_SYS_linux_gtty 32 #define LINUX_SYS_linux_access 33 #define LINUX_SYS_linux_nice 34 -#define LINUX_SYS_linux_ftime 35 #define LINUX_SYS_sync 36 #define LINUX_SYS_linux_kill 37 #define LINUX_SYS_linux_rename 38 @@ -50,21 +45,17 @@ #define LINUX_SYS_dup 41 #define LINUX_SYS_linux_pipe 42 #define LINUX_SYS_linux_times 43 -#define LINUX_SYS_linux_prof 44 #define LINUX_SYS_linux_brk 45 -#define LINUX_SYS_setgid 46 -#define LINUX_SYS_getgid 47 +#define LINUX_SYS_linux_setgid16 46 +#define LINUX_SYS_linux_getgid16 47 #define LINUX_SYS_linux_signal 48 -#define LINUX_SYS_geteuid 49 -#define LINUX_SYS_getegid 50 +#define LINUX_SYS_linux_geteuid16 49 +#define LINUX_SYS_linux_getegid16 50 #define LINUX_SYS_acct 51 -#define LINUX_SYS_linux_umount2 52 -#define LINUX_SYS_linux_lock 53 +#define LINUX_SYS_linux_umount 52 #define LINUX_SYS_linux_ioctl 54 #define LINUX_SYS_linux_fcntl 55 -#define LINUX_SYS_linux_mpx 56 #define LINUX_SYS_setpgid 57 -#define LINUX_SYS_linux_ulimit 58 #define LINUX_SYS_linux_olduname 59 #define LINUX_SYS_umask 60 #define LINUX_SYS_chroot 61 @@ -74,21 +65,21 @@ #define LINUX_SYS_getpgrp 65 #define LINUX_SYS_setsid 66 #define LINUX_SYS_linux_sigaction 67 -#define LINUX_SYS_linux_siggetmask 68 -#define LINUX_SYS_linux_sigsetmask 69 -#define LINUX_SYS_setreuid 70 -#define LINUX_SYS_setregid 71 +#define LINUX_SYS_linux_sgetmask 68 +#define LINUX_SYS_linux_ssetmask 69 +#define LINUX_SYS_linux_setreuid16 70 +#define LINUX_SYS_linux_setregid16 71 #define LINUX_SYS_linux_sigsuspend 72 #define LINUX_SYS_linux_sigpending 73 #define LINUX_SYS_osethostname 74 #define LINUX_SYS_linux_setrlimit 75 -#define LINUX_SYS_linux_getrlimit 76 +#define LINUX_SYS_linux_old_getrlimit 76 #define LINUX_SYS_getrusage 77 #define LINUX_SYS_gettimeofday 78 #define LINUX_SYS_settimeofday 79 -#define LINUX_SYS_linux_getgroups 80 -#define LINUX_SYS_linux_setgroups 81 -#define LINUX_SYS_linux_select 82 +#define LINUX_SYS_linux_getgroups16 80 +#define LINUX_SYS_linux_setgroups16 81 +#define LINUX_SYS_linux_old_select 82 #define LINUX_SYS_linux_symlink 83 #define LINUX_SYS_ostat 84 #define LINUX_SYS_linux_readlink 85 @@ -104,12 +95,11 @@ #define LINUX_SYS_fchown 95 #define LINUX_SYS_getpriority 96 #define LINUX_SYS_setpriority 97 -#define LINUX_SYS_profil 98 #define LINUX_SYS_linux_statfs 99 #define LINUX_SYS_linux_fstatfs 100 #define LINUX_SYS_linux_ioperm 101 #define LINUX_SYS_linux_socketcall 102 -#define LINUX_SYS_linux_ksyslog 103 +#define LINUX_SYS_linux_syslog 103 #define LINUX_SYS_linux_setitimer 104 #define LINUX_SYS_linux_getitimer 105 #define LINUX_SYS_linux_newstat 106 @@ -118,7 +108,6 @@ #define LINUX_SYS_linux_uname 109 #define LINUX_SYS_linux_iopl 110 #define LINUX_SYS_linux_vhangup 111 -#define LINUX_SYS_linux_idle 112 #define LINUX_SYS_linux_vm86old 113 #define LINUX_SYS_linux_wait4 114 #define LINUX_SYS_linux_swapoff 115 @@ -143,12 +132,11 @@ #define LINUX_SYS_linux_bdflush 134 #define LINUX_SYS_linux_sysfs 135 #define LINUX_SYS_linux_personality 136 -#define LINUX_SYS_linux_afs_syscall 137 -#define LINUX_SYS_linux_setfsuid 138 -#define LINUX_SYS_linux_setfsgid 139 +#define LINUX_SYS_linux_setfsuid16 138 +#define LINUX_SYS_linux_setfsgid16 139 #define LINUX_SYS_linux_llseek 140 #define LINUX_SYS_linux_getdents 141 -#define LINUX_SYS_linux_newselect 142 +#define LINUX_SYS_linux_select 142 #define LINUX_SYS_flock 143 #define LINUX_SYS_linux_msync 144 #define LINUX_SYS_readv 145 @@ -170,14 +158,14 @@ #define LINUX_SYS_sched_rr_get_interval 161 #define LINUX_SYS_nanosleep 162 #define LINUX_SYS_linux_mremap 163 -#define LINUX_SYS_setresuid 164 -#define LINUX_SYS_linux_getresuid 165 +#define LINUX_SYS_linux_setresuid16 164 +#define LINUX_SYS_linux_getresuid16 165 #define LINUX_SYS_linux_vm86 166 #define LINUX_SYS_linux_query_module 167 #define LINUX_SYS_poll 168 #define LINUX_SYS_linux_nfsservctl 169 -#define LINUX_SYS_setresgid 170 -#define LINUX_SYS_linux_getresgid 171 +#define LINUX_SYS_linux_setresgid16 170 +#define LINUX_SYS_linux_getresgid16 171 #define LINUX_SYS_linux_prctl 172 #define LINUX_SYS_linux_rt_sigreturn 173 #define LINUX_SYS_linux_rt_sigaction 174 @@ -188,20 +176,42 @@ #define LINUX_SYS_linux_rt_sigsuspend 179 #define LINUX_SYS_linux_pread 180 #define LINUX_SYS_linux_pwrite 181 -#define LINUX_SYS_linux_chown 182 +#define LINUX_SYS_linux_chown16 182 #define LINUX_SYS_linux_getcwd 183 #define LINUX_SYS_linux_capget 184 #define LINUX_SYS_linux_capset 185 #define LINUX_SYS_linux_sigaltstack 186 #define LINUX_SYS_linux_sendfile 187 -#define LINUX_SYS_linux_getpmsg 188 -#define LINUX_SYS_linux_putpmsg 189 #define LINUX_SYS_linux_vfork 190 -#define LINUX_SYS_linux_ugetrlimit 191 +#define LINUX_SYS_linux_getrlimit 191 #define LINUX_SYS_linux_mmap2 192 #define LINUX_SYS_linux_truncate64 193 #define LINUX_SYS_linux_ftruncate64 194 #define LINUX_SYS_linux_stat64 195 #define LINUX_SYS_linux_lstat64 196 #define LINUX_SYS_linux_fstat64 197 -#define LINUX_SYS_MAXSYSCALL 198 +#define LINUX_SYS_linux_lchown 198 +#define LINUX_SYS_linux_getuid 199 +#define LINUX_SYS_linux_getgid 200 +#define LINUX_SYS_geteuid 201 +#define LINUX_SYS_getegid 202 +#define LINUX_SYS_setreuid 203 +#define LINUX_SYS_setregid 204 +#define LINUX_SYS_linux_getgroups 205 +#define LINUX_SYS_linux_setgroups 206 +#define LINUX_SYS_linux_fchown 207 +#define LINUX_SYS_setresuid 208 +#define LINUX_SYS_getresuid 209 +#define LINUX_SYS_setresgid 210 +#define LINUX_SYS_getresgid 211 +#define LINUX_SYS_linux_chown 212 +#define LINUX_SYS_setuid 213 +#define LINUX_SYS_setgid 214 +#define LINUX_SYS_linux_setfsuid 215 +#define LINUX_SYS_linux_setfsgid 216 +#define LINUX_SYS_linux_pivot_root 217 +#define LINUX_SYS_linux_mincore 218 +#define LINUX_SYS_linux_madvise 219 +#define LINUX_SYS_linux_getdents64 220 +#define LINUX_SYS_linux_fcntl64 221 +#define LINUX_SYS_MAXSYSCALL 222 diff --git a/sys/i386/linux/linux_sysent.c b/sys/i386/linux/linux_sysent.c index 0c96903..de2af45 100644 --- a/sys/i386/linux/linux_sysent.c +++ b/sys/i386/linux/linux_sysent.c @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/i386/linux/syscalls.master,v 1.40 2001/04/01 06:37:40 alc Exp + * created from FreeBSD: src/sys/i386/linux/syscalls.master,v 1.43 2001/09/08 18:48:40 marcel Exp */ #include "opt_compat.h" @@ -17,9 +17,9 @@ /* The casts are bogus but will do for now. */ struct sysent linux_sysent[] = { - { 0, (sy_call_t *)linux_setup }, /* 0 = linux_setup */ - { AS(sys_exit_args), (sy_call_t *)sys_exit }, /* 1 = exit */ - { 0, (sy_call_t *)linux_fork }, /* 2 = linux_fork */ + { 0, (sy_call_t *)nosys }, /* 0 = setup */ + { SYF_MPSAFE | AS(sys_exit_args), (sy_call_t *)sys_exit }, /* 1 = exit */ + { SYF_MPSAFE | 0, (sy_call_t *)linux_fork }, /* 2 = linux_fork */ { AS(read_args), (sy_call_t *)read }, /* 3 = read */ { AS(write_args), (sy_call_t *)write }, /* 4 = write */ { AS(linux_open_args), (sy_call_t *)linux_open }, /* 5 = linux_open */ @@ -33,26 +33,26 @@ struct sysent linux_sysent[] = { { AS(linux_time_args), (sy_call_t *)linux_time }, /* 13 = linux_time */ { AS(linux_mknod_args), (sy_call_t *)linux_mknod }, /* 14 = linux_mknod */ { AS(linux_chmod_args), (sy_call_t *)linux_chmod }, /* 15 = linux_chmod */ - { AS(linux_lchown_args), (sy_call_t *)linux_lchown }, /* 16 = linux_lchown */ - { AS(linux_break_args), (sy_call_t *)linux_break }, /* 17 = linux_break */ + { AS(linux_lchown16_args), (sy_call_t *)linux_lchown16 }, /* 16 = linux_lchown16 */ + { 0, (sy_call_t *)nosys }, /* 17 = break */ { AS(linux_stat_args), (sy_call_t *)linux_stat }, /* 18 = linux_stat */ { AS(linux_lseek_args), (sy_call_t *)linux_lseek }, /* 19 = linux_lseek */ - { 0, (sy_call_t *)getpid }, /* 20 = getpid */ + { 0, (sy_call_t *)linux_getpid }, /* 20 = linux_getpid */ { AS(linux_mount_args), (sy_call_t *)linux_mount }, /* 21 = linux_mount */ - { AS(linux_umount_args), (sy_call_t *)linux_umount }, /* 22 = linux_umount */ - { AS(setuid_args), (sy_call_t *)setuid }, /* 23 = setuid */ - { 0, (sy_call_t *)getuid }, /* 24 = getuid */ + { AS(linux_oldumount_args), (sy_call_t *)linux_oldumount }, /* 22 = linux_oldumount */ + { AS(linux_setuid16_args), (sy_call_t *)linux_setuid16 }, /* 23 = linux_setuid16 */ + { 0, (sy_call_t *)linux_getuid16 }, /* 24 = linux_getuid16 */ { 0, (sy_call_t *)linux_stime }, /* 25 = linux_stime */ { 0, (sy_call_t *)linux_ptrace }, /* 26 = linux_ptrace */ { AS(linux_alarm_args), (sy_call_t *)linux_alarm }, /* 27 = linux_alarm */ { AS(linux_fstat_args), (sy_call_t *)linux_fstat }, /* 28 = linux_fstat */ { 0, (sy_call_t *)linux_pause }, /* 29 = linux_pause */ { AS(linux_utime_args), (sy_call_t *)linux_utime }, /* 30 = linux_utime */ - { 0, (sy_call_t *)linux_stty }, /* 31 = linux_stty */ - { 0, (sy_call_t *)linux_gtty }, /* 32 = linux_gtty */ + { 0, (sy_call_t *)nosys }, /* 31 = stty */ + { 0, (sy_call_t *)nosys }, /* 32 = gtty */ { AS(linux_access_args), (sy_call_t *)linux_access }, /* 33 = linux_access */ { AS(linux_nice_args), (sy_call_t *)linux_nice }, /* 34 = linux_nice */ - { 0, (sy_call_t *)linux_ftime }, /* 35 = linux_ftime */ + { 0, (sy_call_t *)nosys }, /* 35 = ftime */ { 0, (sy_call_t *)sync }, /* 36 = sync */ { AS(linux_kill_args), (sy_call_t *)linux_kill }, /* 37 = linux_kill */ { AS(linux_rename_args), (sy_call_t *)linux_rename }, /* 38 = linux_rename */ @@ -61,21 +61,21 @@ struct sysent linux_sysent[] = { { AS(dup_args), (sy_call_t *)dup }, /* 41 = dup */ { AS(linux_pipe_args), (sy_call_t *)linux_pipe }, /* 42 = linux_pipe */ { AS(linux_times_args), (sy_call_t *)linux_times }, /* 43 = linux_times */ - { 0, (sy_call_t *)linux_prof }, /* 44 = linux_prof */ + { 0, (sy_call_t *)nosys }, /* 44 = prof */ { AS(linux_brk_args), (sy_call_t *)linux_brk }, /* 45 = linux_brk */ - { AS(setgid_args), (sy_call_t *)setgid }, /* 46 = setgid */ - { 0, (sy_call_t *)getgid }, /* 47 = getgid */ + { AS(linux_setgid16_args), (sy_call_t *)linux_setgid16 }, /* 46 = linux_setgid16 */ + { 0, (sy_call_t *)linux_getgid16 }, /* 47 = linux_getgid16 */ { AS(linux_signal_args), (sy_call_t *)linux_signal }, /* 48 = linux_signal */ - { 0, (sy_call_t *)geteuid }, /* 49 = geteuid */ - { 0, (sy_call_t *)getegid }, /* 50 = getegid */ + { 0, (sy_call_t *)linux_geteuid16 }, /* 49 = linux_geteuid16 */ + { 0, (sy_call_t *)linux_getegid16 }, /* 50 = linux_getegid16 */ { AS(acct_args), (sy_call_t *)acct }, /* 51 = acct */ - { AS(linux_umount2_args), (sy_call_t *)linux_umount2 }, /* 52 = linux_umount2 */ - { 0, (sy_call_t *)linux_lock }, /* 53 = linux_lock */ + { AS(linux_umount_args), (sy_call_t *)linux_umount }, /* 52 = linux_umount */ + { 0, (sy_call_t *)nosys }, /* 53 = lock */ { AS(linux_ioctl_args), (sy_call_t *)linux_ioctl }, /* 54 = linux_ioctl */ { AS(linux_fcntl_args), (sy_call_t *)linux_fcntl }, /* 55 = linux_fcntl */ - { 0, (sy_call_t *)linux_mpx }, /* 56 = linux_mpx */ + { 0, (sy_call_t *)nosys }, /* 56 = mpx */ { AS(setpgid_args), (sy_call_t *)setpgid }, /* 57 = setpgid */ - { 0, (sy_call_t *)linux_ulimit }, /* 58 = linux_ulimit */ + { 0, (sy_call_t *)nosys }, /* 58 = ulimit */ { 0, (sy_call_t *)linux_olduname }, /* 59 = linux_olduname */ { AS(umask_args), (sy_call_t *)umask }, /* 60 = umask */ { AS(chroot_args), (sy_call_t *)chroot }, /* 61 = chroot */ @@ -85,21 +85,21 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)getpgrp }, /* 65 = getpgrp */ { 0, (sy_call_t *)setsid }, /* 66 = setsid */ { AS(linux_sigaction_args), (sy_call_t *)linux_sigaction }, /* 67 = linux_sigaction */ - { 0, (sy_call_t *)linux_siggetmask }, /* 68 = linux_siggetmask */ - { AS(linux_sigsetmask_args), (sy_call_t *)linux_sigsetmask }, /* 69 = linux_sigsetmask */ - { AS(setreuid_args), (sy_call_t *)setreuid }, /* 70 = setreuid */ - { AS(setregid_args), (sy_call_t *)setregid }, /* 71 = setregid */ + { 0, (sy_call_t *)linux_sgetmask }, /* 68 = linux_sgetmask */ + { AS(linux_ssetmask_args), (sy_call_t *)linux_ssetmask }, /* 69 = linux_ssetmask */ + { AS(linux_setreuid16_args), (sy_call_t *)linux_setreuid16 }, /* 70 = linux_setreuid16 */ + { AS(linux_setregid16_args), (sy_call_t *)linux_setregid16 }, /* 71 = linux_setregid16 */ { AS(linux_sigsuspend_args), (sy_call_t *)linux_sigsuspend }, /* 72 = linux_sigsuspend */ { AS(linux_sigpending_args), (sy_call_t *)linux_sigpending }, /* 73 = linux_sigpending */ - { AS(sethostname_args), (sy_call_t *)osethostname }, /* 74 = osethostname */ + { SYF_MPSAFE | AS(sethostname_args), (sy_call_t *)osethostname }, /* 74 = osethostname */ { AS(linux_setrlimit_args), (sy_call_t *)linux_setrlimit }, /* 75 = linux_setrlimit */ - { AS(linux_getrlimit_args), (sy_call_t *)linux_getrlimit }, /* 76 = linux_getrlimit */ + { AS(linux_old_getrlimit_args), (sy_call_t *)linux_old_getrlimit }, /* 76 = linux_old_getrlimit */ { AS(getrusage_args), (sy_call_t *)getrusage }, /* 77 = getrusage */ { AS(gettimeofday_args), (sy_call_t *)gettimeofday }, /* 78 = gettimeofday */ - { AS(settimeofday_args), (sy_call_t *)settimeofday }, /* 79 = settimeofday */ - { AS(linux_getgroups_args), (sy_call_t *)linux_getgroups }, /* 80 = linux_getgroups */ - { AS(linux_setgroups_args), (sy_call_t *)linux_setgroups }, /* 81 = linux_setgroups */ - { AS(linux_select_args), (sy_call_t *)linux_select }, /* 82 = linux_select */ + { SYF_MPSAFE | AS(settimeofday_args), (sy_call_t *)settimeofday }, /* 79 = settimeofday */ + { AS(linux_getgroups16_args), (sy_call_t *)linux_getgroups16 }, /* 80 = linux_getgroups16 */ + { AS(linux_setgroups16_args), (sy_call_t *)linux_setgroups16 }, /* 81 = linux_setgroups16 */ + { AS(linux_old_select_args), (sy_call_t *)linux_old_select }, /* 82 = linux_old_select */ { AS(linux_symlink_args), (sy_call_t *)linux_symlink }, /* 83 = linux_symlink */ { AS(ostat_args), (sy_call_t *)ostat }, /* 84 = ostat */ { AS(linux_readlink_args), (sy_call_t *)linux_readlink }, /* 85 = linux_readlink */ @@ -115,12 +115,12 @@ struct sysent linux_sysent[] = { { AS(fchown_args), (sy_call_t *)fchown }, /* 95 = fchown */ { AS(getpriority_args), (sy_call_t *)getpriority }, /* 96 = getpriority */ { AS(setpriority_args), (sy_call_t *)setpriority }, /* 97 = setpriority */ - { AS(profil_args), (sy_call_t *)profil }, /* 98 = profil */ + { 0, (sy_call_t *)nosys }, /* 98 = profil */ { AS(linux_statfs_args), (sy_call_t *)linux_statfs }, /* 99 = linux_statfs */ { AS(linux_fstatfs_args), (sy_call_t *)linux_fstatfs }, /* 100 = linux_fstatfs */ { AS(linux_ioperm_args), (sy_call_t *)linux_ioperm }, /* 101 = linux_ioperm */ { AS(linux_socketcall_args), (sy_call_t *)linux_socketcall }, /* 102 = linux_socketcall */ - { AS(linux_ksyslog_args), (sy_call_t *)linux_ksyslog }, /* 103 = linux_ksyslog */ + { AS(linux_syslog_args), (sy_call_t *)linux_syslog }, /* 103 = linux_syslog */ { AS(linux_setitimer_args), (sy_call_t *)linux_setitimer }, /* 104 = linux_setitimer */ { AS(linux_getitimer_args), (sy_call_t *)linux_getitimer }, /* 105 = linux_getitimer */ { AS(linux_newstat_args), (sy_call_t *)linux_newstat }, /* 106 = linux_newstat */ @@ -129,7 +129,7 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)linux_uname }, /* 109 = linux_uname */ { AS(linux_iopl_args), (sy_call_t *)linux_iopl }, /* 110 = linux_iopl */ { 0, (sy_call_t *)linux_vhangup }, /* 111 = linux_vhangup */ - { 0, (sy_call_t *)linux_idle }, /* 112 = linux_idle */ + { 0, (sy_call_t *)nosys }, /* 112 = idle */ { 0, (sy_call_t *)linux_vm86old }, /* 113 = linux_vm86old */ { AS(linux_wait4_args), (sy_call_t *)linux_wait4 }, /* 114 = linux_wait4 */ { 0, (sy_call_t *)linux_swapoff }, /* 115 = linux_swapoff */ @@ -138,7 +138,7 @@ struct sysent linux_sysent[] = { { AS(fsync_args), (sy_call_t *)fsync }, /* 118 = fsync */ { AS(linux_sigreturn_args), (sy_call_t *)linux_sigreturn }, /* 119 = linux_sigreturn */ { AS(linux_clone_args), (sy_call_t *)linux_clone }, /* 120 = linux_clone */ - { AS(setdomainname_args), (sy_call_t *)setdomainname }, /* 121 = setdomainname */ + { SYF_MPSAFE | AS(setdomainname_args), (sy_call_t *)setdomainname }, /* 121 = setdomainname */ { AS(linux_newuname_args), (sy_call_t *)linux_newuname }, /* 122 = linux_newuname */ { AS(linux_modify_ldt_args), (sy_call_t *)linux_modify_ldt }, /* 123 = linux_modify_ldt */ { 0, (sy_call_t *)linux_adjtimex }, /* 124 = linux_adjtimex */ @@ -154,19 +154,19 @@ struct sysent linux_sysent[] = { { 0, (sy_call_t *)linux_bdflush }, /* 134 = linux_bdflush */ { AS(linux_sysfs_args), (sy_call_t *)linux_sysfs }, /* 135 = linux_sysfs */ { AS(linux_personality_args), (sy_call_t *)linux_personality }, /* 136 = linux_personality */ - { 0, (sy_call_t *)linux_afs_syscall }, /* 137 = linux_afs_syscall */ - { AS(linux_setfsuid_args), (sy_call_t *)linux_setfsuid }, /* 138 = linux_setfsuid */ - { AS(linux_setfsgid_args), (sy_call_t *)linux_setfsgid }, /* 139 = linux_setfsgid */ + { 0, (sy_call_t *)nosys }, /* 137 = afs_syscall */ + { AS(linux_setfsuid16_args), (sy_call_t *)linux_setfsuid16 }, /* 138 = linux_setfsuid16 */ + { AS(linux_setfsgid16_args), (sy_call_t *)linux_setfsgid16 }, /* 139 = linux_setfsgid16 */ { AS(linux_llseek_args), (sy_call_t *)linux_llseek }, /* 140 = linux_llseek */ { AS(linux_getdents_args), (sy_call_t *)linux_getdents }, /* 141 = linux_getdents */ - { AS(linux_newselect_args), (sy_call_t *)linux_newselect }, /* 142 = linux_newselect */ + { AS(linux_select_args), (sy_call_t *)linux_select }, /* 142 = linux_select */ { AS(flock_args), (sy_call_t *)flock }, /* 143 = flock */ { AS(linux_msync_args), (sy_call_t *)linux_msync }, /* 144 = linux_msync */ { AS(readv_args), (sy_call_t *)readv }, /* 145 = readv */ { AS(writev_args), (sy_call_t *)writev }, /* 146 = writev */ { AS(linux_getsid_args), (sy_call_t *)linux_getsid }, /* 147 = linux_getsid */ { AS(linux_fdatasync_args), (sy_call_t *)linux_fdatasync }, /* 148 = linux_fdatasync */ - { 0, (sy_call_t *)linux_sysctl }, /* 149 = linux_sysctl */ + { AS(linux_sysctl_args), (sy_call_t *)linux_sysctl }, /* 149 = linux_sysctl */ { AS(mlock_args), (sy_call_t *)mlock }, /* 150 = mlock */ { AS(munlock_args), (sy_call_t *)munlock }, /* 151 = munlock */ { AS(mlockall_args), (sy_call_t *)mlockall }, /* 152 = mlockall */ @@ -179,16 +179,16 @@ struct sysent linux_sysent[] = { { AS(linux_sched_get_priority_max_args), (sy_call_t *)linux_sched_get_priority_max }, /* 159 = linux_sched_get_priority_max */ { AS(linux_sched_get_priority_min_args), (sy_call_t *)linux_sched_get_priority_min }, /* 160 = linux_sched_get_priority_min */ { AS(sched_rr_get_interval_args), (sy_call_t *)sched_rr_get_interval }, /* 161 = sched_rr_get_interval */ - { AS(nanosleep_args), (sy_call_t *)nanosleep }, /* 162 = nanosleep */ + { SYF_MPSAFE | AS(nanosleep_args), (sy_call_t *)nanosleep }, /* 162 = nanosleep */ { AS(linux_mremap_args), (sy_call_t *)linux_mremap }, /* 163 = linux_mremap */ - { AS(setresuid_args), (sy_call_t *)setresuid }, /* 164 = setresuid */ - { AS(linux_getresuid_args), (sy_call_t *)linux_getresuid }, /* 165 = linux_getresuid */ + { AS(linux_setresuid16_args), (sy_call_t *)linux_setresuid16 }, /* 164 = linux_setresuid16 */ + { AS(linux_getresuid16_args), (sy_call_t *)linux_getresuid16 }, /* 165 = linux_getresuid16 */ { 0, (sy_call_t *)linux_vm86 }, /* 166 = linux_vm86 */ { 0, (sy_call_t *)linux_query_module }, /* 167 = linux_query_module */ { AS(poll_args), (sy_call_t *)poll }, /* 168 = poll */ { 0, (sy_call_t *)linux_nfsservctl }, /* 169 = linux_nfsservctl */ - { AS(setresgid_args), (sy_call_t *)setresgid }, /* 170 = setresgid */ - { AS(linux_getresgid_args), (sy_call_t *)linux_getresgid }, /* 171 = linux_getresgid */ + { AS(linux_setresgid16_args), (sy_call_t *)linux_setresgid16 }, /* 170 = linux_setresgid16 */ + { AS(linux_getresgid16_args), (sy_call_t *)linux_getresgid16 }, /* 171 = linux_getresgid16 */ { 0, (sy_call_t *)linux_prctl }, /* 172 = linux_prctl */ { AS(linux_rt_sigreturn_args), (sy_call_t *)linux_rt_sigreturn }, /* 173 = linux_rt_sigreturn */ { AS(linux_rt_sigaction_args), (sy_call_t *)linux_rt_sigaction }, /* 174 = linux_rt_sigaction */ @@ -199,20 +199,44 @@ struct sysent linux_sysent[] = { { AS(linux_rt_sigsuspend_args), (sy_call_t *)linux_rt_sigsuspend }, /* 179 = linux_rt_sigsuspend */ { AS(linux_pread_args), (sy_call_t *)linux_pread }, /* 180 = linux_pread */ { AS(linux_pwrite_args), (sy_call_t *)linux_pwrite }, /* 181 = linux_pwrite */ - { AS(linux_chown_args), (sy_call_t *)linux_chown }, /* 182 = linux_chown */ + { AS(linux_chown16_args), (sy_call_t *)linux_chown16 }, /* 182 = linux_chown16 */ { AS(linux_getcwd_args), (sy_call_t *)linux_getcwd }, /* 183 = linux_getcwd */ { 0, (sy_call_t *)linux_capget }, /* 184 = linux_capget */ { 0, (sy_call_t *)linux_capset }, /* 185 = linux_capset */ { AS(linux_sigaltstack_args), (sy_call_t *)linux_sigaltstack }, /* 186 = linux_sigaltstack */ { 0, (sy_call_t *)linux_sendfile }, /* 187 = linux_sendfile */ - { 0, (sy_call_t *)linux_getpmsg }, /* 188 = linux_getpmsg */ - { 0, (sy_call_t *)linux_putpmsg }, /* 189 = linux_putpmsg */ - { 0, (sy_call_t *)linux_vfork }, /* 190 = linux_vfork */ - { 0, (sy_call_t *)linux_ugetrlimit }, /* 191 = linux_ugetrlimit */ - { 0, (sy_call_t *)linux_mmap2 }, /* 192 = linux_mmap2 */ - { 0, (sy_call_t *)linux_truncate64 }, /* 193 = linux_truncate64 */ - { 0, (sy_call_t *)linux_ftruncate64 }, /* 194 = linux_ftruncate64 */ - { 0, (sy_call_t *)linux_stat64 }, /* 195 = linux_stat64 */ - { 0, (sy_call_t *)linux_lstat64 }, /* 196 = linux_lstat64 */ - { 0, (sy_call_t *)linux_fstat64 }, /* 197 = linux_fstat64 */ + { 0, (sy_call_t *)nosys }, /* 188 = getpmsg */ + { 0, (sy_call_t *)nosys }, /* 189 = putpmsg */ + { SYF_MPSAFE | 0, (sy_call_t *)linux_vfork }, /* 190 = linux_vfork */ + { AS(linux_getrlimit_args), (sy_call_t *)linux_getrlimit }, /* 191 = linux_getrlimit */ + { AS(linux_mmap2_args), (sy_call_t *)linux_mmap2 }, /* 192 = linux_mmap2 */ + { AS(linux_truncate64_args), (sy_call_t *)linux_truncate64 }, /* 193 = linux_truncate64 */ + { AS(linux_ftruncate64_args), (sy_call_t *)linux_ftruncate64 }, /* 194 = linux_ftruncate64 */ + { AS(linux_stat64_args), (sy_call_t *)linux_stat64 }, /* 195 = linux_stat64 */ + { AS(linux_lstat64_args), (sy_call_t *)linux_lstat64 }, /* 196 = linux_lstat64 */ + { AS(linux_fstat64_args), (sy_call_t *)linux_fstat64 }, /* 197 = linux_fstat64 */ + { AS(linux_lchown_args), (sy_call_t *)linux_lchown }, /* 198 = linux_lchown */ + { 0, (sy_call_t *)linux_getuid }, /* 199 = linux_getuid */ + { 0, (sy_call_t *)linux_getgid }, /* 200 = linux_getgid */ + { 0, (sy_call_t *)geteuid }, /* 201 = geteuid */ + { 0, (sy_call_t *)getegid }, /* 202 = getegid */ + { AS(setreuid_args), (sy_call_t *)setreuid }, /* 203 = setreuid */ + { AS(setregid_args), (sy_call_t *)setregid }, /* 204 = setregid */ + { AS(linux_getgroups_args), (sy_call_t *)linux_getgroups }, /* 205 = linux_getgroups */ + { AS(linux_setgroups_args), (sy_call_t *)linux_setgroups }, /* 206 = linux_setgroups */ + { AS(linux_fchown_args), (sy_call_t *)linux_fchown }, /* 207 = linux_fchown */ + { AS(setresuid_args), (sy_call_t *)setresuid }, /* 208 = setresuid */ + { AS(getresuid_args), (sy_call_t *)getresuid }, /* 209 = getresuid */ + { AS(setresgid_args), (sy_call_t *)setresgid }, /* 210 = setresgid */ + { AS(getresgid_args), (sy_call_t *)getresgid }, /* 211 = getresgid */ + { AS(linux_chown_args), (sy_call_t *)linux_chown }, /* 212 = linux_chown */ + { AS(setuid_args), (sy_call_t *)setuid }, /* 213 = setuid */ + { AS(setgid_args), (sy_call_t *)setgid }, /* 214 = setgid */ + { AS(linux_setfsuid_args), (sy_call_t *)linux_setfsuid }, /* 215 = linux_setfsuid */ + { AS(linux_setfsgid_args), (sy_call_t *)linux_setfsgid }, /* 216 = linux_setfsgid */ + { AS(linux_pivot_root_args), (sy_call_t *)linux_pivot_root }, /* 217 = linux_pivot_root */ + { AS(linux_mincore_args), (sy_call_t *)linux_mincore }, /* 218 = linux_mincore */ + { 0, (sy_call_t *)linux_madvise }, /* 219 = linux_madvise */ + { AS(linux_getdents64_args), (sy_call_t *)linux_getdents64 }, /* 220 = linux_getdents64 */ + { AS(linux_fcntl64_args), (sy_call_t *)linux_fcntl64 }, /* 221 = linux_fcntl64 */ }; diff --git a/sys/i386/linux/linux_sysvec.c b/sys/i386/linux/linux_sysvec.c index 306b411..eaab863 100644 --- a/sys/i386/linux/linux_sysvec.c +++ b/sys/i386/linux/linux_sysvec.c @@ -212,7 +212,7 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { register struct proc *p = curproc; register struct trapframe *regs; - struct linux_rt_sigframe *fp, frame; + struct l_rt_sigframe *fp, frame; int oonstack; PROC_LOCK_ASSERT(p, MA_OWNED); @@ -220,7 +220,7 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) oonstack = sigonstack(regs->tf_esp); #ifdef DEBUG - if (ldebug(sigreturn)) + if (ldebug(rt_sendsig)) printf(ARGS(rt_sendsig, "%p, %d, %p, %lu"), catcher, sig, (void*)mask, code); #endif @@ -229,10 +229,10 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) */ if ((p->p_flag & P_ALTSTACK) && !oonstack && SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) { - fp = (struct linux_rt_sigframe *)(p->p_sigstk.ss_sp + - p->p_sigstk.ss_size - sizeof(struct linux_rt_sigframe)); + fp = (struct l_rt_sigframe *)(p->p_sigstk.ss_sp + + p->p_sigstk.ss_size - sizeof(struct l_rt_sigframe)); } else - fp = (struct linux_rt_sigframe *)regs->tf_esp - 1; + fp = (struct l_rt_sigframe *)regs->tf_esp - 1; PROC_UNLOCK(p); /* @@ -241,7 +241,7 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) * if access is denied. */ if ((grow_stack (p, (int)fp) == FALSE) || - !useracc((caddr_t)fp, sizeof (struct linux_rt_sigframe), + !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe), VM_PROT_WRITE)) { /* * Process has trashed its stack; give it an illegal @@ -253,7 +253,7 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) SIGDELSET(p->p_sigcatch, SIGILL); SIGDELSET(p->p_sigmask, SIGILL); #ifdef DEBUG - if (ldebug(sigreturn)) + if (ldebug(rt_sendsig)) printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"), fp, oonstack); #endif @@ -314,7 +314,7 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) frame.sf_sc.uc_mcontext.sc_trapno = code; /* XXX ???? */ #ifdef DEBUG - if (ldebug(sigreturn)) + if (ldebug(rt_sendsig)) printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"), frame.sf_sc.uc_stack.ss_flags, p->p_sigstk.ss_sp, p->p_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask); @@ -362,8 +362,8 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { register struct proc *p = curproc; register struct trapframe *regs; - struct linux_sigframe *fp, frame; - linux_sigset_t lmask; + struct l_sigframe *fp, frame; + l_sigset_t lmask; int oonstack, i; if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) { @@ -376,7 +376,7 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) oonstack = sigonstack(regs->tf_esp); #ifdef DEBUG - if (ldebug(sigreturn)) + if (ldebug(sendsig)) printf(ARGS(sendsig, "%p, %d, %p, %lu"), catcher, sig, (void*)mask, code); #endif @@ -384,13 +384,12 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) /* * Allocate space for the signal handler context. */ - PROC_LOCK(p); if ((p->p_flag & P_ALTSTACK) && !oonstack && SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) { - fp = (struct linux_sigframe *)(p->p_sigstk.ss_sp + - p->p_sigstk.ss_size - sizeof(struct linux_sigframe)); + fp = (struct l_sigframe *)(p->p_sigstk.ss_sp + + p->p_sigstk.ss_size - sizeof(struct l_sigframe)); } else - fp = (struct linux_sigframe *)regs->tf_esp - 1; + fp = (struct l_sigframe *)regs->tf_esp - 1; PROC_UNLOCK(p); /* @@ -399,7 +398,7 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) * if access is denied. */ if ((grow_stack (p, (int)fp) == FALSE) || - !useracc((caddr_t)fp, sizeof (struct linux_sigframe), + !useracc((caddr_t)fp, sizeof (struct l_sigframe), VM_PROT_WRITE)) { /* * Process has trashed its stack; give it an illegal @@ -411,7 +410,6 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) SIGDELSET(p->p_sigcatch, SIGILL); SIGDELSET(p->p_sigmask, SIGILL); psignal(p, SIGILL); - PROC_UNLOCK(p); return; } @@ -450,7 +448,7 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) frame.sf_sc.sc_err = regs->tf_err; frame.sf_sc.sc_trapno = code; /* XXX ???? */ - bzero(&frame.sf_fpstate, sizeof(struct linux_fpstate)); + bzero(&frame.sf_fpstate, sizeof(struct l_fpstate)); for (i = 0; i < (LINUX_NSIG_WORDS-1); i++) frame.sf_extramask[i] = lmask.__bits[i+1]; @@ -476,6 +474,7 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) regs->tf_es = _udatasel; regs->tf_fs = _udatasel; regs->tf_ss = _udatasel; + PROC_LOCK(p); } /* @@ -493,9 +492,9 @@ linux_sigreturn(p, args) struct proc *p; struct linux_sigreturn_args *args; { - struct linux_sigframe frame; + struct l_sigframe frame; register struct trapframe *regs; - linux_sigset_t lmask; + l_sigset_t lmask; int eflags, i; regs = p->p_frame; @@ -589,9 +588,9 @@ linux_rt_sigreturn(p, args) struct linux_rt_sigreturn_args *args; { struct sigaltstack_args sasargs; - struct linux_ucontext uc; - struct linux_sigcontext *context; - linux_stack_t *lss; + struct l_ucontext uc; + struct l_sigcontext *context; + l_stack_t *lss; stack_t *ss; register struct trapframe *regs; int eflags; diff --git a/sys/modules/linux/Makefile b/sys/modules/linux/Makefile index 3360a40..226d22d 100644 --- a/sys/modules/linux/Makefile +++ b/sys/modules/linux/Makefile @@ -5,14 +5,14 @@ MAINTAINER= marcel@FreeBSD.org .PATH: ${.CURDIR}/../../compat/linux ${.CURDIR}/../../${MACHINE_ARCH}/linux KMOD= linux -SRCS= linux_file.c linux_getcwd.c linux_ioctl.c linux_ipc.c linux_machdep.c \ - linux_misc.c linux_signal.c linux_socket.c linux_stats.c linux_mib.c \ - linux_dummy.c linux_sysent.c linux_sysvec.c linux_util.c \ - opt_compat.h opt_linux.h opt_vmpage.h vnode_if.h +SRCS= linux_dummy.c linux_file.c linux_getcwd.c linux_ioctl.c linux_ipc.c \ + linux_machdep.c linux_mib.c linux_misc.c linux_signal.c linux_socket.c \ + linux_stats.c linux_sysctl.c linux_sysent.c linux_sysvec.c \ + linux_util.c opt_compat.h opt_linux.h opt_vmpage.h vnode_if.h OBJS= linux_locore.o .if ${MACHINE_ARCH} == "i386" -SRCS+= imgact_linux.c +SRCS+= linux_uid16.c imgact_linux.c .endif CLEANFILES= linux_assym.h linux_genassym.o |
