Home | History | Annotate | Line # | Download | only in ultrix
ultrix_misc.c revision 1.115
      1 /*	$NetBSD: ultrix_misc.c,v 1.115 2008/08/08 16:21:44 bjs Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1995, 1997 Jonathan Stone (hereinafter referred to as the author)
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *      This product includes software developed by Jonathan Stone for
     18  *      the NetBSD Project.
     19  * 4. The name of the author may not be used to endorse or promote products
     20  *    derived from this software without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  */
     34 
     35 /*
     36  * Copyright (c) 1992, 1993
     37  *	The Regents of the University of California.  All rights reserved.
     38  *
     39  * This software was developed by the Computer Systems Engineering group
     40  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
     41  * contributed to Berkeley.
     42  *
     43  * All advertising materials mentioning features or use of this software
     44  * must display the following acknowledgement:
     45  *	This product includes software developed by the University of
     46  *	California, Lawrence Berkeley Laboratory.
     47  *
     48  * Redistribution and use in source and binary forms, with or without
     49  * modification, are permitted provided that the following conditions
     50  * are met:
     51  * 1. Redistributions of source code must retain the above copyright
     52  *    notice, this list of conditions and the following disclaimer.
     53  * 2. Redistributions in binary form must reproduce the above copyright
     54  *    notice, this list of conditions and the following disclaimer in the
     55  *    documentation and/or other materials provided with the distribution.
     56  * 3. Neither the name of the University nor the names of its contributors
     57  *    may be used to endorse or promote products derived from this software
     58  *    without specific prior written permission.
     59  *
     60  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     61  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     62  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     63  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     64  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     65  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     66  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     67  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     68  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     69  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     70  * SUCH DAMAGE.
     71  *
     72  *
     73  *	@(#)sun_misc.c	8.1 (Berkeley) 6/18/93
     74  *
     75  * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
     76  */
     77 
     78 #include <sys/cdefs.h>
     79 __KERNEL_RCSID(0, "$NetBSD: ultrix_misc.c,v 1.115 2008/08/08 16:21:44 bjs Exp $");
     80 
     81 #if defined(_KERNEL_OPT)
     82 #include "opt_nfsserver.h"
     83 #include "opt_sysv.h"
     84 #endif
     85 
     86 #include <sys/cdefs.h>			/* RCS ID & Copyright macro defns */
     87 
     88 /*
     89  * Ultrix compatibility module.
     90  *
     91  * Ultrix system calls that are implemented differently in BSD are
     92  * handled here.
     93  */
     94 
     95 #if defined(_KERNEL_OPT)
     96 #include "fs_nfs.h"
     97 #endif
     98 
     99 #include <sys/param.h>
    100 #include <sys/systm.h>
    101 #include <sys/namei.h>
    102 #include <sys/dirent.h>
    103 #include <sys/proc.h>
    104 #include <sys/file.h>
    105 #include <sys/filedesc.h>
    106 #include <sys/kernel.h>
    107 #include <sys/exec.h>
    108 #include <sys/malloc.h>
    109 #include <sys/mbuf.h>
    110 #include <sys/mman.h>
    111 #include <sys/mount.h>
    112 #include <sys/resource.h>
    113 #include <sys/resourcevar.h>
    114 #include <sys/signal.h>
    115 #include <sys/signalvar.h>
    116 #include <sys/socket.h>
    117 #include <sys/vnode.h>
    118 #include <sys/uio.h>
    119 #include <sys/wait.h>
    120 #include <sys/utsname.h>
    121 #include <sys/unistd.h>
    122 #include <sys/ipc.h>
    123 
    124 #include <sys/syscallargs.h>
    125 
    126 #include <uvm/uvm_extern.h>
    127 
    128 #include <compat/ultrix/ultrix_syscall.h>
    129 #include <compat/ultrix/ultrix_syscallargs.h>
    130 #include <compat/common/compat_util.h>
    131 
    132 #include <netinet/in.h>
    133 
    134 #include <miscfs/specfs/specdev.h>
    135 
    136 #include <nfs/rpcv2.h>
    137 #include <nfs/nfsproto.h>
    138 #include <nfs/nfs.h>
    139 
    140 #include <sys/socketvar.h>				/* sosetopt() */
    141 
    142 #include <compat/ultrix/ultrix_flock.h>
    143 
    144 #include <compat/sys/signal.h>
    145 #include <compat/sys/signalvar.h>
    146 
    147 #ifdef __mips
    148 #include <mips/cachectl.h>
    149 #include <mips/frame.h>
    150 #endif
    151 
    152 static int ultrix_to_bsd_flock(struct ultrix_flock *, struct flock *);
    153 static void bsd_to_ultrix_flock(struct flock *, struct ultrix_flock *);
    154 
    155 extern struct sysent ultrix_sysent[];
    156 extern const char * const ultrix_syscallnames[];
    157 extern char ultrix_sigcode[], ultrix_esigcode[];
    158 
    159 struct uvm_object *emul_ultrix_object;
    160 
    161 #ifndef __HAVE_SYSCALL_INTERN
    162 void	syscall(void);
    163 #endif
    164 
    165 const struct emul emul_ultrix = {
    166 	"ultrix",
    167 	"/emul/ultrix",
    168 #ifndef __HAVE_MINIMAL_EMUL
    169 	0,
    170 	NULL,
    171 	ULTRIX_SYS_syscall,
    172 	ULTRIX_SYS_NSYSENT,
    173 #endif
    174 	ultrix_sysent,
    175 	ultrix_syscallnames,
    176 #ifdef __mips
    177 	sendsig_sigcontext,
    178 #else /* vax */
    179 	sendsig,
    180 #endif
    181 	trapsignal,
    182 	NULL,
    183 	ultrix_sigcode,
    184 	ultrix_esigcode,
    185 	&emul_ultrix_object,
    186 	setregs,
    187 	NULL,
    188 	NULL,
    189 	NULL,
    190 	NULL,
    191 	NULL,
    192 #ifdef __HAVE_SYSCALL_INTERN
    193 	syscall_intern,
    194 #else
    195 	syscall,
    196 #endif
    197 	NULL,
    198 	NULL,
    199 
    200 	uvm_default_mapaddr,
    201 	NULL,
    202 	0,
    203 	NULL
    204 };
    205 
    206 #define GSI_PROG_ENV 1
    207 
    208 int
    209 ultrix_sys_getsysinfo(struct lwp *l, const struct ultrix_sys_getsysinfo_args *uap, register_t *retval)
    210 {
    211 	static short progenv = 0;
    212 
    213 	switch (SCARG(uap, op)) {
    214 		/* operations implemented: */
    215 	case GSI_PROG_ENV:
    216 		if (SCARG(uap, nbytes) < sizeof(short))
    217 			return EINVAL;
    218 		*retval = 1;
    219 		return copyout(&progenv, SCARG(uap, buffer), sizeof(progenv));
    220 	default:
    221 		*retval = 0; /* info unavail */
    222 		return 0;
    223 	}
    224 }
    225 
    226 int
    227 ultrix_sys_setsysinfo(struct lwp *l, const struct ultrix_sys_setsysinfo_args *uap, register_t *retval)
    228 {
    229 
    230 	*retval = 0;
    231 	return 0;
    232 }
    233 
    234 int
    235 ultrix_sys_waitpid(struct lwp *l, const struct ultrix_sys_waitpid_args *uap, register_t *retval)
    236 {
    237 	struct sys_wait4_args ap;
    238 
    239 	SCARG(&ap, pid) = SCARG(uap, pid);
    240 	SCARG(&ap, status) = SCARG(uap, status);
    241 	SCARG(&ap, options) = SCARG(uap, options);
    242 	SCARG(&ap, rusage) = 0;
    243 
    244 	return sys_wait4(l, &ap, retval);
    245 }
    246 
    247 int
    248 ultrix_sys_wait3(struct lwp *l, const struct ultrix_sys_wait3_args *uap, register_t *retval)
    249 {
    250 	struct sys_wait4_args ap;
    251 
    252 	SCARG(&ap, pid) = -1;
    253 	SCARG(&ap, status) = SCARG(uap, status);
    254 	SCARG(&ap, options) = SCARG(uap, options);
    255 	SCARG(&ap, rusage) = SCARG(uap, rusage);
    256 
    257 	return sys_wait4(l, &ap, retval);
    258 }
    259 
    260 /*
    261  * Ultrix binaries pass in FD_MAX as the first arg to select().
    262  * On Ultrix, FD_MAX is 4096, which is more than the NetBSD sys_select()
    263  * can handle.
    264  * Since we can't have more than the (native) FD_MAX descriptors open,
    265  * limit nfds to at most FD_MAX.
    266  */
    267 int
    268 ultrix_sys_select(struct lwp *l, const struct ultrix_sys_select_args *uap, register_t *retval)
    269 {
    270 	struct timeval atv;
    271 	int error;
    272 	struct sys_select_args ap;
    273 
    274 	/* Limit number of FDs selected on to the native maximum */
    275 
    276 	if (SCARG(uap, nd) > FD_SETSIZE)
    277 		SCARG(&ap, nd) = FD_SETSIZE;
    278 	else
    279 		SCARG(&ap, nd) = SCARG(uap, nd);
    280 
    281 	SCARG(&ap, in) = SCARG(uap, in);
    282 	SCARG(&ap, ou) = SCARG(uap, ou);
    283 	SCARG(&ap, ex) = SCARG(uap, ex);
    284 	SCARG(&ap, tv) = SCARG(uap, tv);
    285 	/* Check for negative timeval */
    286 	if (SCARG(&ap, tv)) {
    287 		error = copyin(SCARG(uap, tv), &atv, sizeof(atv));
    288 		if (error)
    289 			goto done;
    290 #ifdef DEBUG
    291 		/* Ultrix clients sometimes give negative timeouts? */
    292 		if (atv.tv_sec < 0 || atv.tv_usec < 0)
    293 			printf("ultrix select( %ld, %ld): negative timeout\n",
    294 			    atv.tv_sec, atv.tv_usec);
    295 #endif
    296 
    297 	}
    298 	error = sys_select(l, &ap, retval);
    299 	if (error == EINVAL)
    300 		printf("ultrix select: bad args?\n");
    301 
    302 done:
    303 	return error;
    304 }
    305 
    306 #if defined(NFS)
    307 int
    308 async_daemon(struct lwp *l, const void *v, register_t *retval)
    309 {
    310 	struct sys_nfssvc_args ouap;
    311 
    312 	SCARG(&ouap, flag) = NFSSVC_BIOD;
    313 	SCARG(&ouap, argp) = NULL;
    314 
    315 	return sys_nfssvc(l, &ouap, retval);
    316 }
    317 #endif /* NFS */
    318 
    319 
    320 #define	SUN__MAP_NEW	0x80000000	/* if not, old mmap & cannot handle */
    321 
    322 int
    323 ultrix_sys_mmap(struct lwp *l, const struct ultrix_sys_mmap_args *uap, register_t *retval)
    324 {
    325 	struct sys_mmap_args ouap;
    326 
    327 	/*
    328 	 * Verify the arguments.
    329 	 */
    330 	if (SCARG(uap, prot) & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
    331 		return EINVAL;			/* XXX still needed? */
    332 
    333 	if ((SCARG(uap, flags) & SUN__MAP_NEW) == 0)
    334 		return EINVAL;
    335 
    336 	SCARG(&ouap, flags) = SCARG(uap, flags) & ~SUN__MAP_NEW;
    337 	SCARG(&ouap, addr) = SCARG(uap, addr);
    338 	SCARG(&ouap, len) = SCARG(uap, len);
    339 	SCARG(&ouap, prot) = SCARG(uap, prot);
    340 	SCARG(&ouap, fd) = SCARG(uap, fd);
    341 	SCARG(&ouap, pos) = SCARG(uap, pos);
    342 
    343 	return sys_mmap(l, &ouap, retval);
    344 }
    345 
    346 int
    347 ultrix_sys_setsockopt(struct lwp *l, const struct ultrix_sys_setsockopt_args *uap, register_t *retval)
    348 {
    349 	struct sockopt sopt;
    350 	struct socket *so;
    351 	int error;
    352 	struct sys_setsockopt_args ap;
    353 
    354 	SCARG(&ap, s) = SCARG(uap, s);
    355 	SCARG(&ap, level) = SCARG(uap, level);
    356 	SCARG(&ap, name) = SCARG(uap, name);
    357 	SCARG(&ap, val) = SCARG(uap, val);
    358 	SCARG(&ap, valsize) = SCARG(uap, valsize);
    359 
    360 	/* fd_getsock() will use the descriptor for us */
    361 	if ((error = fd_getsock(SCARG(&ap, s), &so))  != 0)
    362 		return error;
    363 #define	SO_DONTLINGER (~SO_LINGER)
    364 	if (SCARG(&ap, name) == SO_DONTLINGER) {
    365 		struct linger lg;
    366 
    367 		lg.l_onoff = 0;
    368 		error = so_setsockopt(l, so, SCARG(&ap, level), SO_LINGER,
    369 		    &lg, sizeof(lg));
    370 		goto out;
    371 	}
    372 	if (SCARG(&ap, level) == IPPROTO_IP) {
    373 #define		EMUL_IP_MULTICAST_IF		2
    374 #define		EMUL_IP_MULTICAST_TTL		3
    375 #define		EMUL_IP_MULTICAST_LOOP		4
    376 #define		EMUL_IP_ADD_MEMBERSHIP		5
    377 #define		EMUL_IP_DROP_MEMBERSHIP	6
    378 		static const int ipoptxlat[] = {
    379 			IP_MULTICAST_IF,
    380 			IP_MULTICAST_TTL,
    381 			IP_MULTICAST_LOOP,
    382 			IP_ADD_MEMBERSHIP,
    383 			IP_DROP_MEMBERSHIP
    384 		};
    385 		if (SCARG(&ap, name) >= EMUL_IP_MULTICAST_IF &&
    386 		    SCARG(&ap, name) <= EMUL_IP_DROP_MEMBERSHIP) {
    387 			SCARG(&ap, name) =
    388 			    ipoptxlat[SCARG(&ap, name) - EMUL_IP_MULTICAST_IF];
    389 		}
    390 	}
    391 	if (SCARG(&ap, valsize) > MLEN) {
    392 		error = EINVAL;
    393 		goto out;
    394 	}
    395 	sockopt_init(&sopt, SCARG(&ap, level), SCARG(&ap, name),
    396 	    SCARG(&ap, valsize));
    397 	if (SCARG(&ap, val)) {
    398 		error = copyin(SCARG(&ap, val), sopt.sopt_data,
    399 		    (u_int)SCARG(&ap, valsize));
    400 	}
    401 	if (error == 0)
    402 		error = sosetopt(so, &sopt);
    403 	sockopt_destroy(&sopt);
    404  out:
    405  	fd_putfile(SCARG(uap, s));
    406 	return error;
    407 }
    408 
    409 #define	ULTRIX__SYS_NMLN	32
    410 
    411 struct ultrix_utsname {
    412 	char    sysname[ULTRIX__SYS_NMLN];
    413 	char    nodename[ULTRIX__SYS_NMLN];
    414 	char    release[ULTRIX__SYS_NMLN];
    415 	char    version[ULTRIX__SYS_NMLN];
    416 	char    machine[ULTRIX__SYS_NMLN];
    417 };
    418 
    419 int
    420 ultrix_sys_uname(struct lwp *l, const struct ultrix_sys_uname_args *uap, register_t *retval)
    421 {
    422 	struct ultrix_utsname sut;
    423 	const char *cp;
    424 	char *dp, *ep;
    425 
    426 	memset(&sut, 0, sizeof(sut));
    427 
    428 	strncpy(sut.sysname, ostype, sizeof(sut.sysname) - 1);
    429 	strncpy(sut.nodename, hostname, sizeof(sut.nodename) - 1);
    430 	strncpy(sut.release, osrelease, sizeof(sut.release) - 1);
    431 	dp = sut.version;
    432 	ep = &sut.version[sizeof(sut.version) - 1];
    433 	for (cp = version; *cp && *cp != '('; cp++)
    434 		;
    435 	for (cp++; *cp && *cp != ')' && dp < ep; cp++)
    436 		*dp++ = *cp;
    437 	for (; *cp && *cp != '#'; cp++)
    438 		;
    439 	for (; *cp && *cp != ':' && dp < ep; cp++)
    440 		*dp++ = *cp;
    441 	*dp = '\0';
    442 	strncpy(sut.machine, machine, sizeof(sut.machine) - 1);
    443 
    444 	return copyout(&sut, SCARG(uap, name), sizeof(sut));
    445 }
    446 
    447 int
    448 ultrix_sys_setpgrp(struct lwp *l, const struct ultrix_sys_setpgrp_args *uap, register_t *retval)
    449 {
    450 	struct proc *p = l->l_proc;
    451 	struct sys_setpgid_args ap;
    452 
    453 	SCARG(&ap, pid) = SCARG(uap, pid);
    454 	SCARG(&ap, pgid) = SCARG(uap, pgid);
    455 	/*
    456 	 * difference to our setpgid call is to include backwards
    457 	 * compatibility to pre-setsid() binaries. Do setsid()
    458 	 * instead of setpgid() in those cases where the process
    459 	 * tries to create a new session the old way.
    460 	 */
    461 	if (!SCARG(&ap, pgid) &&
    462 	    (!SCARG(&ap, pid) || SCARG(&ap, pid) == p->p_pid))
    463 		return sys_setsid(l, &ap, retval);
    464 	else
    465 		return sys_setpgid(l, &ap, retval);
    466 }
    467 
    468 #if defined (NFSSERVER)
    469 int
    470 ultrix_sys_nfssvc(struct lwp *l, const struct ultrix_sys_nfssvc_args *uap,
    471     register_t *retval)
    472 {
    473 
    474 #if 0	/* XXX */
    475 	struct emul *e = p->p_emul;
    476 	struct sys_nfssvc_args outuap;
    477 	struct sockaddr sa;
    478 	int error;
    479 	void *sg = stackgap_init(p, 0);
    480 
    481 	memset(&outuap, 0, sizeof outuap);
    482 	SCARG(&outuap, fd) = SCARG(uap, fd);
    483 	SCARG(&outuap, mskval) = stackgap_alloc(p, &sg, sizeof sa);
    484 	SCARG(&outuap, msklen) = sizeof sa;
    485 	SCARG(&outuap, mtchval) = stackgap_alloc(p, &sg, sizeof sa);
    486 	SCARG(&outuap, mtchlen) = sizeof sa;
    487 
    488 	memset(&sa, 0, sizeof sa);
    489 	if (error = copyout(&sa, SCARG(&outuap, mskval), SCARG(&outuap, msklen)))
    490 		return error;
    491 	if (error = copyout(&sa, SCARG(&outuap, mtchval), SCARG(&outuap, mtchlen)))
    492 		return error;
    493 
    494 	return nfssvc(l, &outuap, retval);
    495 #else
    496 	return ENOSYS;
    497 #endif
    498 }
    499 #endif /* NFSSERVER */
    500 
    501 struct ultrix_ustat {
    502 	daddr_t	f_tfree;	/* total free */
    503 	uint32_t f_tinode;	/* total inodes free */
    504 	char	f_fname[6];	/* filsys name */
    505 	char	f_fpack[6];	/* filsys pack name */
    506 };
    507 
    508 int
    509 ultrix_sys_ustat(struct lwp *l, const struct ultrix_sys_ustat_args *uap, register_t *retval)
    510 {
    511 	struct ultrix_ustat us;
    512 	int error;
    513 
    514 	memset(&us, 0, sizeof us);
    515 
    516 	/*
    517 	 * XXX: should set f_tfree and f_tinode at least
    518 	 * How do we translate dev -> fstat? (and then to ultrix_ustat)
    519 	 */
    520 
    521 	if ((error = copyout(&us, SCARG(uap, buf), sizeof us)) != 0)
    522 		return error;
    523 	return 0;
    524 }
    525 
    526 int
    527 ultrix_sys_quotactl(struct lwp *l, const struct ultrix_sys_quotactl_args *uap, register_t *retval)
    528 {
    529 
    530 	return EINVAL;
    531 }
    532 
    533 int
    534 ultrix_sys_vhangup(struct lwp *l, const void *uap, register_t *retval)
    535 {
    536 
    537 	return 0;
    538 }
    539 
    540 
    541 /*
    542  * RISC Ultrix cache control syscalls
    543  */
    544 #ifdef __mips
    545 int
    546 ultrix_sys_cacheflush(struct lwp *l, const struct ultrix_sys_cacheflush_args *uap, register_t *retval)
    547 {
    548 	/* {
    549 		syscallarg(void *) addr;
    550 		syscallarg(unsigned) nbytes;
    551 		syscallarg(int) flag;
    552 	} */
    553 	struct proc *p = l->l_proc;
    554 	vaddr_t va  = (vaddr_t)SCARG(uap, addr);
    555 	int nbytes     = SCARG(uap, nbytes);
    556 	int whichcache = SCARG(uap, whichcache);
    557 
    558 	return mips_user_cacheflush(p, va, nbytes, whichcache);
    559 }
    560 
    561 
    562 int
    563 ultrix_sys_cachectl(struct lwp *l, const struct ultrix_sys_cachectl_args *uap, register_t *retval)
    564 {
    565 	/* {
    566 		syscallarg(void *) addr;
    567 		syscallarg(int) nbytes;
    568 		syscallarg(int) cacheop;
    569 	} */
    570 	struct proc *p = l->l_proc;
    571 	vaddr_t va  = (vaddr_t)SCARG(uap, addr);
    572 	int nbytes  = SCARG(uap, nbytes);
    573 	int cacheop = SCARG(uap, cacheop);
    574 
    575 	return mips_user_cachectl(p, va, nbytes, cacheop);
    576 }
    577 
    578 #endif	/* __mips */
    579 
    580 
    581 int
    582 ultrix_sys_exportfs(struct lwp *l, const struct ultrix_sys_exportfs_args *uap, register_t *retval)
    583 {
    584 
    585 	/*
    586 	 * XXX: should perhaps translate into a mount(2)
    587 	 * with MOUNT_EXPORT?
    588 	 */
    589 	return 0;
    590 }
    591 
    592 int
    593 ultrix_sys_sigpending(struct lwp *l, const struct ultrix_sys_sigpending_args *uap, register_t *retval)
    594 {
    595 	sigset_t ss;
    596 	int mask;
    597 
    598 	sigpending1(l, &ss);
    599 	mask = ss.__bits[0];
    600 
    601 	return copyout(&mask, SCARG(uap, mask), sizeof(int));
    602 }
    603 
    604 int
    605 ultrix_sys_sigreturn(struct lwp *l, const struct ultrix_sys_sigreturn_args *uap, register_t *retval)
    606 {
    607 	/* struct sigcontext13 is close enough to Ultrix */
    608 	struct compat_13_sys_sigreturn_args ap;
    609 
    610 	SCARG(&ap, sigcntxp) = (void *)SCARG(uap, sigcntxp);
    611 
    612 	return compat_13_sys_sigreturn(l, &ap, retval);
    613 }
    614 
    615 int
    616 ultrix_sys_sigcleanup(struct lwp *l, const struct ultrix_sys_sigcleanup_args *uap, register_t *retval)
    617 {
    618 
    619 	/* struct sigcontext13 is close enough to Ultrix */
    620 	struct compat_13_sys_sigreturn_args ap;
    621 
    622 	SCARG(&ap, sigcntxp) = (void *)SCARG(uap, sigcntxp);
    623 
    624 	return compat_13_sys_sigreturn(l, &ap, retval);
    625 }
    626 
    627 int
    628 ultrix_sys_sigsuspend(struct lwp *l, const struct ultrix_sys_sigsuspend_args *uap, register_t *retval)
    629 {
    630 	int mask = SCARG(uap, mask);
    631 	sigset_t ss;
    632 
    633 	ss.__bits[0] = mask;
    634 	ss.__bits[1] = 0;
    635 	ss.__bits[2] = 0;
    636 	ss.__bits[3] = 0;
    637 
    638 	return sigsuspend1(l, &ss);
    639 }
    640 
    641 #define ULTRIX_SV_ONSTACK 0x0001  /* take signal on signal stack */
    642 #define ULTRIX_SV_INTERRUPT 0x0002  /* do not restart system on signal return */
    643 #define ULTRIX_SV_OLDSIG 0x1000  /* Emulate old signal() for POSIX */
    644 
    645 int
    646 ultrix_sys_sigvec(struct lwp *l, const struct ultrix_sys_sigvec_args *uap, register_t *retval)
    647 {
    648 	struct sigvec nsv, osv;
    649 	struct sigaction nsa, osa;
    650 	int error;
    651 
    652 	if (SCARG(uap, nsv)) {
    653 		error = copyin(SCARG(uap, nsv), &nsv, sizeof(nsv));
    654 		if (error)
    655 			return error;
    656 		nsa.sa_handler = nsv.sv_handler;
    657 #if 0 /* documentation */
    658 		/* ONSTACK is identical */
    659 		nsa.sa_flags = nsv.sv_flags & ULTRIX_SV_ONSTACK;
    660 		if ((nsv.sv_flags & ULTRIX_SV_OLDSIG)
    661 		    /* old signal() - always restart */
    662 		    || (!(nsv.sv_flags & ULTRIX_SV_INTERRUPT))
    663 		    /* inverted meaning (same bit) */
    664 		    )
    665 			nsa.sa_flags |= SA_RESTART;
    666 #else /* optimized - assuming ULTRIX_SV_OLDSIG=>!ULTRIX_SV_INTERRUPT */
    667 		nsa.sa_flags = nsv.sv_flags & ~ULTRIX_SV_OLDSIG;
    668 		nsa.sa_flags ^= SA_RESTART;
    669 #endif
    670 		native_sigset13_to_sigset(&nsv.sv_mask, &nsa.sa_mask);
    671 	}
    672 	error = sigaction1(l, SCARG(uap, signum),
    673 	    SCARG(uap, nsv) ? &nsa : 0, SCARG(uap, osv) ? &osa : 0,
    674 	    NULL, 0);
    675 	if (error)
    676 		return error;
    677 	if (SCARG(uap, osv)) {
    678 		osv.sv_handler = osa.sa_handler;
    679 		osv.sv_flags = osa.sa_flags ^ SA_RESTART;
    680 		osv.sv_flags &= (ULTRIX_SV_ONSTACK | ULTRIX_SV_INTERRUPT);
    681 		native_sigset_to_sigset13(&osa.sa_mask, &osv.sv_mask);
    682 		error = copyout(&osv, SCARG(uap, osv), sizeof(osv));
    683 		if (error)
    684 			return error;
    685 	}
    686 	return 0;
    687 }
    688 
    689 int
    690 ultrix_sys_shmsys(struct lwp *l, const struct ultrix_sys_shmsys_args *uap, register_t *retval)
    691 {
    692 
    693 #ifdef SYSVSHM
    694 	/* Ultrix SVSHM weirndess: */
    695 	struct sys_shmat_args shmat_args;
    696 	struct compat_14_sys_shmctl_args shmctl_args;
    697 	struct sys_shmdt_args shmdt_args;
    698 	struct sys_shmget_args shmget_args;
    699 
    700 
    701 	switch (SCARG(uap, shmop)) {
    702 	case 0:						/* Ultrix shmat() */
    703 		SCARG(&shmat_args, shmid) = SCARG(uap, a2);
    704 		SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a3);
    705 		SCARG(&shmat_args, shmflg) = SCARG(uap, a4);
    706 		return sys_shmat(l, &shmat_args, retval);
    707 
    708 	case 1:						/* Ultrix shmctl() */
    709 		SCARG(&shmctl_args, shmid) = SCARG(uap, a2);
    710 		SCARG(&shmctl_args, cmd) = SCARG(uap, a3);
    711 		SCARG(&shmctl_args, buf) = (struct shmid_ds14 *)SCARG(uap, a4);
    712 		return compat_14_sys_shmctl(l, &shmctl_args, retval);
    713 
    714 	case 2:						/* Ultrix shmdt() */
    715 		SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a2);
    716 		return sys_shmdt(l, &shmdt_args, retval);
    717 
    718 	case 3:						/* Ultrix shmget() */
    719 		SCARG(&shmget_args, key) = SCARG(uap, a2);
    720 		SCARG(&shmget_args, size) = SCARG(uap, a3);
    721 		SCARG(&shmget_args, shmflg) = SCARG(uap, a4)
    722 		    & (IPC_CREAT|IPC_EXCL|IPC_NOWAIT);
    723 		return sys_shmget(l, &shmget_args, retval);
    724 
    725 	default:
    726 		return EINVAL;
    727 	}
    728 #else
    729 	return EOPNOTSUPP;
    730 #endif	/* SYSVSHM */
    731 }
    732 
    733 static int
    734 ultrix_to_bsd_flock(struct ultrix_flock *ufl, struct flock *fl)
    735 {
    736 
    737 	fl->l_start = ufl->l_start;
    738 	fl->l_len = ufl->l_len;
    739 	fl->l_pid = ufl->l_pid;
    740 	fl->l_whence = ufl->l_whence;
    741 
    742 	switch (ufl->l_type) {
    743 	case ULTRIX_F_RDLCK:
    744 		fl->l_type = F_RDLCK;
    745 		break;
    746 	case ULTRIX_F_WRLCK:
    747 		fl->l_type = F_WRLCK;
    748 		break;
    749 	case ULTRIX_F_UNLCK:
    750 		fl->l_type = F_UNLCK;
    751 		break;
    752 	default:
    753 		return EINVAL;
    754 	}
    755 
    756 	return 0;
    757 }
    758 
    759 static void
    760 bsd_to_ultrix_flock(struct flock *fl, struct ultrix_flock *ufl)
    761 {
    762 
    763 	ufl->l_start = fl->l_start;
    764 	ufl->l_len = fl->l_len;
    765 	ufl->l_pid = fl->l_pid;
    766 	ufl->l_whence = fl->l_whence;
    767 
    768 	switch (fl->l_type) {
    769 	case F_RDLCK:
    770 		ufl->l_type = ULTRIX_F_RDLCK;
    771 		break;
    772 	case F_WRLCK:
    773 		ufl->l_type = ULTRIX_F_WRLCK;
    774 		break;
    775 	case F_UNLCK:
    776 		ufl->l_type = ULTRIX_F_UNLCK;
    777 		break;
    778 	}
    779 }
    780 
    781 int
    782 ultrix_sys_fcntl(struct lwp *l, const struct ultrix_sys_fcntl_args *uap, register_t *retval)
    783 {
    784 	int error;
    785 	struct ultrix_flock ufl;
    786 	struct flock fl;
    787 
    788 	switch (SCARG(uap, cmd)) {
    789 	case F_GETLK:
    790 	case F_SETLK:
    791 	case F_SETLKW:
    792 		error = copyin(SCARG(uap, arg), &ufl, sizeof(ufl));
    793 		if (error)
    794 			return error;
    795 		error = ultrix_to_bsd_flock(&ufl, &fl);
    796 		if (error)
    797 			return error;
    798 		error = do_fcntl_lock(SCARG(uap, fd), SCARG(uap, cmd), &fl);
    799 		if (SCARG(uap, cmd) != F_GETLK || error != 0)
    800 			return error;
    801 		bsd_to_ultrix_flock(&fl, &ufl);
    802 		return copyout(&ufl, SCARG(uap, arg), sizeof(ufl));
    803 
    804 	default:
    805 		break;
    806 	}
    807 
    808 	return sys_fcntl(l, (const void *)uap, retval);
    809 }
    810