Home | History | Annotate | Line # | Download | only in common
linux_misc.c revision 1.131
      1  1.131  jdolecek /*	$NetBSD: linux_misc.c,v 1.131 2004/09/19 16:50:11 jdolecek Exp $	*/
      2   1.47       erh 
      3   1.47       erh /*-
      4   1.56   thorpej  * Copyright (c) 1995, 1998, 1999 The NetBSD Foundation, Inc.
      5   1.47       erh  * All rights reserved.
      6   1.47       erh  *
      7   1.47       erh  * This code is derived from software contributed to The NetBSD Foundation
      8   1.56   thorpej  * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
      9   1.56   thorpej  * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center.
     10   1.47       erh  *
     11   1.47       erh  * Redistribution and use in source and binary forms, with or without
     12   1.47       erh  * modification, are permitted provided that the following conditions
     13   1.47       erh  * are met:
     14   1.47       erh  * 1. Redistributions of source code must retain the above copyright
     15   1.47       erh  *    notice, this list of conditions and the following disclaimer.
     16   1.47       erh  * 2. Redistributions in binary form must reproduce the above copyright
     17   1.47       erh  *    notice, this list of conditions and the following disclaimer in the
     18   1.47       erh  *    documentation and/or other materials provided with the distribution.
     19   1.47       erh  * 3. All advertising materials mentioning features or use of this software
     20   1.47       erh  *    must display the following acknowledgement:
     21   1.47       erh  *	This product includes software developed by the NetBSD
     22   1.47       erh  *	Foundation, Inc. and its contributors.
     23   1.47       erh  * 4. Neither the name of The NetBSD Foundation nor the names of its
     24   1.47       erh  *    contributors may be used to endorse or promote products derived
     25   1.47       erh  *    from this software without specific prior written permission.
     26   1.47       erh  *
     27   1.47       erh  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     28   1.47       erh  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     29   1.47       erh  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     30   1.47       erh  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     31   1.47       erh  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     32   1.47       erh  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     33   1.47       erh  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     34   1.47       erh  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     35   1.47       erh  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     36   1.47       erh  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     37   1.47       erh  * POSSIBILITY OF SUCH DAMAGE.
     38    1.1      fvdl  */
     39    1.1      fvdl 
     40    1.1      fvdl /*
     41    1.1      fvdl  * Linux compatibility module. Try to deal with various Linux system calls.
     42    1.1      fvdl  */
     43    1.1      fvdl 
     44   1.47       erh /*
     45   1.47       erh  * These functions have been moved to multiarch to allow
     46   1.47       erh  * selection of which machines include them to be
     47   1.47       erh  * determined by the individual files.linux_<arch> files.
     48   1.47       erh  *
     49   1.47       erh  * Function in multiarch:
     50   1.47       erh  *	linux_sys_break			: linux_break.c
     51   1.47       erh  *	linux_sys_alarm			: linux_misc_notalpha.c
     52   1.57   thorpej  *	linux_sys_getresgid		: linux_misc_notalpha.c
     53   1.47       erh  *	linux_sys_nice			: linux_misc_notalpha.c
     54   1.47       erh  *	linux_sys_readdir		: linux_misc_notalpha.c
     55   1.57   thorpej  *	linux_sys_setresgid		: linux_misc_notalpha.c
     56   1.47       erh  *	linux_sys_time			: linux_misc_notalpha.c
     57   1.47       erh  *	linux_sys_utime			: linux_misc_notalpha.c
     58   1.47       erh  *	linux_sys_waitpid		: linux_misc_notalpha.c
     59   1.47       erh  *	linux_sys_old_mmap		: linux_oldmmap.c
     60   1.47       erh  *	linux_sys_oldolduname		: linux_oldolduname.c
     61   1.47       erh  *	linux_sys_oldselect		: linux_oldselect.c
     62   1.47       erh  *	linux_sys_olduname		: linux_olduname.c
     63   1.47       erh  *	linux_sys_pipe			: linux_pipe.c
     64   1.47       erh  */
     65   1.95     lukem 
     66   1.95     lukem #include <sys/cdefs.h>
     67  1.131  jdolecek __KERNEL_RCSID(0, "$NetBSD: linux_misc.c,v 1.131 2004/09/19 16:50:11 jdolecek Exp $");
     68   1.47       erh 
     69    1.1      fvdl #include <sys/param.h>
     70    1.1      fvdl #include <sys/systm.h>
     71    1.1      fvdl #include <sys/namei.h>
     72    1.1      fvdl #include <sys/proc.h>
     73   1.29   mycroft #include <sys/dirent.h>
     74    1.1      fvdl #include <sys/file.h>
     75    1.1      fvdl #include <sys/stat.h>
     76    1.1      fvdl #include <sys/filedesc.h>
     77    1.1      fvdl #include <sys/ioctl.h>
     78    1.1      fvdl #include <sys/kernel.h>
     79    1.1      fvdl #include <sys/malloc.h>
     80    1.1      fvdl #include <sys/mbuf.h>
     81    1.1      fvdl #include <sys/mman.h>
     82    1.1      fvdl #include <sys/mount.h>
     83   1.67       erh #include <sys/reboot.h>
     84    1.1      fvdl #include <sys/resource.h>
     85    1.1      fvdl #include <sys/resourcevar.h>
     86    1.1      fvdl #include <sys/signal.h>
     87    1.1      fvdl #include <sys/signalvar.h>
     88    1.1      fvdl #include <sys/socket.h>
     89    1.1      fvdl #include <sys/time.h>
     90    1.1      fvdl #include <sys/times.h>
     91    1.1      fvdl #include <sys/vnode.h>
     92    1.1      fvdl #include <sys/uio.h>
     93    1.1      fvdl #include <sys/wait.h>
     94    1.1      fvdl #include <sys/utsname.h>
     95    1.1      fvdl #include <sys/unistd.h>
     96   1.75  jdolecek #include <sys/swap.h>		/* for SWAP_ON */
     97   1.75  jdolecek #include <sys/sysctl.h>		/* for KERN_DOMAINNAME */
     98    1.1      fvdl 
     99   1.73  jdolecek #include <sys/ptrace.h>
    100   1.73  jdolecek #include <machine/ptrace.h>
    101   1.73  jdolecek 
    102  1.116   thorpej #include <sys/sa.h>
    103    1.1      fvdl #include <sys/syscallargs.h>
    104    1.1      fvdl 
    105   1.49  christos #include <compat/linux/common/linux_types.h>
    106   1.49  christos #include <compat/linux/common/linux_signal.h>
    107   1.49  christos 
    108    1.1      fvdl #include <compat/linux/linux_syscallargs.h>
    109   1.49  christos 
    110   1.49  christos #include <compat/linux/common/linux_fcntl.h>
    111   1.49  christos #include <compat/linux/common/linux_mmap.h>
    112   1.49  christos #include <compat/linux/common/linux_dirent.h>
    113   1.49  christos #include <compat/linux/common/linux_util.h>
    114   1.49  christos #include <compat/linux/common/linux_misc.h>
    115   1.62      tron #include <compat/linux/common/linux_ptrace.h>
    116   1.67       erh #include <compat/linux/common/linux_reboot.h>
    117   1.84      manu #include <compat/linux/common/linux_emuldata.h>
    118   1.49  christos 
    119   1.73  jdolecek const int linux_ptrace_request_map[] = {
    120   1.62      tron 	LINUX_PTRACE_TRACEME,	PT_TRACE_ME,
    121   1.62      tron 	LINUX_PTRACE_PEEKTEXT,	PT_READ_I,
    122   1.62      tron 	LINUX_PTRACE_PEEKDATA,	PT_READ_D,
    123   1.62      tron 	LINUX_PTRACE_POKETEXT,	PT_WRITE_I,
    124   1.62      tron 	LINUX_PTRACE_POKEDATA,	PT_WRITE_D,
    125   1.62      tron 	LINUX_PTRACE_CONT,	PT_CONTINUE,
    126   1.62      tron 	LINUX_PTRACE_KILL,	PT_KILL,
    127   1.62      tron 	LINUX_PTRACE_ATTACH,	PT_ATTACH,
    128   1.62      tron 	LINUX_PTRACE_DETACH,	PT_DETACH,
    129   1.73  jdolecek #ifdef PT_STEP
    130   1.73  jdolecek 	LINUX_PTRACE_SINGLESTEP,	PT_STEP,
    131   1.73  jdolecek #endif
    132   1.62      tron 	-1
    133   1.62      tron };
    134    1.1      fvdl 
    135  1.111    simonb static const struct mnttypes {
    136  1.101  christos 	char *bsd;
    137  1.101  christos 	int linux;
    138  1.101  christos } fstypes[] = {
    139  1.101  christos 	{ MOUNT_FFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    140  1.101  christos 	{ MOUNT_NFS,		LINUX_NFS_SUPER_MAGIC 		},
    141  1.101  christos 	{ MOUNT_MFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    142  1.101  christos 	{ MOUNT_MSDOS,		LINUX_MSDOS_SUPER_MAGIC		},
    143  1.101  christos 	{ MOUNT_LFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    144  1.101  christos 	{ MOUNT_FDESC,		LINUX_DEFAULT_SUPER_MAGIC	},
    145  1.101  christos 	{ MOUNT_PORTAL,		LINUX_DEFAULT_SUPER_MAGIC	},
    146  1.101  christos 	{ MOUNT_NULL,		LINUX_DEFAULT_SUPER_MAGIC	},
    147  1.101  christos 	{ MOUNT_OVERLAY,	LINUX_DEFAULT_SUPER_MAGIC	},
    148  1.101  christos 	{ MOUNT_UMAP,		LINUX_DEFAULT_SUPER_MAGIC	},
    149  1.101  christos 	{ MOUNT_KERNFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    150  1.101  christos 	{ MOUNT_PROCFS,		LINUX_PROC_SUPER_MAGIC		},
    151  1.101  christos 	{ MOUNT_AFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    152  1.101  christos 	{ MOUNT_CD9660,		LINUX_ISOFS_SUPER_MAGIC		},
    153  1.101  christos 	{ MOUNT_UNION,		LINUX_DEFAULT_SUPER_MAGIC	},
    154  1.101  christos 	{ MOUNT_ADOSFS,		LINUX_ADFS_SUPER_MAGIC		},
    155  1.101  christos 	{ MOUNT_EXT2FS,		LINUX_EXT2_SUPER_MAGIC		},
    156  1.101  christos 	{ MOUNT_CFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    157  1.101  christos 	{ MOUNT_CODA,		LINUX_CODA_SUPER_MAGIC		},
    158  1.101  christos 	{ MOUNT_FILECORE,	LINUX_DEFAULT_SUPER_MAGIC	},
    159  1.101  christos 	{ MOUNT_NTFS,		LINUX_DEFAULT_SUPER_MAGIC	},
    160  1.101  christos 	{ MOUNT_SMBFS,		LINUX_SMB_SUPER_MAGIC		}
    161  1.101  christos };
    162  1.101  christos #define FSTYPESSIZE (sizeof(fstypes) / sizeof(fstypes[0]))
    163  1.101  christos 
    164  1.104  christos #ifdef DEBUG_LINUX
    165  1.104  christos #define DPRINTF(a)	uprintf a
    166  1.104  christos #else
    167  1.104  christos #define DPRINTF(a)
    168  1.104  christos #endif
    169  1.104  christos 
    170   1.47       erh /* Local linux_misc.c functions: */
    171  1.123  christos static void bsd_to_linux_statfs __P((const struct statvfs *,
    172  1.123  christos     struct linux_statfs *));
    173   1.97  christos static int linux_to_bsd_limit __P((int));
    174  1.118  christos static void linux_to_bsd_mmap_args __P((struct sys_mmap_args *,
    175  1.118  christos     const struct linux_sys_mmap_args *));
    176  1.128  jdolecek static int linux_mmap __P((struct lwp *, struct linux_sys_mmap_args *,
    177  1.128  jdolecek     register_t *, off_t));
    178  1.128  jdolecek 
    179   1.26  christos 
    180    1.1      fvdl /*
    181    1.1      fvdl  * The information on a terminated (or stopped) process needs
    182    1.1      fvdl  * to be converted in order for Linux binaries to get a valid signal
    183    1.1      fvdl  * number out of it.
    184    1.1      fvdl  */
    185   1.47       erh void
    186   1.52  christos bsd_to_linux_wstat(st)
    187   1.52  christos 	int *st;
    188    1.1      fvdl {
    189   1.21   mycroft 
    190   1.52  christos 	int sig;
    191   1.52  christos 
    192   1.52  christos 	if (WIFSIGNALED(*st)) {
    193   1.52  christos 		sig = WTERMSIG(*st);
    194   1.52  christos 		if (sig >= 0 && sig < NSIG)
    195  1.105  christos 			*st= (*st& ~0177) | native_to_linux_signo[sig];
    196   1.52  christos 	} else if (WIFSTOPPED(*st)) {
    197   1.52  christos 		sig = WSTOPSIG(*st);
    198   1.52  christos 		if (sig >= 0 && sig < NSIG)
    199  1.105  christos 			*st = (*st & ~0xff00) |
    200  1.105  christos 			    (native_to_linux_signo[sig] << 8);
    201   1.52  christos 	}
    202    1.1      fvdl }
    203    1.1      fvdl 
    204    1.1      fvdl /*
    205    1.1      fvdl  * This is very much the same as waitpid()
    206    1.1      fvdl  */
    207    1.1      fvdl int
    208  1.116   thorpej linux_sys_wait4(l, v, retval)
    209  1.116   thorpej 	struct lwp *l;
    210   1.20   thorpej 	void *v;
    211   1.20   thorpej 	register_t *retval;
    212   1.20   thorpej {
    213   1.21   mycroft 	struct linux_sys_wait4_args /* {
    214    1.1      fvdl 		syscallarg(int) pid;
    215    1.1      fvdl 		syscallarg(int *) status;
    216    1.1      fvdl 		syscallarg(int) options;
    217    1.1      fvdl 		syscallarg(struct rusage *) rusage;
    218   1.20   thorpej 	} */ *uap = v;
    219  1.116   thorpej 	struct proc *p = l->l_proc;
    220   1.21   mycroft 	struct sys_wait4_args w4a;
    221   1.55   thorpej 	int error, *status, tstat, options, linux_options;
    222    1.1      fvdl 	caddr_t sg;
    223    1.1      fvdl 
    224   1.16      fvdl 	if (SCARG(uap, status) != NULL) {
    225  1.102  christos 		sg = stackgap_init(p, 0);
    226  1.102  christos 		status = (int *) stackgap_alloc(p, &sg, sizeof *status);
    227   1.16      fvdl 	} else
    228   1.16      fvdl 		status = NULL;
    229    1.1      fvdl 
    230   1.55   thorpej 	linux_options = SCARG(uap, options);
    231   1.55   thorpej 	options = 0;
    232   1.55   thorpej 	if (linux_options &
    233   1.93   thorpej 	    ~(LINUX_WAIT4_WNOHANG|LINUX_WAIT4_WUNTRACED|LINUX_WAIT4_WALL|
    234   1.93   thorpej 	      LINUX_WAIT4_WCLONE))
    235   1.55   thorpej 		return (EINVAL);
    236   1.55   thorpej 
    237   1.55   thorpej 	if (linux_options & LINUX_WAIT4_WNOHANG)
    238   1.55   thorpej 		options |= WNOHANG;
    239   1.55   thorpej 	if (linux_options & LINUX_WAIT4_WUNTRACED)
    240   1.55   thorpej 		options |= WUNTRACED;
    241   1.93   thorpej 	if (linux_options & LINUX_WAIT4_WALL)
    242   1.93   thorpej 		options |= WALLSIG;
    243   1.55   thorpej 	if (linux_options & LINUX_WAIT4_WCLONE)
    244   1.55   thorpej 		options |= WALTSIG;
    245   1.55   thorpej 
    246    1.1      fvdl 	SCARG(&w4a, pid) = SCARG(uap, pid);
    247    1.1      fvdl 	SCARG(&w4a, status) = status;
    248   1.55   thorpej 	SCARG(&w4a, options) = options;
    249    1.1      fvdl 	SCARG(&w4a, rusage) = SCARG(uap, rusage);
    250    1.1      fvdl 
    251  1.116   thorpej 	if ((error = sys_wait4(l, &w4a, retval)))
    252    1.1      fvdl 		return error;
    253    1.1      fvdl 
    254   1.80  jdolecek 	sigdelset(&p->p_sigctx.ps_siglist, SIGCHLD);
    255   1.18      fvdl 
    256   1.16      fvdl 	if (status != NULL) {
    257   1.16      fvdl 		if ((error = copyin(status, &tstat, sizeof tstat)))
    258   1.16      fvdl 			return error;
    259   1.16      fvdl 
    260   1.16      fvdl 		bsd_to_linux_wstat(&tstat);
    261   1.16      fvdl 		return copyout(&tstat, SCARG(uap, status), sizeof tstat);
    262   1.16      fvdl 	}
    263    1.1      fvdl 
    264   1.16      fvdl 	return 0;
    265    1.1      fvdl }
    266    1.1      fvdl 
    267    1.1      fvdl /*
    268    1.1      fvdl  * Linux brk(2). The check if the new address is >= the old one is
    269    1.1      fvdl  * done in the kernel in Linux. NetBSD does it in the library.
    270    1.1      fvdl  */
    271    1.1      fvdl int
    272  1.116   thorpej linux_sys_brk(l, v, retval)
    273  1.116   thorpej 	struct lwp *l;
    274   1.20   thorpej 	void *v;
    275   1.20   thorpej 	register_t *retval;
    276   1.20   thorpej {
    277   1.21   mycroft 	struct linux_sys_brk_args /* {
    278    1.1      fvdl 		syscallarg(char *) nsize;
    279   1.20   thorpej 	} */ *uap = v;
    280  1.116   thorpej 	struct proc *p = l->l_proc;
    281    1.1      fvdl 	char *nbrk = SCARG(uap, nsize);
    282   1.21   mycroft 	struct sys_obreak_args oba;
    283    1.1      fvdl 	struct vmspace *vm = p->p_vmspace;
    284   1.85      manu 	struct linux_emuldata *ed = (struct linux_emuldata*)p->p_emuldata;
    285   1.84      manu 
    286    1.1      fvdl 	SCARG(&oba, nsize) = nbrk;
    287    1.1      fvdl 
    288  1.116   thorpej 	if ((caddr_t) nbrk > vm->vm_daddr && sys_obreak(l, &oba, retval) == 0)
    289  1.127  jdolecek 		ed->s->p_break = (char*)nbrk;
    290   1.85      manu 	else
    291  1.127  jdolecek 		nbrk = ed->s->p_break;
    292   1.85      manu 
    293   1.85      manu 	retval[0] = (register_t)nbrk;
    294    1.1      fvdl 
    295    1.1      fvdl 	return 0;
    296    1.1      fvdl }
    297    1.1      fvdl 
    298    1.1      fvdl /*
    299  1.131  jdolecek  * Convert NetBSD statvfs structure to Linux statfs structure.
    300  1.131  jdolecek  * Linux doesn't have f_flag, and we can't set f_frsize due
    301  1.131  jdolecek  * to glibc statvfs() bug (see below).
    302    1.2      fvdl  */
    303    1.2      fvdl static void
    304    1.2      fvdl bsd_to_linux_statfs(bsp, lsp)
    305  1.123  christos 	const struct statvfs *bsp;
    306    1.2      fvdl 	struct linux_statfs *lsp;
    307    1.2      fvdl {
    308  1.101  christos 	int i;
    309  1.101  christos 
    310  1.101  christos 	for (i = 0; i < FSTYPESSIZE; i++)
    311  1.101  christos 		if (strcmp(bsp->f_fstypename, fstypes[i].bsd) == 0)
    312  1.101  christos 			break;
    313  1.101  christos 
    314  1.101  christos 	if (i == FSTYPESSIZE) {
    315  1.104  christos 		DPRINTF(("unhandled fstype in linux emulation: %s\n",
    316  1.104  christos 		    bsp->f_fstypename));
    317  1.101  christos 		lsp->l_ftype = LINUX_DEFAULT_SUPER_MAGIC;
    318  1.101  christos 	} else {
    319  1.101  christos 		lsp->l_ftype = fstypes[i].linux;
    320  1.101  christos 	}
    321   1.21   mycroft 
    322  1.131  jdolecek 	/*
    323  1.131  jdolecek 	 * The sizes are expressed in number of blocks. The block
    324  1.131  jdolecek 	 * size used for the size is f_frsize for POSIX-compliant
    325  1.131  jdolecek 	 * statvfs. Linux statfs uses f_bsize as the block size
    326  1.131  jdolecek 	 * (f_frsize used to not be available in Linux struct statfs).
    327  1.131  jdolecek 	 * However, glibc 2.3.3 statvfs() wrapper fails to adjust the block
    328  1.131  jdolecek 	 * counts for different f_frsize if f_frsize is provided by the kernel.
    329  1.131  jdolecek 	 * POSIX conforming apps thus get wrong size if f_frsize
    330  1.131  jdolecek 	 * is different to f_bsize. Thus, we just pretend we don't
    331  1.131  jdolecek 	 * support f_frsize.
    332  1.131  jdolecek 	 */
    333  1.131  jdolecek 
    334  1.129  jdolecek 	lsp->l_fbsize = bsp->f_frsize;
    335  1.131  jdolecek 	lsp->l_ffrsize = 0;			/* compat */
    336    1.2      fvdl 	lsp->l_fblocks = bsp->f_blocks;
    337    1.2      fvdl 	lsp->l_fbfree = bsp->f_bfree;
    338    1.2      fvdl 	lsp->l_fbavail = bsp->f_bavail;
    339    1.2      fvdl 	lsp->l_ffiles = bsp->f_files;
    340    1.2      fvdl 	lsp->l_fffree = bsp->f_ffree;
    341  1.101  christos 	/* Linux sets the fsid to 0..., we don't */
    342  1.123  christos 	lsp->l_ffsid.val[0] = bsp->f_fsidx.__fsid_val[0];
    343  1.123  christos 	lsp->l_ffsid.val[1] = bsp->f_fsidx.__fsid_val[1];
    344  1.129  jdolecek 	lsp->l_fnamelen = bsp->f_namemax;
    345  1.101  christos 	(void)memset(lsp->l_fspare, 0, sizeof(lsp->l_fspare));
    346    1.2      fvdl }
    347    1.2      fvdl 
    348    1.2      fvdl /*
    349    1.2      fvdl  * Implement the fs stat functions. Straightforward.
    350    1.1      fvdl  */
    351    1.1      fvdl int
    352  1.116   thorpej linux_sys_statfs(l, v, retval)
    353  1.116   thorpej 	struct lwp *l;
    354   1.20   thorpej 	void *v;
    355   1.20   thorpej 	register_t *retval;
    356   1.20   thorpej {
    357   1.21   mycroft 	struct linux_sys_statfs_args /* {
    358   1.53  christos 		syscallarg(const char *) path;
    359    1.1      fvdl 		syscallarg(struct linux_statfs *) sp;
    360   1.20   thorpej 	} */ *uap = v;
    361  1.116   thorpej 	struct proc *p = l->l_proc;
    362  1.123  christos 	struct statvfs btmp, *bsp;
    363    1.2      fvdl 	struct linux_statfs ltmp;
    364  1.124  christos 	struct sys_statvfs1_args bsa;
    365    1.2      fvdl 	caddr_t sg;
    366    1.2      fvdl 	int error;
    367    1.2      fvdl 
    368  1.102  christos 	sg = stackgap_init(p, 0);
    369  1.123  christos 	bsp = (struct statvfs *) stackgap_alloc(p, &sg, sizeof (struct statvfs));
    370    1.2      fvdl 
    371  1.121      fvdl 	CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
    372    1.2      fvdl 
    373    1.2      fvdl 	SCARG(&bsa, path) = SCARG(uap, path);
    374    1.2      fvdl 	SCARG(&bsa, buf) = bsp;
    375  1.125  christos 	SCARG(&bsa, flags) = ST_WAIT;
    376    1.2      fvdl 
    377  1.125  christos 	if ((error = sys_statvfs1(l, &bsa, retval)))
    378    1.2      fvdl 		return error;
    379    1.2      fvdl 
    380    1.2      fvdl 	if ((error = copyin((caddr_t) bsp, (caddr_t) &btmp, sizeof btmp)))
    381    1.2      fvdl 		return error;
    382    1.2      fvdl 
    383    1.2      fvdl 	bsd_to_linux_statfs(&btmp, &ltmp);
    384    1.2      fvdl 
    385    1.2      fvdl 	return copyout((caddr_t) &ltmp, (caddr_t) SCARG(uap, sp), sizeof ltmp);
    386    1.1      fvdl }
    387    1.1      fvdl 
    388    1.1      fvdl int
    389  1.116   thorpej linux_sys_fstatfs(l, v, retval)
    390  1.116   thorpej 	struct lwp *l;
    391   1.20   thorpej 	void *v;
    392   1.20   thorpej 	register_t *retval;
    393   1.20   thorpej {
    394   1.21   mycroft 	struct linux_sys_fstatfs_args /* {
    395    1.2      fvdl 		syscallarg(int) fd;
    396    1.1      fvdl 		syscallarg(struct linux_statfs *) sp;
    397   1.20   thorpej 	} */ *uap = v;
    398  1.116   thorpej 	struct proc *p = l->l_proc;
    399  1.123  christos 	struct statvfs btmp, *bsp;
    400    1.2      fvdl 	struct linux_statfs ltmp;
    401  1.125  christos 	struct sys_fstatvfs1_args bsa;
    402    1.2      fvdl 	caddr_t sg;
    403    1.2      fvdl 	int error;
    404    1.2      fvdl 
    405  1.102  christos 	sg = stackgap_init(p, 0);
    406  1.123  christos 	bsp = (struct statvfs *) stackgap_alloc(p, &sg, sizeof (struct statvfs));
    407    1.2      fvdl 
    408    1.2      fvdl 	SCARG(&bsa, fd) = SCARG(uap, fd);
    409    1.2      fvdl 	SCARG(&bsa, buf) = bsp;
    410  1.125  christos 	SCARG(&bsa, flags) = ST_WAIT;
    411    1.2      fvdl 
    412  1.125  christos 	if ((error = sys_fstatvfs1(l, &bsa, retval)))
    413    1.2      fvdl 		return error;
    414    1.2      fvdl 
    415    1.2      fvdl 	if ((error = copyin((caddr_t) bsp, (caddr_t) &btmp, sizeof btmp)))
    416    1.2      fvdl 		return error;
    417    1.2      fvdl 
    418    1.2      fvdl 	bsd_to_linux_statfs(&btmp, &ltmp);
    419    1.2      fvdl 
    420    1.2      fvdl 	return copyout((caddr_t) &ltmp, (caddr_t) SCARG(uap, sp), sizeof ltmp);
    421    1.1      fvdl }
    422   1.82      fvdl 
    423    1.1      fvdl /*
    424    1.1      fvdl  * uname(). Just copy the info from the various strings stored in the
    425    1.1      fvdl  * kernel, and put it in the Linux utsname structure. That structure
    426    1.1      fvdl  * is almost the same as the NetBSD one, only it has fields 65 characters
    427    1.1      fvdl  * long, and an extra domainname field.
    428    1.1      fvdl  */
    429    1.1      fvdl int
    430  1.116   thorpej linux_sys_uname(l, v, retval)
    431  1.116   thorpej 	struct lwp *l;
    432   1.20   thorpej 	void *v;
    433   1.20   thorpej 	register_t *retval;
    434   1.20   thorpej {
    435   1.21   mycroft 	struct linux_sys_uname_args /* {
    436    1.1      fvdl 		syscallarg(struct linux_utsname *) up;
    437   1.20   thorpej 	} */ *uap = v;
    438   1.15   mycroft 	struct linux_utsname luts;
    439    1.1      fvdl 
    440   1.82      fvdl 	strncpy(luts.l_sysname, linux_sysname, sizeof(luts.l_sysname));
    441   1.15   mycroft 	strncpy(luts.l_nodename, hostname, sizeof(luts.l_nodename));
    442   1.82      fvdl 	strncpy(luts.l_release, linux_release, sizeof(luts.l_release));
    443   1.82      fvdl 	strncpy(luts.l_version, linux_version, sizeof(luts.l_version));
    444   1.15   mycroft 	strncpy(luts.l_machine, machine, sizeof(luts.l_machine));
    445   1.15   mycroft 	strncpy(luts.l_domainname, domainname, sizeof(luts.l_domainname));
    446   1.15   mycroft 
    447   1.15   mycroft 	return copyout(&luts, SCARG(uap, up), sizeof(luts));
    448   1.15   mycroft }
    449   1.15   mycroft 
    450   1.47       erh /* Used directly on: alpha, mips, ppc, sparc, sparc64 */
    451   1.47       erh /* Used indirectly on: arm, i386, m68k */
    452    1.1      fvdl 
    453    1.1      fvdl /*
    454   1.47       erh  * New type Linux mmap call.
    455   1.47       erh  * Only called directly on machines with >= 6 free regs.
    456    1.1      fvdl  */
    457    1.1      fvdl int
    458  1.116   thorpej linux_sys_mmap(l, v, retval)
    459  1.116   thorpej 	struct lwp *l;
    460   1.20   thorpej 	void *v;
    461   1.20   thorpej 	register_t *retval;
    462   1.20   thorpej {
    463   1.21   mycroft 	struct linux_sys_mmap_args /* {
    464   1.47       erh 		syscallarg(unsigned long) addr;
    465   1.47       erh 		syscallarg(size_t) len;
    466   1.47       erh 		syscallarg(int) prot;
    467   1.47       erh 		syscallarg(int) flags;
    468   1.47       erh 		syscallarg(int) fd;
    469   1.94      manu 		syscallarg(linux_off_t) offset;
    470   1.20   thorpej 	} */ *uap = v;
    471  1.118  christos 
    472  1.115  christos 	if (SCARG(uap, offset) & PAGE_MASK)
    473  1.115  christos 		return EINVAL;
    474  1.115  christos 
    475  1.128  jdolecek 	return linux_mmap(l, uap, retval, SCARG(uap, offset));
    476  1.118  christos }
    477  1.118  christos 
    478  1.118  christos /*
    479  1.118  christos  * Guts of most architectures' mmap64() implementations.  This shares
    480  1.118  christos  * its list of arguments with linux_sys_mmap().
    481  1.118  christos  *
    482  1.118  christos  * The difference in linux_sys_mmap2() is that "offset" is actually
    483  1.118  christos  * (offset / pagesize), not an absolute byte count.  This translation
    484  1.118  christos  * to pagesize offsets is done inside glibc between the mmap64() call
    485  1.118  christos  * point, and the actual syscall.
    486  1.118  christos  */
    487  1.118  christos int
    488  1.118  christos linux_sys_mmap2(l, v, retval)
    489  1.118  christos 	struct lwp *l;
    490  1.118  christos 	void *v;
    491  1.118  christos 	register_t *retval;
    492  1.118  christos {
    493  1.118  christos 	struct linux_sys_mmap2_args /* {
    494  1.118  christos 		syscallarg(unsigned long) addr;
    495  1.118  christos 		syscallarg(size_t) len;
    496  1.118  christos 		syscallarg(int) prot;
    497  1.118  christos 		syscallarg(int) flags;
    498  1.118  christos 		syscallarg(int) fd;
    499  1.118  christos 		syscallarg(linux_off_t) offset;
    500  1.118  christos 	} */ *uap = v;
    501  1.128  jdolecek 
    502  1.128  jdolecek 	return linux_mmap(l, uap, retval,
    503  1.128  jdolecek 	    ((off_t)SCARG(uap, offset)) << PAGE_SHIFT);
    504  1.128  jdolecek }
    505  1.128  jdolecek 
    506  1.128  jdolecek /*
    507  1.128  jdolecek  * Massage arguments and call system mmap(2).
    508  1.128  jdolecek  */
    509  1.128  jdolecek static int
    510  1.128  jdolecek linux_mmap(l, uap, retval, offset)
    511  1.128  jdolecek 	struct lwp *l;
    512  1.128  jdolecek 	struct linux_sys_mmap_args *uap;
    513  1.128  jdolecek 	register_t *retval;
    514  1.128  jdolecek 	off_t offset;
    515  1.128  jdolecek {
    516  1.118  christos 	struct sys_mmap_args cma;
    517  1.128  jdolecek 	int error;
    518  1.128  jdolecek 	size_t mmoff=0;
    519  1.128  jdolecek 
    520  1.128  jdolecek 	if (SCARG(uap, flags) & LINUX_MAP_GROWSDOWN) {
    521  1.128  jdolecek 		/*
    522  1.128  jdolecek 		 * Request for stack-like memory segment. On linux, this
    523  1.128  jdolecek 		 * works by mmap()ping (small) segment, which is automatically
    524  1.128  jdolecek 		 * extended when page fault happens below the currently
    525  1.128  jdolecek 		 * allocated area. We emulate this by allocating (typically
    526  1.128  jdolecek 		 * bigger) segment sized at current stack size limit, and
    527  1.128  jdolecek 		 * offsetting the requested and returned address accordingly.
    528  1.128  jdolecek 		 * Since physical pages are only allocated on-demand, this
    529  1.128  jdolecek 		 * is effectively identical.
    530  1.128  jdolecek 		 */
    531  1.128  jdolecek 		rlim_t ssl = l->l_proc->p_rlimit[RLIMIT_STACK].rlim_cur;
    532  1.128  jdolecek 
    533  1.128  jdolecek 		if (SCARG(uap, len) < ssl) {
    534  1.128  jdolecek 			/* Compute the address offset */
    535  1.128  jdolecek 			mmoff = round_page(ssl) - SCARG(uap, len);
    536  1.128  jdolecek 
    537  1.128  jdolecek 			if (SCARG(uap, addr))
    538  1.128  jdolecek 				SCARG(uap, addr) -= mmoff;
    539  1.128  jdolecek 
    540  1.128  jdolecek 			SCARG(uap, len) = (size_t) ssl;
    541  1.128  jdolecek 		}
    542  1.128  jdolecek 	}
    543  1.118  christos 
    544  1.118  christos 	linux_to_bsd_mmap_args(&cma, uap);
    545  1.128  jdolecek 	SCARG(&cma, pos) = offset;
    546  1.128  jdolecek 
    547  1.128  jdolecek 	error = sys_mmap(l, &cma, retval);
    548  1.128  jdolecek 	if (error)
    549  1.128  jdolecek 		return (error);
    550  1.128  jdolecek 
    551  1.128  jdolecek 	/* Shift the returned address for stack-like segment if necessary */
    552  1.128  jdolecek 	if (SCARG(uap, flags) & LINUX_MAP_GROWSDOWN && mmoff)
    553  1.128  jdolecek 		retval[0] += mmoff;
    554  1.118  christos 
    555  1.128  jdolecek 	return (0);
    556  1.118  christos }
    557  1.118  christos 
    558  1.118  christos static void
    559  1.118  christos linux_to_bsd_mmap_args(cma, uap)
    560  1.118  christos 	struct sys_mmap_args *cma;
    561  1.118  christos 	const struct linux_sys_mmap_args *uap;
    562  1.118  christos {
    563  1.119  christos 	int flags = MAP_TRYFIXED, fl = SCARG(uap, flags);
    564  1.118  christos 
    565  1.103  christos 	flags |= cvtto_bsd_mask(fl, LINUX_MAP_SHARED, MAP_SHARED);
    566  1.103  christos 	flags |= cvtto_bsd_mask(fl, LINUX_MAP_PRIVATE, MAP_PRIVATE);
    567  1.103  christos 	flags |= cvtto_bsd_mask(fl, LINUX_MAP_FIXED, MAP_FIXED);
    568  1.103  christos 	flags |= cvtto_bsd_mask(fl, LINUX_MAP_ANON, MAP_ANON);
    569   1.47       erh 	/* XXX XAX ERH: Any other flags here?  There are more defined... */
    570   1.47       erh 
    571  1.118  christos 	SCARG(cma, addr) = (void *)SCARG(uap, addr);
    572  1.118  christos 	SCARG(cma, len) = SCARG(uap, len);
    573  1.118  christos 	SCARG(cma, prot) = SCARG(uap, prot);
    574  1.118  christos 	if (SCARG(cma, prot) & VM_PROT_WRITE) /* XXX */
    575  1.118  christos 		SCARG(cma, prot) |= VM_PROT_READ;
    576  1.118  christos 	SCARG(cma, flags) = flags;
    577  1.118  christos 	SCARG(cma, fd) = flags & MAP_ANON ? -1 : SCARG(uap, fd);
    578  1.118  christos 	SCARG(cma, pad) = 0;
    579   1.97  christos }
    580   1.97  christos 
    581   1.34   mycroft int
    582  1.116   thorpej linux_sys_mremap(l, v, retval)
    583  1.116   thorpej 	struct lwp *l;
    584   1.34   mycroft 	void *v;
    585   1.34   mycroft 	register_t *retval;
    586   1.34   mycroft {
    587   1.34   mycroft 	struct linux_sys_mremap_args /* {
    588   1.34   mycroft 		syscallarg(void *) old_address;
    589   1.34   mycroft 		syscallarg(size_t) old_size;
    590   1.34   mycroft 		syscallarg(size_t) new_size;
    591   1.34   mycroft 		syscallarg(u_long) flags;
    592   1.34   mycroft 	} */ *uap = v;
    593   1.42   thorpej 	struct sys_munmap_args mua;
    594   1.42   thorpej 	size_t old_size, new_size;
    595   1.42   thorpej 	int error;
    596   1.42   thorpej 
    597   1.42   thorpej 	old_size = round_page(SCARG(uap, old_size));
    598   1.42   thorpej 	new_size = round_page(SCARG(uap, new_size));
    599   1.42   thorpej 
    600   1.42   thorpej 	/*
    601   1.42   thorpej 	 * Growing mapped region.
    602   1.42   thorpej 	 */
    603   1.42   thorpej 	if (new_size > old_size) {
    604   1.42   thorpej 		/*
    605   1.42   thorpej 		 * XXX Implement me.  What we probably want to do is
    606   1.42   thorpej 		 * XXX dig out the guts of the old mapping, mmap that
    607   1.42   thorpej 		 * XXX object again with the new size, then munmap
    608   1.42   thorpej 		 * XXX the old mapping.
    609   1.42   thorpej 		 */
    610   1.42   thorpej 		*retval = 0;
    611   1.42   thorpej 		return (ENOMEM);
    612   1.42   thorpej 	}
    613   1.42   thorpej 
    614   1.42   thorpej 	/*
    615   1.42   thorpej 	 * Shrinking mapped region.
    616   1.42   thorpej 	 */
    617   1.42   thorpej 	if (new_size < old_size) {
    618   1.42   thorpej 		SCARG(&mua, addr) = (caddr_t)SCARG(uap, old_address) +
    619   1.43   thorpej 		    new_size;
    620   1.42   thorpej 		SCARG(&mua, len) = old_size - new_size;
    621  1.116   thorpej 		error = sys_munmap(l, &mua, retval);
    622   1.42   thorpej 		*retval = error ? 0 : (register_t)SCARG(uap, old_address);
    623   1.42   thorpej 		return (error);
    624   1.42   thorpej 	}
    625   1.34   mycroft 
    626   1.42   thorpej 	/*
    627   1.42   thorpej 	 * No change.
    628   1.42   thorpej 	 */
    629   1.42   thorpej 	*retval = (register_t)SCARG(uap, old_address);
    630   1.42   thorpej 	return (0);
    631   1.24      fvdl }
    632   1.24      fvdl 
    633   1.24      fvdl int
    634  1.116   thorpej linux_sys_msync(l, v, retval)
    635  1.116   thorpej 	struct lwp *l;
    636   1.24      fvdl 	void *v;
    637   1.24      fvdl 	register_t *retval;
    638   1.24      fvdl {
    639   1.24      fvdl 	struct linux_sys_msync_args /* {
    640   1.24      fvdl 		syscallarg(caddr_t) addr;
    641   1.24      fvdl 		syscallarg(int) len;
    642   1.24      fvdl 		syscallarg(int) fl;
    643   1.24      fvdl 	} */ *uap = v;
    644   1.24      fvdl 
    645   1.36      fvdl 	struct sys___msync13_args bma;
    646   1.24      fvdl 
    647   1.24      fvdl 	/* flags are ignored */
    648   1.24      fvdl 	SCARG(&bma, addr) = SCARG(uap, addr);
    649   1.24      fvdl 	SCARG(&bma, len) = SCARG(uap, len);
    650   1.36      fvdl 	SCARG(&bma, flags) = SCARG(uap, fl);
    651   1.24      fvdl 
    652  1.116   thorpej 	return sys___msync13(l, &bma, retval);
    653  1.103  christos }
    654  1.103  christos 
    655  1.103  christos int
    656  1.116   thorpej linux_sys_mprotect(l, v, retval)
    657  1.116   thorpej 	struct lwp *l;
    658  1.103  christos 	void *v;
    659  1.103  christos 	register_t *retval;
    660  1.103  christos {
    661  1.103  christos 	struct linux_sys_mprotect_args /* {
    662  1.103  christos 		syscallarg(const void *) start;
    663  1.103  christos 		syscallarg(unsigned long) len;
    664  1.103  christos 		syscallarg(int) prot;
    665  1.103  christos 	} */ *uap = v;
    666  1.103  christos 	unsigned long end, start = (unsigned long)SCARG(uap, start), len;
    667  1.103  christos 	int prot = SCARG(uap, prot);
    668  1.103  christos 	struct vm_map_entry *entry;
    669  1.116   thorpej 	struct vm_map *map = &l->l_proc->p_vmspace->vm_map;
    670  1.103  christos 
    671  1.103  christos 	if (start & PAGE_MASK)
    672  1.103  christos 		return EINVAL;
    673  1.103  christos 
    674  1.103  christos 	len = round_page(SCARG(uap, len));
    675  1.103  christos 	end = start + len;
    676  1.103  christos 
    677  1.103  christos 	if (end < start)
    678  1.103  christos 		return EINVAL;
    679  1.103  christos 	else if (end == start)
    680  1.103  christos 		return 0;
    681  1.103  christos 
    682  1.103  christos 	if (SCARG(uap, prot) & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
    683  1.103  christos 		return EINVAL;
    684  1.103  christos 
    685  1.103  christos 	vm_map_lock(map);
    686  1.103  christos #ifdef notdef
    687  1.103  christos 	VM_MAP_RANGE_CHECK(map, start, end);
    688  1.103  christos #endif
    689  1.103  christos 	if (!uvm_map_lookup_entry(map, start, &entry) || entry->start > start) {
    690  1.103  christos 		vm_map_unlock(map);
    691  1.126  jdolecek 		return ENOMEM;
    692  1.103  christos 	}
    693  1.103  christos 	vm_map_unlock(map);
    694  1.103  christos 	return uvm_map_protect(map, start, end, prot, FALSE);
    695    1.1      fvdl }
    696    1.1      fvdl 
    697    1.1      fvdl /*
    698    1.1      fvdl  * This code is partly stolen from src/lib/libc/compat-43/times.c
    699    1.1      fvdl  */
    700    1.1      fvdl 
    701  1.113  jdolecek #define	CONVTCK(r)	(r.tv_sec * hz + r.tv_usec / (1000000 / hz))
    702    1.1      fvdl 
    703    1.1      fvdl int
    704  1.116   thorpej linux_sys_times(l, v, retval)
    705  1.116   thorpej 	struct lwp *l;
    706   1.20   thorpej 	void *v;
    707   1.20   thorpej 	register_t *retval;
    708   1.20   thorpej {
    709   1.21   mycroft 	struct linux_sys_times_args /* {
    710    1.1      fvdl 		syscallarg(struct times *) tms;
    711   1.20   thorpej 	} */ *uap = v;
    712  1.116   thorpej 	struct proc *p = l->l_proc;
    713    1.1      fvdl 	struct timeval t;
    714    1.4   mycroft 	int error, s;
    715    1.1      fvdl 
    716  1.112  jdolecek 	if (SCARG(uap, tms)) {
    717  1.112  jdolecek 		struct linux_tms ltms;
    718  1.112  jdolecek 		struct rusage ru;
    719  1.112  jdolecek 
    720  1.112  jdolecek 		calcru(p, &ru.ru_utime, &ru.ru_stime, NULL);
    721  1.112  jdolecek 		ltms.ltms_utime = CONVTCK(ru.ru_utime);
    722  1.112  jdolecek 		ltms.ltms_stime = CONVTCK(ru.ru_stime);
    723    1.1      fvdl 
    724  1.112  jdolecek 		ltms.ltms_cutime = CONVTCK(p->p_stats->p_cru.ru_utime);
    725  1.112  jdolecek 		ltms.ltms_cstime = CONVTCK(p->p_stats->p_cru.ru_stime);
    726    1.1      fvdl 
    727  1.112  jdolecek 		if ((error = copyout(&ltms, SCARG(uap, tms), sizeof ltms)))
    728  1.112  jdolecek 			return error;
    729  1.112  jdolecek 	}
    730    1.1      fvdl 
    731    1.4   mycroft 	s = splclock();
    732    1.4   mycroft 	timersub(&time, &boottime, &t);
    733    1.4   mycroft 	splx(s);
    734    1.1      fvdl 
    735    1.1      fvdl 	retval[0] = ((linux_clock_t)(CONVTCK(t)));
    736    1.1      fvdl 	return 0;
    737    1.1      fvdl }
    738  1.113  jdolecek 
    739  1.113  jdolecek #undef CONVTCK
    740    1.1      fvdl 
    741    1.1      fvdl /*
    742    1.1      fvdl  * Linux 'readdir' call. This code is mostly taken from the
    743    1.1      fvdl  * SunOS getdents call (see compat/sunos/sunos_misc.c), though
    744    1.1      fvdl  * an attempt has been made to keep it a little cleaner (failing
    745    1.1      fvdl  * miserably, because of the cruft needed if count 1 is passed).
    746    1.1      fvdl  *
    747   1.17      fvdl  * The d_off field should contain the offset of the next valid entry,
    748   1.17      fvdl  * but in Linux it has the offset of the entry itself. We emulate
    749   1.17      fvdl  * that bug here.
    750   1.17      fvdl  *
    751    1.1      fvdl  * Read in BSD-style entries, convert them, and copy them out.
    752    1.1      fvdl  *
    753    1.1      fvdl  * Note that this doesn't handle union-mounted filesystems.
    754    1.1      fvdl  */
    755    1.1      fvdl int
    756  1.116   thorpej linux_sys_getdents(l, v, retval)
    757  1.116   thorpej 	struct lwp *l;
    758   1.20   thorpej 	void *v;
    759   1.20   thorpej 	register_t *retval;
    760   1.20   thorpej {
    761   1.47       erh 	struct linux_sys_getdents_args /* {
    762    1.1      fvdl 		syscallarg(int) fd;
    763   1.47       erh 		syscallarg(struct linux_dirent *) dent;
    764    1.1      fvdl 		syscallarg(unsigned int) count;
    765   1.20   thorpej 	} */ *uap = v;
    766  1.116   thorpej 	struct proc *p = l->l_proc;
    767   1.69  augustss 	struct dirent *bdp;
    768    1.1      fvdl 	struct vnode *vp;
    769   1.26  christos 	caddr_t	inp, buf;		/* BSD-format */
    770   1.26  christos 	int len, reclen;		/* BSD-format */
    771   1.51      fvdl 	caddr_t outp;			/* Linux-format */
    772   1.26  christos 	int resid, linux_reclen = 0;	/* Linux-format */
    773    1.1      fvdl 	struct file *fp;
    774    1.1      fvdl 	struct uio auio;
    775    1.1      fvdl 	struct iovec aiov;
    776    1.1      fvdl 	struct linux_dirent idb;
    777    1.1      fvdl 	off_t off;		/* true file offset */
    778   1.17      fvdl 	int buflen, error, eofflag, nbytes, oldcall;
    779    1.1      fvdl 	struct vattr va;
    780   1.40      fvdl 	off_t *cookiebuf = NULL, *cookie;
    781   1.22   mycroft 	int ncookies;
    782    1.1      fvdl 
    783   1.54   thorpej 	/* getvnode() will use the descriptor for us */
    784    1.1      fvdl 	if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
    785    1.1      fvdl 		return (error);
    786    1.1      fvdl 
    787   1.54   thorpej 	if ((fp->f_flag & FREAD) == 0) {
    788   1.54   thorpej 		error = EBADF;
    789   1.54   thorpej 		goto out1;
    790   1.54   thorpej 	}
    791    1.1      fvdl 
    792    1.5   mycroft 	vp = (struct vnode *)fp->f_data;
    793   1.54   thorpej 	if (vp->v_type != VDIR) {
    794   1.54   thorpej 		error = EINVAL;
    795   1.54   thorpej 		goto out1;
    796   1.54   thorpej 	}
    797    1.1      fvdl 
    798  1.121      fvdl 	if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)))
    799   1.54   thorpej 		goto out1;
    800    1.1      fvdl 
    801    1.1      fvdl 	nbytes = SCARG(uap, count);
    802   1.17      fvdl 	if (nbytes == 1) {	/* emulating old, broken behaviour */
    803  1.107  christos 		nbytes = sizeof (idb);
    804    1.5   mycroft 		buflen = max(va.va_blocksize, nbytes);
    805   1.17      fvdl 		oldcall = 1;
    806    1.5   mycroft 	} else {
    807    1.5   mycroft 		buflen = min(MAXBSIZE, nbytes);
    808   1.33      fvdl 		if (buflen < va.va_blocksize)
    809   1.33      fvdl 			buflen = va.va_blocksize;
    810   1.17      fvdl 		oldcall = 0;
    811    1.1      fvdl 	}
    812    1.1      fvdl 	buf = malloc(buflen, M_TEMP, M_WAITOK);
    813   1.33      fvdl 
    814   1.39      fvdl 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    815    1.1      fvdl 	off = fp->f_offset;
    816    1.1      fvdl again:
    817    1.1      fvdl 	aiov.iov_base = buf;
    818    1.1      fvdl 	aiov.iov_len = buflen;
    819    1.1      fvdl 	auio.uio_iov = &aiov;
    820    1.1      fvdl 	auio.uio_iovcnt = 1;
    821    1.1      fvdl 	auio.uio_rw = UIO_READ;
    822    1.1      fvdl 	auio.uio_segflg = UIO_SYSSPACE;
    823  1.130     skrll 	auio.uio_procp = NULL;
    824    1.1      fvdl 	auio.uio_resid = buflen;
    825    1.1      fvdl 	auio.uio_offset = off;
    826    1.1      fvdl 	/*
    827    1.1      fvdl          * First we read into the malloc'ed buffer, then
    828    1.1      fvdl          * we massage it into user space, one record at a time.
    829    1.1      fvdl          */
    830   1.39      fvdl 	error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &cookiebuf,
    831   1.39      fvdl 	    &ncookies);
    832    1.1      fvdl 	if (error)
    833    1.1      fvdl 		goto out;
    834    1.1      fvdl 
    835    1.1      fvdl 	inp = buf;
    836   1.51      fvdl 	outp = (caddr_t)SCARG(uap, dent);
    837    1.1      fvdl 	resid = nbytes;
    838   1.35      fvdl 	if ((len = buflen - auio.uio_resid) == 0)
    839    1.1      fvdl 		goto eof;
    840    1.1      fvdl 
    841   1.22   mycroft 	for (cookie = cookiebuf; len > 0; len -= reclen) {
    842    1.5   mycroft 		bdp = (struct dirent *)inp;
    843    1.5   mycroft 		reclen = bdp->d_reclen;
    844    1.1      fvdl 		if (reclen & 3)
    845    1.1      fvdl 			panic("linux_readdir");
    846    1.1      fvdl 		if (bdp->d_fileno == 0) {
    847    1.1      fvdl 			inp += reclen;	/* it is a hole; squish it out */
    848   1.22   mycroft 			off = *cookie++;
    849    1.1      fvdl 			continue;
    850    1.1      fvdl 		}
    851   1.21   mycroft 		linux_reclen = LINUX_RECLEN(&idb, bdp->d_namlen);
    852   1.21   mycroft 		if (reclen > len || resid < linux_reclen) {
    853    1.1      fvdl 			/* entry too big for buffer, so just stop */
    854    1.1      fvdl 			outp++;
    855    1.1      fvdl 			break;
    856    1.1      fvdl 		}
    857    1.1      fvdl 		/*
    858    1.1      fvdl 		 * Massage in place to make a Linux-shaped dirent (otherwise
    859    1.1      fvdl 		 * we have to worry about touching user memory outside of
    860    1.1      fvdl 		 * the copyout() call).
    861    1.1      fvdl 		 */
    862  1.107  christos 		idb.d_ino = bdp->d_fileno;
    863   1.17      fvdl 		/*
    864   1.21   mycroft 		 * The old readdir() call misuses the offset and reclen fields.
    865   1.17      fvdl 		 */
    866   1.22   mycroft 		if (oldcall) {
    867   1.22   mycroft 			idb.d_off = (linux_off_t)linux_reclen;
    868   1.22   mycroft 			idb.d_reclen = (u_short)bdp->d_namlen;
    869   1.22   mycroft 		} else {
    870  1.109      tron 			if (sizeof (idb.d_off) <= 4 && (off >> 32) != 0) {
    871   1.33      fvdl 				compat_offseterr(vp, "linux_getdents");
    872   1.33      fvdl 				error = EINVAL;
    873   1.33      fvdl 				goto out;
    874   1.33      fvdl 			}
    875   1.22   mycroft 			idb.d_off = (linux_off_t)off;
    876  1.107  christos 			idb.d_reclen = (u_short)linux_reclen;
    877  1.107  christos 		}
    878  1.107  christos 		strcpy(idb.d_name, bdp->d_name);
    879  1.107  christos 		if ((error = copyout((caddr_t)&idb, outp, linux_reclen)))
    880  1.107  christos 			goto out;
    881  1.107  christos 		/* advance past this real entry */
    882  1.107  christos 		inp += reclen;
    883  1.107  christos 		off = *cookie++;	/* each entry points to itself */
    884  1.107  christos 		/* advance output past Linux-shaped entry */
    885  1.107  christos 		outp += linux_reclen;
    886  1.107  christos 		resid -= linux_reclen;
    887  1.107  christos 		if (oldcall)
    888  1.107  christos 			break;
    889  1.107  christos 	}
    890  1.107  christos 
    891  1.107  christos 	/* if we squished out the whole block, try again */
    892  1.107  christos 	if (outp == (caddr_t)SCARG(uap, dent))
    893  1.107  christos 		goto again;
    894  1.107  christos 	fp->f_offset = off;	/* update the vnode offset */
    895  1.107  christos 
    896  1.107  christos 	if (oldcall)
    897  1.107  christos 		nbytes = resid + linux_reclen;
    898  1.107  christos 
    899  1.107  christos eof:
    900  1.107  christos 	*retval = nbytes - resid;
    901  1.107  christos out:
    902  1.107  christos 	VOP_UNLOCK(vp, 0);
    903  1.107  christos 	if (cookiebuf)
    904  1.107  christos 		free(cookiebuf, M_TEMP);
    905  1.107  christos 	free(buf, M_TEMP);
    906  1.107  christos out1:
    907  1.121      fvdl 	FILE_UNUSE(fp, p);
    908    1.1      fvdl 	return error;
    909    1.1      fvdl }
    910    1.1      fvdl 
    911    1.1      fvdl /*
    912   1.17      fvdl  * Even when just using registers to pass arguments to syscalls you can
    913   1.17      fvdl  * have 5 of them on the i386. So this newer version of select() does
    914   1.17      fvdl  * this.
    915    1.1      fvdl  */
    916    1.1      fvdl int
    917  1.116   thorpej linux_sys_select(l, v, retval)
    918  1.116   thorpej 	struct lwp *l;
    919   1.20   thorpej 	void *v;
    920   1.20   thorpej 	register_t *retval;
    921   1.20   thorpej {
    922   1.21   mycroft 	struct linux_sys_select_args /* {
    923   1.17      fvdl 		syscallarg(int) nfds;
    924   1.17      fvdl 		syscallarg(fd_set *) readfds;
    925   1.17      fvdl 		syscallarg(fd_set *) writefds;
    926   1.17      fvdl 		syscallarg(fd_set *) exceptfds;
    927   1.17      fvdl 		syscallarg(struct timeval *) timeout;
    928   1.20   thorpej 	} */ *uap = v;
    929   1.20   thorpej 
    930  1.116   thorpej 	return linux_select1(l, retval, SCARG(uap, nfds), SCARG(uap, readfds),
    931   1.17      fvdl 	    SCARG(uap, writefds), SCARG(uap, exceptfds), SCARG(uap, timeout));
    932   1.17      fvdl }
    933   1.17      fvdl 
    934   1.17      fvdl /*
    935   1.17      fvdl  * Common code for the old and new versions of select(). A couple of
    936   1.17      fvdl  * things are important:
    937   1.17      fvdl  * 1) return the amount of time left in the 'timeout' parameter
    938   1.17      fvdl  * 2) select never returns ERESTART on Linux, always return EINTR
    939   1.17      fvdl  */
    940   1.17      fvdl int
    941  1.116   thorpej linux_select1(l, retval, nfds, readfds, writefds, exceptfds, timeout)
    942  1.116   thorpej 	struct lwp *l;
    943   1.17      fvdl 	register_t *retval;
    944   1.17      fvdl 	int nfds;
    945   1.17      fvdl 	fd_set *readfds, *writefds, *exceptfds;
    946   1.17      fvdl 	struct timeval *timeout;
    947   1.17      fvdl {
    948   1.21   mycroft 	struct sys_select_args bsa;
    949  1.116   thorpej 	struct proc *p = l->l_proc;
    950   1.13   mycroft 	struct timeval tv0, tv1, utv, *tvp;
    951   1.13   mycroft 	caddr_t sg;
    952    1.1      fvdl 	int error;
    953    1.1      fvdl 
    954   1.17      fvdl 	SCARG(&bsa, nd) = nfds;
    955   1.17      fvdl 	SCARG(&bsa, in) = readfds;
    956   1.17      fvdl 	SCARG(&bsa, ou) = writefds;
    957   1.17      fvdl 	SCARG(&bsa, ex) = exceptfds;
    958   1.17      fvdl 	SCARG(&bsa, tv) = timeout;
    959    1.1      fvdl 
    960    1.7      fvdl 	/*
    961    1.7      fvdl 	 * Store current time for computation of the amount of
    962    1.7      fvdl 	 * time left.
    963    1.7      fvdl 	 */
    964   1.17      fvdl 	if (timeout) {
    965   1.17      fvdl 		if ((error = copyin(timeout, &utv, sizeof(utv))))
    966   1.13   mycroft 			return error;
    967   1.13   mycroft 		if (itimerfix(&utv)) {
    968   1.13   mycroft 			/*
    969   1.13   mycroft 			 * The timeval was invalid.  Convert it to something
    970   1.13   mycroft 			 * valid that will act as it does under Linux.
    971   1.13   mycroft 			 */
    972  1.102  christos 			sg = stackgap_init(p, 0);
    973  1.102  christos 			tvp = stackgap_alloc(p, &sg, sizeof(utv));
    974   1.13   mycroft 			utv.tv_sec += utv.tv_usec / 1000000;
    975   1.13   mycroft 			utv.tv_usec %= 1000000;
    976   1.13   mycroft 			if (utv.tv_usec < 0) {
    977   1.13   mycroft 				utv.tv_sec -= 1;
    978   1.13   mycroft 				utv.tv_usec += 1000000;
    979   1.13   mycroft 			}
    980   1.13   mycroft 			if (utv.tv_sec < 0)
    981   1.13   mycroft 				timerclear(&utv);
    982   1.13   mycroft 			if ((error = copyout(&utv, tvp, sizeof(utv))))
    983   1.13   mycroft 				return error;
    984   1.13   mycroft 			SCARG(&bsa, tv) = tvp;
    985   1.13   mycroft 		}
    986    1.7      fvdl 		microtime(&tv0);
    987   1.13   mycroft 	}
    988    1.7      fvdl 
    989  1.116   thorpej 	error = sys_select(l, &bsa, retval);
    990   1.10   mycroft 	if (error) {
    991   1.10   mycroft 		/*
    992   1.10   mycroft 		 * See fs/select.c in the Linux kernel.  Without this,
    993   1.10   mycroft 		 * Maelstrom doesn't work.
    994   1.10   mycroft 		 */
    995   1.10   mycroft 		if (error == ERESTART)
    996   1.10   mycroft 			error = EINTR;
    997    1.7      fvdl 		return error;
    998   1.10   mycroft 	}
    999    1.7      fvdl 
   1000   1.17      fvdl 	if (timeout) {
   1001   1.14   mycroft 		if (*retval) {
   1002    1.7      fvdl 			/*
   1003   1.13   mycroft 			 * Compute how much time was left of the timeout,
   1004    1.7      fvdl 			 * by subtracting the current time and the time
   1005    1.7      fvdl 			 * before we started the call, and subtracting
   1006    1.7      fvdl 			 * that result from the user-supplied value.
   1007    1.7      fvdl 			 */
   1008    1.7      fvdl 			microtime(&tv1);
   1009    1.7      fvdl 			timersub(&tv1, &tv0, &tv1);
   1010    1.7      fvdl 			timersub(&utv, &tv1, &utv);
   1011   1.14   mycroft 			if (utv.tv_sec < 0)
   1012   1.14   mycroft 				timerclear(&utv);
   1013   1.14   mycroft 		} else
   1014   1.14   mycroft 			timerclear(&utv);
   1015   1.17      fvdl 		if ((error = copyout(&utv, timeout, sizeof(utv))))
   1016    1.7      fvdl 			return error;
   1017    1.7      fvdl 	}
   1018   1.13   mycroft 
   1019    1.7      fvdl 	return 0;
   1020    1.1      fvdl }
   1021    1.1      fvdl 
   1022    1.1      fvdl /*
   1023    1.1      fvdl  * Get the process group of a certain process. Look it up
   1024    1.1      fvdl  * and return the value.
   1025    1.1      fvdl  */
   1026    1.1      fvdl int
   1027  1.116   thorpej linux_sys_getpgid(l, v, retval)
   1028  1.116   thorpej 	struct lwp *l;
   1029   1.20   thorpej 	void *v;
   1030   1.20   thorpej 	register_t *retval;
   1031   1.20   thorpej {
   1032   1.21   mycroft 	struct linux_sys_getpgid_args /* {
   1033    1.1      fvdl 		syscallarg(int) pid;
   1034   1.20   thorpej 	} */ *uap = v;
   1035  1.116   thorpej 	struct proc *p = l->l_proc;
   1036    1.1      fvdl 	struct proc *targp;
   1037    1.1      fvdl 
   1038   1.26  christos 	if (SCARG(uap, pid) != 0 && SCARG(uap, pid) != p->p_pid) {
   1039    1.1      fvdl 		if ((targp = pfind(SCARG(uap, pid))) == 0)
   1040    1.1      fvdl 			return ESRCH;
   1041   1.26  christos 	}
   1042    1.1      fvdl 	else
   1043    1.1      fvdl 		targp = p;
   1044    1.1      fvdl 
   1045    1.1      fvdl 	retval[0] = targp->p_pgid;
   1046    1.6      fvdl 	return 0;
   1047    1.6      fvdl }
   1048    1.6      fvdl 
   1049    1.6      fvdl /*
   1050    1.6      fvdl  * Set the 'personality' (emulation mode) for the current process. Only
   1051    1.6      fvdl  * accept the Linux personality here (0). This call is needed because
   1052    1.6      fvdl  * the Linux ELF crt0 issues it in an ugly kludge to make sure that
   1053    1.6      fvdl  * ELF binaries run in Linux mode, not SVR4 mode.
   1054    1.6      fvdl  */
   1055    1.6      fvdl int
   1056  1.116   thorpej linux_sys_personality(l, v, retval)
   1057  1.116   thorpej 	struct lwp *l;
   1058   1.20   thorpej 	void *v;
   1059   1.20   thorpej 	register_t *retval;
   1060   1.20   thorpej {
   1061   1.21   mycroft 	struct linux_sys_personality_args /* {
   1062    1.6      fvdl 		syscallarg(int) per;
   1063   1.20   thorpej 	} */ *uap = v;
   1064   1.20   thorpej 
   1065    1.6      fvdl 	if (SCARG(uap, per) != 0)
   1066    1.6      fvdl 		return EINVAL;
   1067    1.6      fvdl 	retval[0] = 0;
   1068    1.1      fvdl 	return 0;
   1069   1.18      fvdl }
   1070   1.18      fvdl 
   1071   1.79   thorpej #if defined(__i386__) || defined(__m68k__)
   1072   1.18      fvdl /*
   1073   1.18      fvdl  * The calls are here because of type conversions.
   1074   1.18      fvdl  */
   1075   1.18      fvdl int
   1076  1.116   thorpej linux_sys_setreuid16(l, v, retval)
   1077  1.116   thorpej 	struct lwp *l;
   1078   1.20   thorpej 	void *v;
   1079   1.20   thorpej 	register_t *retval;
   1080   1.20   thorpej {
   1081   1.78      fvdl 	struct linux_sys_setreuid16_args /* {
   1082   1.18      fvdl 		syscallarg(int) ruid;
   1083   1.18      fvdl 		syscallarg(int) euid;
   1084   1.20   thorpej 	} */ *uap = v;
   1085   1.28   mycroft 	struct sys_setreuid_args bsa;
   1086   1.18      fvdl 
   1087   1.18      fvdl 	SCARG(&bsa, ruid) = ((linux_uid_t)SCARG(uap, ruid) == (linux_uid_t)-1) ?
   1088   1.18      fvdl 		(uid_t)-1 : SCARG(uap, ruid);
   1089   1.18      fvdl 	SCARG(&bsa, euid) = ((linux_uid_t)SCARG(uap, euid) == (linux_uid_t)-1) ?
   1090   1.18      fvdl 		(uid_t)-1 : SCARG(uap, euid);
   1091   1.18      fvdl 
   1092  1.116   thorpej 	return sys_setreuid(l, &bsa, retval);
   1093   1.18      fvdl }
   1094   1.18      fvdl 
   1095   1.18      fvdl int
   1096  1.116   thorpej linux_sys_setregid16(l, v, retval)
   1097  1.116   thorpej 	struct lwp *l;
   1098   1.20   thorpej 	void *v;
   1099   1.20   thorpej 	register_t *retval;
   1100   1.20   thorpej {
   1101   1.78      fvdl 	struct linux_sys_setregid16_args /* {
   1102   1.18      fvdl 		syscallarg(int) rgid;
   1103   1.18      fvdl 		syscallarg(int) egid;
   1104   1.20   thorpej 	} */ *uap = v;
   1105   1.28   mycroft 	struct sys_setregid_args bsa;
   1106   1.18      fvdl 
   1107   1.18      fvdl 	SCARG(&bsa, rgid) = ((linux_gid_t)SCARG(uap, rgid) == (linux_gid_t)-1) ?
   1108   1.18      fvdl 		(uid_t)-1 : SCARG(uap, rgid);
   1109   1.18      fvdl 	SCARG(&bsa, egid) = ((linux_gid_t)SCARG(uap, egid) == (linux_gid_t)-1) ?
   1110   1.18      fvdl 		(uid_t)-1 : SCARG(uap, egid);
   1111   1.18      fvdl 
   1112  1.116   thorpej 	return sys_setregid(l, &bsa, retval);
   1113   1.63       abs }
   1114   1.81      fvdl 
   1115   1.81      fvdl int
   1116  1.116   thorpej linux_sys_setresuid16(l, v, retval)
   1117  1.116   thorpej 	struct lwp *l;
   1118   1.81      fvdl 	void *v;
   1119   1.81      fvdl 	register_t *retval;
   1120   1.81      fvdl {
   1121   1.81      fvdl 	struct linux_sys_setresuid16_args /* {
   1122   1.81      fvdl 		syscallarg(uid_t) ruid;
   1123   1.81      fvdl 		syscallarg(uid_t) euid;
   1124   1.81      fvdl 		syscallarg(uid_t) suid;
   1125   1.81      fvdl 	} */ *uap = v;
   1126   1.81      fvdl 	struct linux_sys_setresuid16_args lsa;
   1127   1.81      fvdl 
   1128   1.81      fvdl 	SCARG(&lsa, ruid) = ((linux_uid_t)SCARG(uap, ruid) == (linux_uid_t)-1) ?
   1129   1.81      fvdl 		(uid_t)-1 : SCARG(uap, ruid);
   1130   1.81      fvdl 	SCARG(&lsa, euid) = ((linux_uid_t)SCARG(uap, euid) == (linux_uid_t)-1) ?
   1131   1.81      fvdl 		(uid_t)-1 : SCARG(uap, euid);
   1132   1.81      fvdl 	SCARG(&lsa, suid) = ((linux_uid_t)SCARG(uap, suid) == (linux_uid_t)-1) ?
   1133   1.81      fvdl 		(uid_t)-1 : SCARG(uap, suid);
   1134   1.81      fvdl 
   1135  1.116   thorpej 	return linux_sys_setresuid(l, &lsa, retval);
   1136   1.81      fvdl }
   1137   1.81      fvdl 
   1138   1.81      fvdl int
   1139  1.116   thorpej linux_sys_setresgid16(l, v, retval)
   1140  1.116   thorpej 	struct lwp *l;
   1141   1.81      fvdl 	void *v;
   1142   1.81      fvdl 	register_t *retval;
   1143   1.81      fvdl {
   1144   1.81      fvdl 	struct linux_sys_setresgid16_args /* {
   1145   1.81      fvdl 		syscallarg(gid_t) rgid;
   1146   1.81      fvdl 		syscallarg(gid_t) egid;
   1147   1.81      fvdl 		syscallarg(gid_t) sgid;
   1148   1.81      fvdl 	} */ *uap = v;
   1149   1.81      fvdl 	struct linux_sys_setresgid16_args lsa;
   1150   1.81      fvdl 
   1151   1.81      fvdl 	SCARG(&lsa, rgid) = ((linux_gid_t)SCARG(uap, rgid) == (linux_gid_t)-1) ?
   1152   1.81      fvdl 		(gid_t)-1 : SCARG(uap, rgid);
   1153   1.81      fvdl 	SCARG(&lsa, egid) = ((linux_gid_t)SCARG(uap, egid) == (linux_gid_t)-1) ?
   1154   1.81      fvdl 		(gid_t)-1 : SCARG(uap, egid);
   1155   1.81      fvdl 	SCARG(&lsa, sgid) = ((linux_gid_t)SCARG(uap, sgid) == (linux_gid_t)-1) ?
   1156   1.81      fvdl 		(gid_t)-1 : SCARG(uap, sgid);
   1157   1.81      fvdl 
   1158  1.116   thorpej 	return linux_sys_setresgid(l, &lsa, retval);
   1159   1.81      fvdl }
   1160   1.81      fvdl 
   1161   1.81      fvdl int
   1162  1.116   thorpej linux_sys_getgroups16(l, v, retval)
   1163  1.116   thorpej 	struct lwp *l;
   1164   1.81      fvdl 	void *v;
   1165   1.81      fvdl 	register_t *retval;
   1166   1.81      fvdl {
   1167   1.81      fvdl 	struct linux_sys_getgroups16_args /* {
   1168   1.81      fvdl 		syscallarg(int) gidsetsize;
   1169   1.81      fvdl 		syscallarg(linux_gid_t *) gidset;
   1170   1.81      fvdl 	} */ *uap = v;
   1171  1.116   thorpej 	struct proc *p = l->l_proc;
   1172   1.81      fvdl 	caddr_t sg;
   1173   1.81      fvdl 	int n, error, i;
   1174   1.81      fvdl 	struct sys_getgroups_args bsa;
   1175   1.81      fvdl 	gid_t *bset, *kbset;
   1176   1.81      fvdl 	linux_gid_t *lset;
   1177   1.81      fvdl 	struct pcred *pc = p->p_cred;
   1178   1.81      fvdl 
   1179   1.81      fvdl 	n = SCARG(uap, gidsetsize);
   1180   1.81      fvdl 	if (n < 0)
   1181   1.81      fvdl 		return EINVAL;
   1182   1.81      fvdl 	error = 0;
   1183   1.81      fvdl 	bset = kbset = NULL;
   1184   1.81      fvdl 	lset = NULL;
   1185   1.81      fvdl 	if (n > 0) {
   1186   1.81      fvdl 		n = min(pc->pc_ucred->cr_ngroups, n);
   1187  1.102  christos 		sg = stackgap_init(p, 0);
   1188  1.102  christos 		bset = stackgap_alloc(p, &sg, n * sizeof (gid_t));
   1189   1.81      fvdl 		kbset = malloc(n * sizeof (gid_t), M_TEMP, M_WAITOK);
   1190   1.81      fvdl 		lset = malloc(n * sizeof (linux_gid_t), M_TEMP, M_WAITOK);
   1191   1.81      fvdl 		if (bset == NULL || kbset == NULL || lset == NULL)
   1192   1.81      fvdl 			return ENOMEM;
   1193   1.81      fvdl 		SCARG(&bsa, gidsetsize) = n;
   1194   1.81      fvdl 		SCARG(&bsa, gidset) = bset;
   1195  1.116   thorpej 		error = sys_getgroups(l, &bsa, retval);
   1196   1.81      fvdl 		if (error != 0)
   1197   1.81      fvdl 			goto out;
   1198   1.81      fvdl 		error = copyin(bset, kbset, n * sizeof (gid_t));
   1199   1.81      fvdl 		if (error != 0)
   1200   1.81      fvdl 			goto out;
   1201   1.81      fvdl 		for (i = 0; i < n; i++)
   1202   1.81      fvdl 			lset[i] = (linux_gid_t)kbset[i];
   1203   1.81      fvdl 		error = copyout(lset, SCARG(uap, gidset),
   1204   1.81      fvdl 		    n * sizeof (linux_gid_t));
   1205   1.81      fvdl 	} else
   1206   1.81      fvdl 		*retval = pc->pc_ucred->cr_ngroups;
   1207   1.81      fvdl out:
   1208   1.81      fvdl 	if (kbset != NULL)
   1209   1.81      fvdl 		free(kbset, M_TEMP);
   1210   1.81      fvdl 	if (lset != NULL)
   1211   1.81      fvdl 		free(lset, M_TEMP);
   1212   1.81      fvdl 	return error;
   1213   1.81      fvdl }
   1214   1.81      fvdl 
   1215   1.81      fvdl int
   1216  1.116   thorpej linux_sys_setgroups16(l, v, retval)
   1217  1.116   thorpej 	struct lwp *l;
   1218   1.81      fvdl 	void *v;
   1219   1.81      fvdl 	register_t *retval;
   1220   1.81      fvdl {
   1221   1.81      fvdl 	struct linux_sys_setgroups16_args /* {
   1222   1.81      fvdl 		syscallarg(int) gidsetsize;
   1223   1.81      fvdl 		syscallarg(linux_gid_t *) gidset;
   1224   1.81      fvdl 	} */ *uap = v;
   1225  1.116   thorpej 	struct proc *p = l->l_proc;
   1226   1.81      fvdl 	caddr_t sg;
   1227   1.81      fvdl 	int n;
   1228   1.81      fvdl 	int error, i;
   1229   1.81      fvdl 	struct sys_setgroups_args bsa;
   1230   1.81      fvdl 	gid_t *bset, *kbset;
   1231   1.81      fvdl 	linux_gid_t *lset;
   1232   1.81      fvdl 
   1233   1.81      fvdl 	n = SCARG(uap, gidsetsize);
   1234   1.81      fvdl 	if (n < 0 || n > NGROUPS)
   1235   1.81      fvdl 		return EINVAL;
   1236  1.102  christos 	sg = stackgap_init(p, 0);
   1237  1.102  christos 	bset = stackgap_alloc(p, &sg, n * sizeof (gid_t));
   1238   1.81      fvdl 	lset = malloc(n * sizeof (linux_gid_t), M_TEMP, M_WAITOK);
   1239  1.106      fvdl 	kbset = malloc(n * sizeof (gid_t), M_TEMP, M_WAITOK);
   1240   1.81      fvdl 	if (lset == NULL || bset == NULL)
   1241   1.81      fvdl 		return ENOMEM;
   1242   1.81      fvdl 	error = copyin(SCARG(uap, gidset), lset, n * sizeof (linux_gid_t));
   1243   1.81      fvdl 	if (error != 0)
   1244   1.81      fvdl 		goto out;
   1245   1.81      fvdl 	for (i = 0; i < n; i++)
   1246   1.81      fvdl 		kbset[i] = (gid_t)lset[i];
   1247   1.81      fvdl 	error = copyout(kbset, bset, n * sizeof (gid_t));
   1248   1.81      fvdl 	if (error != 0)
   1249   1.81      fvdl 		goto out;
   1250   1.81      fvdl 	SCARG(&bsa, gidsetsize) = n;
   1251   1.81      fvdl 	SCARG(&bsa, gidset) = bset;
   1252  1.116   thorpej 	error = sys_setgroups(l, &bsa, retval);
   1253   1.81      fvdl 
   1254   1.81      fvdl out:
   1255   1.81      fvdl 	if (lset != NULL)
   1256   1.81      fvdl 		free(lset, M_TEMP);
   1257   1.81      fvdl 	if (kbset != NULL)
   1258   1.81      fvdl 		free(kbset, M_TEMP);
   1259   1.81      fvdl 
   1260   1.81      fvdl 	return error;
   1261   1.81      fvdl }
   1262   1.81      fvdl 
   1263   1.79   thorpej #endif /* __i386__ || __m68k__ */
   1264   1.63       abs 
   1265   1.63       abs /*
   1266   1.64       abs  * We have nonexistent fsuid equal to uid.
   1267   1.64       abs  * If modification is requested, refuse.
   1268   1.63       abs  */
   1269   1.63       abs int
   1270  1.116   thorpej linux_sys_setfsuid(l, v, retval)
   1271  1.116   thorpej 	 struct lwp *l;
   1272   1.63       abs 	 void *v;
   1273   1.63       abs 	 register_t *retval;
   1274   1.63       abs {
   1275   1.63       abs 	 struct linux_sys_setfsuid_args /* {
   1276   1.63       abs 		 syscallarg(uid_t) uid;
   1277   1.63       abs 	 } */ *uap = v;
   1278  1.116   thorpej 	 struct proc *p = l->l_proc;
   1279   1.63       abs 	 uid_t uid;
   1280   1.63       abs 
   1281   1.63       abs 	 uid = SCARG(uap, uid);
   1282   1.63       abs 	 if (p->p_cred->p_ruid != uid)
   1283  1.116   thorpej 		 return sys_nosys(l, v, retval);
   1284   1.63       abs 	 else
   1285   1.63       abs 		 return (0);
   1286   1.63       abs }
   1287   1.63       abs 
   1288   1.66       erh /* XXX XXX XXX */
   1289   1.66       erh #ifndef alpha
   1290   1.63       abs int
   1291  1.116   thorpej linux_sys_getfsuid(l, v, retval)
   1292  1.116   thorpej 	struct lwp *l;
   1293   1.66       erh 	void *v;
   1294   1.66       erh 	register_t *retval;
   1295   1.63       abs {
   1296  1.116   thorpej 	return sys_getuid(l, v, retval);
   1297   1.27      fvdl }
   1298   1.66       erh #endif
   1299   1.27      fvdl 
   1300   1.27      fvdl int
   1301  1.116   thorpej linux_sys_setresuid(l, v, retval)
   1302  1.116   thorpej 	struct lwp *l;
   1303   1.57   thorpej 	void *v;
   1304   1.57   thorpej 	register_t *retval;
   1305   1.57   thorpej {
   1306   1.57   thorpej 	struct linux_sys_setresuid_args /* {
   1307   1.57   thorpej 		syscallarg(uid_t) ruid;
   1308   1.57   thorpej 		syscallarg(uid_t) euid;
   1309   1.57   thorpej 		syscallarg(uid_t) suid;
   1310   1.57   thorpej 	} */ *uap = v;
   1311   1.57   thorpej 
   1312   1.57   thorpej 	/*
   1313   1.57   thorpej 	 * Note: These checks are a little different than the NetBSD
   1314   1.57   thorpej 	 * setreuid(2) call performs.  This precisely follows the
   1315   1.57   thorpej 	 * behavior of the Linux kernel.
   1316   1.57   thorpej 	 */
   1317   1.57   thorpej 
   1318  1.117       dsl 	return do_setresuid(l, SCARG(uap, ruid), SCARG(uap, euid),
   1319  1.117       dsl 			    SCARG(uap, suid),
   1320  1.117       dsl 			    ID_R_EQ_R | ID_R_EQ_E | ID_R_EQ_S |
   1321  1.117       dsl 			    ID_E_EQ_R | ID_E_EQ_E | ID_E_EQ_S |
   1322  1.117       dsl 			    ID_S_EQ_R | ID_S_EQ_E | ID_S_EQ_S );
   1323   1.57   thorpej }
   1324   1.57   thorpej 
   1325   1.57   thorpej int
   1326  1.116   thorpej linux_sys_getresuid(l, v, retval)
   1327  1.116   thorpej 	struct lwp *l;
   1328   1.57   thorpej 	void *v;
   1329   1.57   thorpej 	register_t *retval;
   1330   1.57   thorpej {
   1331   1.57   thorpej 	struct linux_sys_getresuid_args /* {
   1332   1.57   thorpej 		syscallarg(uid_t *) ruid;
   1333   1.57   thorpej 		syscallarg(uid_t *) euid;
   1334   1.57   thorpej 		syscallarg(uid_t *) suid;
   1335   1.57   thorpej 	} */ *uap = v;
   1336  1.116   thorpej 	struct proc *p = l->l_proc;
   1337   1.57   thorpej 	struct pcred *pc = p->p_cred;
   1338   1.57   thorpej 	int error;
   1339   1.57   thorpej 
   1340   1.57   thorpej 	/*
   1341   1.57   thorpej 	 * Linux copies these values out to userspace like so:
   1342   1.57   thorpej 	 *
   1343   1.57   thorpej 	 *	1. Copy out ruid.
   1344   1.57   thorpej 	 *	2. If that succeeds, copy out euid.
   1345   1.57   thorpej 	 *	3. If both of those succeed, copy out suid.
   1346   1.57   thorpej 	 */
   1347   1.57   thorpej 	if ((error = copyout(&pc->p_ruid, SCARG(uap, ruid),
   1348   1.57   thorpej 			     sizeof(uid_t))) != 0)
   1349   1.57   thorpej 		return (error);
   1350   1.57   thorpej 
   1351   1.57   thorpej 	if ((error = copyout(&pc->pc_ucred->cr_uid, SCARG(uap, euid),
   1352   1.57   thorpej 			     sizeof(uid_t))) != 0)
   1353   1.57   thorpej 		return (error);
   1354   1.57   thorpej 
   1355   1.57   thorpej 	return (copyout(&pc->p_svuid, SCARG(uap, suid), sizeof(uid_t)));
   1356   1.78      fvdl }
   1357   1.62      tron 
   1358   1.62      tron int
   1359  1.116   thorpej linux_sys_ptrace(l, v, retval)
   1360  1.116   thorpej 	struct lwp *l;
   1361   1.62      tron 	void *v;
   1362   1.62      tron 	register_t *retval;
   1363   1.62      tron {
   1364   1.62      tron 	struct linux_sys_ptrace_args /* {
   1365   1.88      manu 		i386, m68k, powerpc: T=int
   1366   1.66       erh 		alpha: T=long
   1367   1.66       erh 		syscallarg(T) request;
   1368   1.66       erh 		syscallarg(T) pid;
   1369   1.66       erh 		syscallarg(T) addr;
   1370   1.66       erh 		syscallarg(T) data;
   1371   1.62      tron 	} */ *uap = v;
   1372   1.73  jdolecek 	const int *ptr;
   1373   1.73  jdolecek 	int request;
   1374   1.89      manu 	int error;
   1375   1.62      tron 
   1376   1.62      tron 	ptr = linux_ptrace_request_map;
   1377   1.62      tron 	request = SCARG(uap, request);
   1378   1.62      tron 	while (*ptr != -1)
   1379   1.62      tron 		if (*ptr++ == request) {
   1380   1.62      tron 			struct sys_ptrace_args pta;
   1381   1.62      tron 
   1382   1.62      tron 			SCARG(&pta, req) = *ptr;
   1383   1.62      tron 			SCARG(&pta, pid) = SCARG(uap, pid);
   1384   1.62      tron 			SCARG(&pta, addr) = (caddr_t)SCARG(uap, addr);
   1385   1.62      tron 			SCARG(&pta, data) = SCARG(uap, data);
   1386   1.62      tron 
   1387   1.73  jdolecek 			/*
   1388   1.73  jdolecek 			 * Linux ptrace(PTRACE_CONT, pid, 0, 0) means actually
   1389   1.90  jdolecek 			 * to continue where the process left off previously.
   1390   1.90  jdolecek 			 * The same thing is achieved by addr == (caddr_t) 1
   1391   1.90  jdolecek 			 * on NetBSD, so rewrite 'addr' appropriately.
   1392   1.73  jdolecek 			 */
   1393   1.73  jdolecek 			if (request == LINUX_PTRACE_CONT && SCARG(uap, addr)==0)
   1394   1.73  jdolecek 				SCARG(&pta, addr) = (caddr_t) 1;
   1395   1.73  jdolecek 
   1396  1.116   thorpej 			error = sys_ptrace(l, &pta, retval);
   1397   1.92      manu 			if (error)
   1398   1.92      manu 				return error;
   1399   1.92      manu 			switch (request) {
   1400   1.92      manu 			case LINUX_PTRACE_PEEKTEXT:
   1401   1.92      manu 			case LINUX_PTRACE_PEEKDATA:
   1402   1.92      manu 				error = copyout (retval,
   1403   1.92      manu 				    (caddr_t)SCARG(uap, data), sizeof *retval);
   1404   1.92      manu 				*retval = SCARG(uap, data);
   1405   1.92      manu 				break;
   1406   1.92      manu 			default:
   1407   1.92      manu 				break;
   1408   1.92      manu 			}
   1409   1.89      manu 			return error;
   1410   1.62      tron 		}
   1411   1.62      tron 		else
   1412   1.62      tron 			ptr++;
   1413   1.62      tron 
   1414  1.116   thorpej 	return LINUX_SYS_PTRACE_ARCH(l, uap, retval);
   1415    1.1      fvdl }
   1416   1.67       erh 
   1417   1.67       erh int
   1418  1.116   thorpej linux_sys_reboot(struct lwp *l, void *v, register_t *retval)
   1419   1.67       erh {
   1420   1.67       erh 	struct linux_sys_reboot_args /* {
   1421   1.67       erh 		syscallarg(int) magic1;
   1422   1.67       erh 		syscallarg(int) magic2;
   1423   1.67       erh 		syscallarg(int) cmd;
   1424   1.67       erh 		syscallarg(void *) arg;
   1425   1.67       erh 	} */ *uap = v;
   1426   1.67       erh 	struct sys_reboot_args /* {
   1427   1.67       erh 		syscallarg(int) opt;
   1428   1.67       erh 		syscallarg(char *) bootstr;
   1429   1.67       erh 	} */ sra;
   1430  1.116   thorpej 	struct proc *p = l->l_proc;
   1431   1.67       erh 	int error;
   1432   1.67       erh 
   1433   1.67       erh 	if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
   1434   1.67       erh 		return(error);
   1435   1.67       erh 
   1436   1.67       erh 	if (SCARG(uap, magic1) != LINUX_REBOOT_MAGIC1)
   1437   1.67       erh 		return(EINVAL);
   1438   1.67       erh 	if (SCARG(uap, magic2) != LINUX_REBOOT_MAGIC2 &&
   1439   1.67       erh 	    SCARG(uap, magic2) != LINUX_REBOOT_MAGIC2A &&
   1440   1.67       erh 	    SCARG(uap, magic2) != LINUX_REBOOT_MAGIC2B)
   1441   1.67       erh 		return(EINVAL);
   1442   1.67       erh 
   1443   1.67       erh 	switch (SCARG(uap, cmd)) {
   1444   1.67       erh 	case LINUX_REBOOT_CMD_RESTART:
   1445   1.67       erh 		SCARG(&sra, opt) = RB_AUTOBOOT;
   1446   1.67       erh 		break;
   1447   1.67       erh 	case LINUX_REBOOT_CMD_HALT:
   1448   1.67       erh 		SCARG(&sra, opt) = RB_HALT;
   1449   1.67       erh 		break;
   1450   1.67       erh 	case LINUX_REBOOT_CMD_POWER_OFF:
   1451   1.67       erh 		SCARG(&sra, opt) = RB_HALT|RB_POWERDOWN;
   1452   1.67       erh 		break;
   1453   1.67       erh 	case LINUX_REBOOT_CMD_RESTART2:
   1454   1.67       erh 		/* Reboot with an argument. */
   1455   1.67       erh 		SCARG(&sra, opt) = RB_AUTOBOOT|RB_STRING;
   1456   1.67       erh 		SCARG(&sra, bootstr) = SCARG(uap, arg);
   1457   1.67       erh 		break;
   1458   1.67       erh 	case LINUX_REBOOT_CMD_CAD_ON:
   1459   1.67       erh 		return(EINVAL);	/* We don't implement ctrl-alt-delete */
   1460   1.67       erh 	case LINUX_REBOOT_CMD_CAD_OFF:
   1461   1.67       erh 		return(0);
   1462   1.67       erh 	default:
   1463   1.67       erh 		return(EINVAL);
   1464   1.67       erh 	}
   1465   1.67       erh 
   1466  1.116   thorpej 	return(sys_reboot(l, &sra, retval));
   1467   1.75  jdolecek }
   1468   1.75  jdolecek 
   1469   1.75  jdolecek /*
   1470   1.75  jdolecek  * Copy of compat_12_sys_swapon().
   1471   1.75  jdolecek  */
   1472   1.75  jdolecek int
   1473  1.116   thorpej linux_sys_swapon(l, v, retval)
   1474  1.116   thorpej 	struct lwp *l;
   1475   1.75  jdolecek 	void *v;
   1476   1.75  jdolecek 	register_t *retval;
   1477   1.75  jdolecek {
   1478   1.75  jdolecek 	struct sys_swapctl_args ua;
   1479   1.75  jdolecek 	struct linux_sys_swapon_args /* {
   1480   1.75  jdolecek 		syscallarg(const char *) name;
   1481   1.75  jdolecek 	} */ *uap = v;
   1482   1.75  jdolecek 
   1483   1.75  jdolecek 	SCARG(&ua, cmd) = SWAP_ON;
   1484   1.75  jdolecek 	SCARG(&ua, arg) = (void *)SCARG(uap, name);
   1485   1.75  jdolecek 	SCARG(&ua, misc) = 0;	/* priority */
   1486  1.116   thorpej 	return (sys_swapctl(l, &ua, retval));
   1487   1.76  jdolecek }
   1488   1.76  jdolecek 
   1489   1.76  jdolecek /*
   1490   1.76  jdolecek  * Stop swapping to the file or block device specified by path.
   1491   1.76  jdolecek  */
   1492   1.76  jdolecek int
   1493  1.116   thorpej linux_sys_swapoff(l, v, retval)
   1494  1.116   thorpej 	struct lwp *l;
   1495   1.76  jdolecek 	void *v;
   1496   1.76  jdolecek 	register_t *retval;
   1497   1.76  jdolecek {
   1498   1.76  jdolecek 	struct sys_swapctl_args ua;
   1499   1.76  jdolecek 	struct linux_sys_swapoff_args /* {
   1500   1.76  jdolecek 		syscallarg(const char *) path;
   1501   1.76  jdolecek 	} */ *uap = v;
   1502   1.76  jdolecek 
   1503   1.76  jdolecek 	SCARG(&ua, cmd) = SWAP_OFF;
   1504   1.76  jdolecek 	SCARG(&ua, arg) = (void *)SCARG(uap, path);
   1505  1.116   thorpej 	return (sys_swapctl(l, &ua, retval));
   1506   1.75  jdolecek }
   1507   1.75  jdolecek 
   1508   1.75  jdolecek /*
   1509   1.75  jdolecek  * Copy of compat_09_sys_setdomainname()
   1510   1.75  jdolecek  */
   1511   1.75  jdolecek /* ARGSUSED */
   1512   1.75  jdolecek int
   1513  1.116   thorpej linux_sys_setdomainname(l, v, retval)
   1514  1.116   thorpej 	struct lwp *l;
   1515   1.75  jdolecek 	void *v;
   1516   1.75  jdolecek 	register_t *retval;
   1517   1.75  jdolecek {
   1518   1.75  jdolecek 	struct linux_sys_setdomainname_args /* {
   1519   1.75  jdolecek 		syscallarg(char *) domainname;
   1520   1.75  jdolecek 		syscallarg(int) len;
   1521   1.75  jdolecek 	} */ *uap = v;
   1522  1.122    atatat 	int name[2];
   1523   1.75  jdolecek 
   1524  1.122    atatat 	name[0] = CTL_KERN;
   1525  1.122    atatat 	name[1] = KERN_DOMAINNAME;
   1526  1.122    atatat 	return (old_sysctl(&name[0], 2, 0, 0, SCARG(uap, domainname),
   1527  1.122    atatat 			    SCARG(uap, len), l));
   1528   1.77  augustss }
   1529   1.77  augustss 
   1530   1.77  augustss /*
   1531   1.77  augustss  * sysinfo()
   1532   1.77  augustss  */
   1533   1.77  augustss /* ARGSUSED */
   1534   1.77  augustss int
   1535  1.116   thorpej linux_sys_sysinfo(l, v, retval)
   1536  1.116   thorpej 	struct lwp *l;
   1537   1.77  augustss 	void *v;
   1538   1.77  augustss 	register_t *retval;
   1539   1.77  augustss {
   1540   1.77  augustss 	struct linux_sys_sysinfo_args /* {
   1541   1.77  augustss 		syscallarg(struct linux_sysinfo *) arg;
   1542   1.77  augustss 	} */ *uap = v;
   1543   1.77  augustss 	struct linux_sysinfo si;
   1544   1.77  augustss 	struct loadavg *la;
   1545   1.77  augustss 
   1546   1.77  augustss 	si.uptime = time.tv_sec - boottime.tv_sec;
   1547   1.77  augustss 	la = &averunnable;
   1548   1.77  augustss 	si.loads[0] = la->ldavg[0] * LINUX_SYSINFO_LOADS_SCALE / la->fscale;
   1549   1.77  augustss 	si.loads[1] = la->ldavg[1] * LINUX_SYSINFO_LOADS_SCALE / la->fscale;
   1550   1.77  augustss 	si.loads[2] = la->ldavg[2] * LINUX_SYSINFO_LOADS_SCALE / la->fscale;
   1551   1.77  augustss 	si.totalram = ctob(physmem);
   1552   1.77  augustss 	si.freeram = uvmexp.free * uvmexp.pagesize;
   1553   1.77  augustss 	si.sharedram = 0;	/* XXX */
   1554   1.96       chs 	si.bufferram = uvmexp.filepages * uvmexp.pagesize;
   1555   1.77  augustss 	si.totalswap = uvmexp.swpages * uvmexp.pagesize;
   1556   1.77  augustss 	si.freeswap = (uvmexp.swpages - uvmexp.swpginuse) * uvmexp.pagesize;
   1557   1.77  augustss 	si.procs = nprocs;
   1558   1.77  augustss 
   1559   1.77  augustss 	/* The following are only present in newer Linux kernels. */
   1560   1.77  augustss 	si.totalbig = 0;
   1561   1.77  augustss 	si.freebig = 0;
   1562   1.77  augustss 	si.mem_unit = 1;
   1563   1.77  augustss 
   1564   1.77  augustss 	return (copyout(&si, SCARG(uap, arg), sizeof si));
   1565   1.97  christos }
   1566   1.97  christos 
   1567   1.97  christos #define bsd_to_linux_rlimit1(l, b, f) \
   1568  1.114   thorpej     (l)->f = ((b)->f == RLIM_INFINITY || \
   1569  1.114   thorpej 	     ((b)->f & 0xffffffff00000000ULL) != 0) ? \
   1570   1.97  christos     LINUX_RLIM_INFINITY : (int32_t)(b)->f
   1571   1.97  christos #define bsd_to_linux_rlimit(l, b) \
   1572   1.97  christos     bsd_to_linux_rlimit1(l, b, rlim_cur); \
   1573   1.97  christos     bsd_to_linux_rlimit1(l, b, rlim_max)
   1574   1.97  christos 
   1575   1.97  christos #define linux_to_bsd_rlimit1(b, l, f) \
   1576  1.110     enami     (b)->f = (l)->f == LINUX_RLIM_INFINITY ? RLIM_INFINITY : (l)->f
   1577   1.97  christos #define linux_to_bsd_rlimit(b, l) \
   1578   1.97  christos     linux_to_bsd_rlimit1(b, l, rlim_cur); \
   1579   1.97  christos     linux_to_bsd_rlimit1(b, l, rlim_max)
   1580   1.97  christos 
   1581   1.97  christos static int
   1582   1.97  christos linux_to_bsd_limit(lim)
   1583   1.97  christos 	int lim;
   1584   1.97  christos {
   1585   1.97  christos 	switch (lim) {
   1586   1.97  christos 	case LINUX_RLIMIT_CPU:
   1587   1.97  christos 		return RLIMIT_CPU;
   1588   1.97  christos 	case LINUX_RLIMIT_FSIZE:
   1589   1.97  christos 		return RLIMIT_FSIZE;
   1590   1.97  christos 	case LINUX_RLIMIT_DATA:
   1591   1.97  christos 		return RLIMIT_DATA;
   1592   1.97  christos 	case LINUX_RLIMIT_STACK:
   1593   1.97  christos 		return RLIMIT_STACK;
   1594   1.97  christos 	case LINUX_RLIMIT_CORE:
   1595   1.97  christos 		return RLIMIT_CORE;
   1596   1.97  christos 	case LINUX_RLIMIT_RSS:
   1597   1.97  christos 		return RLIMIT_RSS;
   1598   1.97  christos 	case LINUX_RLIMIT_NPROC:
   1599   1.97  christos 		return RLIMIT_NPROC;
   1600   1.97  christos 	case LINUX_RLIMIT_NOFILE:
   1601   1.97  christos 		return RLIMIT_NOFILE;
   1602   1.97  christos 	case LINUX_RLIMIT_MEMLOCK:
   1603   1.97  christos 		return RLIMIT_MEMLOCK;
   1604   1.97  christos 	case LINUX_RLIMIT_AS:
   1605   1.97  christos 	case LINUX_RLIMIT_LOCKS:
   1606   1.97  christos 		return -EOPNOTSUPP;
   1607   1.97  christos 	default:
   1608   1.97  christos 		return -EINVAL;
   1609   1.97  christos 	}
   1610   1.97  christos }
   1611   1.97  christos 
   1612   1.97  christos 
   1613   1.97  christos int
   1614  1.116   thorpej linux_sys_getrlimit(l, v, retval)
   1615  1.116   thorpej 	struct lwp *l;
   1616   1.97  christos 	void *v;
   1617   1.97  christos 	register_t *retval;
   1618   1.97  christos {
   1619   1.97  christos 	struct linux_sys_getrlimit_args /* {
   1620   1.97  christos 		syscallarg(int) which;
   1621   1.97  christos 		syscallarg(struct orlimit *) rlp;
   1622   1.97  christos 	} */ *uap = v;
   1623  1.116   thorpej 	struct proc *p = l->l_proc;
   1624  1.102  christos 	caddr_t sg = stackgap_init(p, 0);
   1625   1.97  christos 	struct sys_getrlimit_args ap;
   1626   1.97  christos 	struct rlimit rl;
   1627   1.97  christos 	struct orlimit orl;
   1628   1.97  christos 	int error;
   1629   1.97  christos 
   1630   1.97  christos 	SCARG(&ap, which) = linux_to_bsd_limit(SCARG(uap, which));
   1631   1.97  christos 	if ((error = SCARG(&ap, which)) < 0)
   1632   1.97  christos 		return -error;
   1633  1.102  christos 	SCARG(&ap, rlp) = stackgap_alloc(p, &sg, sizeof rl);
   1634  1.116   thorpej 	if ((error = sys_getrlimit(l, &ap, retval)) != 0)
   1635   1.97  christos 		return error;
   1636   1.97  christos 	if ((error = copyin(SCARG(&ap, rlp), &rl, sizeof(rl))) != 0)
   1637   1.97  christos 		return error;
   1638   1.97  christos 	bsd_to_linux_rlimit(&orl, &rl);
   1639   1.97  christos 	return copyout(&orl, SCARG(uap, rlp), sizeof(orl));
   1640   1.97  christos }
   1641   1.97  christos 
   1642   1.97  christos int
   1643  1.116   thorpej linux_sys_setrlimit(l, v, retval)
   1644  1.116   thorpej 	struct lwp *l;
   1645   1.97  christos 	void *v;
   1646   1.97  christos 	register_t *retval;
   1647   1.97  christos {
   1648   1.97  christos 	struct linux_sys_setrlimit_args /* {
   1649   1.97  christos 		syscallarg(int) which;
   1650   1.97  christos 		syscallarg(struct orlimit *) rlp;
   1651   1.97  christos 	} */ *uap = v;
   1652  1.116   thorpej 	struct proc *p = l->l_proc;
   1653  1.102  christos 	caddr_t sg = stackgap_init(p, 0);
   1654   1.97  christos 	struct sys_setrlimit_args ap;
   1655   1.97  christos 	struct rlimit rl;
   1656   1.97  christos 	struct orlimit orl;
   1657   1.97  christos 	int error;
   1658   1.97  christos 
   1659   1.97  christos 	SCARG(&ap, which) = linux_to_bsd_limit(SCARG(uap, which));
   1660  1.102  christos 	SCARG(&ap, rlp) = stackgap_alloc(p, &sg, sizeof rl);
   1661   1.97  christos 	if ((error = SCARG(&ap, which)) < 0)
   1662   1.97  christos 		return -error;
   1663   1.97  christos 	if ((error = copyin(SCARG(uap, rlp), &orl, sizeof(orl))) != 0)
   1664   1.97  christos 		return error;
   1665   1.97  christos 	linux_to_bsd_rlimit(&rl, &orl);
   1666  1.100  christos 	/* XXX: alpha complains about this */
   1667  1.100  christos 	if ((error = copyout(&rl, (void *)SCARG(&ap, rlp), sizeof(rl))) != 0)
   1668   1.97  christos 		return error;
   1669  1.116   thorpej 	return sys_setrlimit(l, &ap, retval);
   1670   1.97  christos }
   1671   1.97  christos 
   1672   1.98     rafal #ifndef __mips__
   1673   1.98     rafal /* XXX: this doesn't look 100% common, at least mips doesn't have it */
   1674   1.97  christos int
   1675  1.116   thorpej linux_sys_ugetrlimit(l, v, retval)
   1676  1.116   thorpej 	struct lwp *l;
   1677   1.97  christos 	void *v;
   1678   1.97  christos 	register_t *retval;
   1679   1.97  christos {
   1680  1.116   thorpej 	return linux_sys_getrlimit(l, v, retval);
   1681   1.87  jdolecek }
   1682   1.98     rafal #endif
   1683   1.87  jdolecek 
   1684   1.87  jdolecek /*
   1685   1.87  jdolecek  * This gets called for unsupported syscalls. The difference to sys_nosys()
   1686   1.87  jdolecek  * is that process does not get SIGSYS, the call just returns with ENOSYS.
   1687   1.87  jdolecek  * This is the way Linux does it and glibc depends on this behaviour.
   1688   1.87  jdolecek  */
   1689   1.87  jdolecek int
   1690  1.116   thorpej linux_sys_nosys(l, v, retval)
   1691  1.116   thorpej 	struct lwp *l;
   1692   1.87  jdolecek 	void *v;
   1693   1.87  jdolecek 	register_t *retval;
   1694   1.87  jdolecek {
   1695   1.87  jdolecek 	return (ENOSYS);
   1696   1.67       erh }
   1697