Home | History | Annotate | Line # | Download | only in ultrix
ultrix_misc.c revision 1.118
      1 /*	$NetBSD: ultrix_misc.c,v 1.118 2009/01/17 15:48:06 he 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.118 2009/01/17 15:48:06 he Exp $");
     80 
     81 #if defined(_KERNEL_OPT)
     82 #include "opt_sysv.h"
     83 #endif
     84 
     85 #include <sys/cdefs.h>			/* RCS ID & Copyright macro defns */
     86 
     87 /*
     88  * Ultrix compatibility module.
     89  *
     90  * Ultrix system calls that are implemented differently in BSD are
     91  * handled here.
     92  */
     93 
     94 #if defined(_KERNEL_OPT)
     95 #include "fs_nfs.h"
     96 #endif
     97 
     98 #include <sys/param.h>
     99 #include <sys/systm.h>
    100 #include <sys/namei.h>
    101 #include <sys/dirent.h>
    102 #include <sys/proc.h>
    103 #include <sys/file.h>
    104 #include <sys/filedesc.h>
    105 #include <sys/kernel.h>
    106 #include <sys/exec.h>
    107 #include <sys/malloc.h>
    108 #include <sys/mbuf.h>
    109 #include <sys/mman.h>
    110 #include <sys/mount.h>
    111 #include <sys/resource.h>
    112 #include <sys/resourcevar.h>
    113 #include <sys/signal.h>
    114 #include <sys/signalvar.h>
    115 #include <sys/socket.h>
    116 #include <sys/vnode.h>
    117 #include <sys/uio.h>
    118 #include <sys/wait.h>
    119 #include <sys/utsname.h>
    120 #include <sys/unistd.h>
    121 #include <sys/ipc.h>
    122 
    123 #include <sys/syscallargs.h>
    124 
    125 #include <uvm/uvm_extern.h>
    126 
    127 #include <compat/ultrix/ultrix_syscall.h>
    128 #include <compat/ultrix/ultrix_syscallargs.h>
    129 #include <compat/common/compat_util.h>
    130 #include <compat/sys/time.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 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 	NULL,
    203 	0,
    204 	NULL
    205 };
    206 
    207 #define GSI_PROG_ENV 1
    208 
    209 int
    210 ultrix_sys_getsysinfo(struct lwp *l, const struct ultrix_sys_getsysinfo_args *uap, register_t *retval)
    211 {
    212 	static short progenv = 0;
    213 
    214 	switch (SCARG(uap, op)) {
    215 		/* operations implemented: */
    216 	case GSI_PROG_ENV:
    217 		if (SCARG(uap, nbytes) < sizeof(short))
    218 			return EINVAL;
    219 		*retval = 1;
    220 		return copyout(&progenv, SCARG(uap, buffer), sizeof(progenv));
    221 	default:
    222 		*retval = 0; /* info unavail */
    223 		return 0;
    224 	}
    225 }
    226 
    227 int
    228 ultrix_sys_setsysinfo(struct lwp *l, const struct ultrix_sys_setsysinfo_args *uap, register_t *retval)
    229 {
    230 
    231 	*retval = 0;
    232 	return 0;
    233 }
    234 
    235 int
    236 ultrix_sys_waitpid(struct lwp *l, const struct ultrix_sys_waitpid_args *uap, register_t *retval)
    237 {
    238 	struct compat_50_sys_wait4_args ap;
    239 
    240 	SCARG(&ap, pid) = SCARG(uap, pid);
    241 	SCARG(&ap, status) = SCARG(uap, status);
    242 	SCARG(&ap, options) = SCARG(uap, options);
    243 	SCARG(&ap, rusage) = 0;
    244 
    245 	return compat_50_sys_wait4(l, &ap, retval);
    246 }
    247 
    248 int
    249 ultrix_sys_wait3(struct lwp *l, const struct ultrix_sys_wait3_args *uap, register_t *retval)
    250 {
    251 	struct compat_50_sys_wait4_args ap;
    252 
    253 	SCARG(&ap, pid) = -1;
    254 	SCARG(&ap, status) = SCARG(uap, status);
    255 	SCARG(&ap, options) = SCARG(uap, options);
    256 	SCARG(&ap, rusage) = SCARG(uap, rusage);
    257 
    258 	return compat_50_sys_wait4(l, &ap, retval);
    259 }
    260 
    261 /*
    262  * Ultrix binaries pass in FD_MAX as the first arg to select().
    263  * On Ultrix, FD_MAX is 4096, which is more than the NetBSD sys_select()
    264  * can handle.
    265  * Since we can't have more than the (native) FD_MAX descriptors open,
    266  * limit nfds to at most FD_MAX.
    267  */
    268 int
    269 ultrix_sys_select(struct lwp *l, const struct ultrix_sys_select_args *uap, register_t *retval)
    270 {
    271 	struct timeval50 atv;
    272 	int error;
    273 	struct compat_50_sys_select_args ap;
    274 
    275 	/* Limit number of FDs selected on to the native maximum */
    276 
    277 	if (SCARG(uap, nd) > FD_SETSIZE)
    278 		SCARG(&ap, nd) = FD_SETSIZE;
    279 	else
    280 		SCARG(&ap, nd) = SCARG(uap, nd);
    281 
    282 	SCARG(&ap, in) = SCARG(uap, in);
    283 	SCARG(&ap, ou) = SCARG(uap, ou);
    284 	SCARG(&ap, ex) = SCARG(uap, ex);
    285 	SCARG(&ap, tv) = SCARG(uap, tv);
    286 	/* Check for negative timeval */
    287 	if (SCARG(&ap, tv)) {
    288 		error = copyin(SCARG(uap, tv), &atv, sizeof(atv));
    289 		if (error)
    290 			goto done;
    291 #ifdef DEBUG
    292 		/* Ultrix clients sometimes give negative timeouts? */
    293 		if (atv.tv_sec < 0 || atv.tv_usec < 0)
    294 			printf("ultrix select( %ld, %ld): negative timeout\n",
    295 			    atv.tv_sec, atv.tv_usec);
    296 #endif
    297 
    298 	}
    299 	error = compat_50_sys_select(l, &ap, retval);
    300 	if (error == EINVAL)
    301 		printf("ultrix select: bad args?\n");
    302 
    303 done:
    304 	return error;
    305 }
    306 
    307 #if defined(NFS)
    308 int
    309 async_daemon(struct lwp *l, const void *v, register_t *retval)
    310 {
    311 	struct sys_nfssvc_args ouap;
    312 
    313 	SCARG(&ouap, flag) = NFSSVC_BIOD;
    314 	SCARG(&ouap, argp) = NULL;
    315 
    316 	return sys_nfssvc(l, &ouap, retval);
    317 }
    318 #endif /* NFS */
    319 
    320 
    321 #define	SUN__MAP_NEW	0x80000000	/* if not, old mmap & cannot handle */
    322 
    323 int
    324 ultrix_sys_mmap(struct lwp *l, const struct ultrix_sys_mmap_args *uap, register_t *retval)
    325 {
    326 	struct sys_mmap_args ouap;
    327 
    328 	/*
    329 	 * Verify the arguments.
    330 	 */
    331 	if (SCARG(uap, prot) & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
    332 		return EINVAL;			/* XXX still needed? */
    333 
    334 	if ((SCARG(uap, flags) & SUN__MAP_NEW) == 0)
    335 		return EINVAL;
    336 
    337 	SCARG(&ouap, flags) = SCARG(uap, flags) & ~SUN__MAP_NEW;
    338 	SCARG(&ouap, addr) = SCARG(uap, addr);
    339 	SCARG(&ouap, len) = SCARG(uap, len);
    340 	SCARG(&ouap, prot) = SCARG(uap, prot);
    341 	SCARG(&ouap, fd) = SCARG(uap, fd);
    342 	SCARG(&ouap, pos) = SCARG(uap, pos);
    343 
    344 	return sys_mmap(l, &ouap, retval);
    345 }
    346 
    347 int
    348 ultrix_sys_setsockopt(struct lwp *l, const struct ultrix_sys_setsockopt_args *uap, register_t *retval)
    349 {
    350 	struct sockopt sopt;
    351 	struct socket *so;
    352 	int error;
    353 	struct sys_setsockopt_args ap;
    354 
    355 	SCARG(&ap, s) = SCARG(uap, s);
    356 	SCARG(&ap, level) = SCARG(uap, level);
    357 	SCARG(&ap, name) = SCARG(uap, name);
    358 	SCARG(&ap, val) = SCARG(uap, val);
    359 	SCARG(&ap, valsize) = SCARG(uap, valsize);
    360 
    361 	/* fd_getsock() will use the descriptor for us */
    362 	if ((error = fd_getsock(SCARG(&ap, s), &so))  != 0)
    363 		return error;
    364 #define	SO_DONTLINGER (~SO_LINGER)
    365 	if (SCARG(&ap, name) == SO_DONTLINGER) {
    366 		struct linger lg;
    367 
    368 		lg.l_onoff = 0;
    369 		error = so_setsockopt(l, so, SCARG(&ap, level), SO_LINGER,
    370 		    &lg, sizeof(lg));
    371 		goto out;
    372 	}
    373 	if (SCARG(&ap, level) == IPPROTO_IP) {
    374 #define		EMUL_IP_MULTICAST_IF		2
    375 #define		EMUL_IP_MULTICAST_TTL		3
    376 #define		EMUL_IP_MULTICAST_LOOP		4
    377 #define		EMUL_IP_ADD_MEMBERSHIP		5
    378 #define		EMUL_IP_DROP_MEMBERSHIP	6
    379 		static const int ipoptxlat[] = {
    380 			IP_MULTICAST_IF,
    381 			IP_MULTICAST_TTL,
    382 			IP_MULTICAST_LOOP,
    383 			IP_ADD_MEMBERSHIP,
    384 			IP_DROP_MEMBERSHIP
    385 		};
    386 		if (SCARG(&ap, name) >= EMUL_IP_MULTICAST_IF &&
    387 		    SCARG(&ap, name) <= EMUL_IP_DROP_MEMBERSHIP) {
    388 			SCARG(&ap, name) =
    389 			    ipoptxlat[SCARG(&ap, name) - EMUL_IP_MULTICAST_IF];
    390 		}
    391 	}
    392 	if (SCARG(&ap, valsize) > MLEN) {
    393 		error = EINVAL;
    394 		goto out;
    395 	}
    396 	sockopt_init(&sopt, SCARG(&ap, level), SCARG(&ap, name),
    397 	    SCARG(&ap, valsize));
    398 	if (SCARG(&ap, val)) {
    399 		error = copyin(SCARG(&ap, val), sopt.sopt_data,
    400 		    (u_int)SCARG(&ap, valsize));
    401 	}
    402 	if (error == 0)
    403 		error = sosetopt(so, &sopt);
    404 	sockopt_destroy(&sopt);
    405  out:
    406  	fd_putfile(SCARG(uap, s));
    407 	return error;
    408 }
    409 
    410 #define	ULTRIX__SYS_NMLN	32
    411 
    412 struct ultrix_utsname {
    413 	char    sysname[ULTRIX__SYS_NMLN];
    414 	char    nodename[ULTRIX__SYS_NMLN];
    415 	char    release[ULTRIX__SYS_NMLN];
    416 	char    version[ULTRIX__SYS_NMLN];
    417 	char    machine[ULTRIX__SYS_NMLN];
    418 };
    419 
    420 int
    421 ultrix_sys_uname(struct lwp *l, const struct ultrix_sys_uname_args *uap, register_t *retval)
    422 {
    423 	struct ultrix_utsname sut;
    424 	const char *cp;
    425 	char *dp, *ep;
    426 
    427 	memset(&sut, 0, sizeof(sut));
    428 
    429 	strncpy(sut.sysname, ostype, sizeof(sut.sysname) - 1);
    430 	strncpy(sut.nodename, hostname, sizeof(sut.nodename) - 1);
    431 	strncpy(sut.release, osrelease, sizeof(sut.release) - 1);
    432 	dp = sut.version;
    433 	ep = &sut.version[sizeof(sut.version) - 1];
    434 	for (cp = version; *cp && *cp != '('; cp++)
    435 		;
    436 	for (cp++; *cp && *cp != ')' && dp < ep; cp++)
    437 		*dp++ = *cp;
    438 	for (; *cp && *cp != '#'; cp++)
    439 		;
    440 	for (; *cp && *cp != ':' && dp < ep; cp++)
    441 		*dp++ = *cp;
    442 	*dp = '\0';
    443 	strncpy(sut.machine, machine, sizeof(sut.machine) - 1);
    444 
    445 	return copyout(&sut, SCARG(uap, name), sizeof(sut));
    446 }
    447 
    448 int
    449 ultrix_sys_setpgrp(struct lwp *l, const struct ultrix_sys_setpgrp_args *uap, register_t *retval)
    450 {
    451 	struct proc *p = l->l_proc;
    452 	struct sys_setpgid_args ap;
    453 
    454 	SCARG(&ap, pid) = SCARG(uap, pid);
    455 	SCARG(&ap, pgid) = SCARG(uap, pgid);
    456 	/*
    457 	 * difference to our setpgid call is to include backwards
    458 	 * compatibility to pre-setsid() binaries. Do setsid()
    459 	 * instead of setpgid() in those cases where the process
    460 	 * tries to create a new session the old way.
    461 	 */
    462 	if (!SCARG(&ap, pgid) &&
    463 	    (!SCARG(&ap, pid) || SCARG(&ap, pid) == p->p_pid))
    464 		return sys_setsid(l, &ap, retval);
    465 	else
    466 		return sys_setpgid(l, &ap, retval);
    467 }
    468 
    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 
    500 struct ultrix_ustat {
    501 	daddr_t	f_tfree;	/* total free */
    502 	uint32_t f_tinode;	/* total inodes free */
    503 	char	f_fname[6];	/* filsys name */
    504 	char	f_fpack[6];	/* filsys pack name */
    505 };
    506 
    507 int
    508 ultrix_sys_ustat(struct lwp *l, const struct ultrix_sys_ustat_args *uap, register_t *retval)
    509 {
    510 	struct ultrix_ustat us;
    511 	int error;
    512 
    513 	memset(&us, 0, sizeof us);
    514 
    515 	/*
    516 	 * XXX: should set f_tfree and f_tinode at least
    517 	 * How do we translate dev -> fstat? (and then to ultrix_ustat)
    518 	 */
    519 
    520 	if ((error = copyout(&us, SCARG(uap, buf), sizeof us)) != 0)
    521 		return error;
    522 	return 0;
    523 }
    524 
    525 int
    526 ultrix_sys_quotactl(struct lwp *l, const struct ultrix_sys_quotactl_args *uap, register_t *retval)
    527 {
    528 
    529 	return EINVAL;
    530 }
    531 
    532 int
    533 ultrix_sys_vhangup(struct lwp *l, const void *uap, register_t *retval)
    534 {
    535 
    536 	return 0;
    537 }
    538 
    539 
    540 /*
    541  * RISC Ultrix cache control syscalls
    542  */
    543 #ifdef __mips
    544 int
    545 ultrix_sys_cacheflush(struct lwp *l, const struct ultrix_sys_cacheflush_args *uap, register_t *retval)
    546 {
    547 	/* {
    548 		syscallarg(void *) addr;
    549 		syscallarg(unsigned) nbytes;
    550 		syscallarg(int) flag;
    551 	} */
    552 	struct proc *p = l->l_proc;
    553 	vaddr_t va  = (vaddr_t)SCARG(uap, addr);
    554 	int nbytes     = SCARG(uap, nbytes);
    555 	int whichcache = SCARG(uap, whichcache);
    556 
    557 	return mips_user_cacheflush(p, va, nbytes, whichcache);
    558 }
    559 
    560 
    561 int
    562 ultrix_sys_cachectl(struct lwp *l, const struct ultrix_sys_cachectl_args *uap, register_t *retval)
    563 {
    564 	/* {
    565 		syscallarg(void *) addr;
    566 		syscallarg(int) nbytes;
    567 		syscallarg(int) cacheop;
    568 	} */
    569 	struct proc *p = l->l_proc;
    570 	vaddr_t va  = (vaddr_t)SCARG(uap, addr);
    571 	int nbytes  = SCARG(uap, nbytes);
    572 	int cacheop = SCARG(uap, cacheop);
    573 
    574 	return mips_user_cachectl(p, va, nbytes, cacheop);
    575 }
    576 
    577 #endif	/* __mips */
    578 
    579 
    580 int
    581 ultrix_sys_exportfs(struct lwp *l, const struct ultrix_sys_exportfs_args *uap, register_t *retval)
    582 {
    583 
    584 	/*
    585 	 * XXX: should perhaps translate into a mount(2)
    586 	 * with MOUNT_EXPORT?
    587 	 */
    588 	return 0;
    589 }
    590 
    591 int
    592 ultrix_sys_sigpending(struct lwp *l, const struct ultrix_sys_sigpending_args *uap, register_t *retval)
    593 {
    594 	sigset_t ss;
    595 	int mask;
    596 
    597 	sigpending1(l, &ss);
    598 	mask = ss.__bits[0];
    599 
    600 	return copyout(&mask, SCARG(uap, mask), sizeof(int));
    601 }
    602 
    603 int
    604 ultrix_sys_sigreturn(struct lwp *l, const struct ultrix_sys_sigreturn_args *uap, register_t *retval)
    605 {
    606 	/* struct sigcontext13 is close enough to Ultrix */
    607 	struct compat_13_sys_sigreturn_args ap;
    608 
    609 	SCARG(&ap, sigcntxp) = (void *)SCARG(uap, sigcntxp);
    610 
    611 	return compat_13_sys_sigreturn(l, &ap, retval);
    612 }
    613 
    614 int
    615 ultrix_sys_sigcleanup(struct lwp *l, const struct ultrix_sys_sigcleanup_args *uap, register_t *retval)
    616 {
    617 
    618 	/* struct sigcontext13 is close enough to Ultrix */
    619 	struct compat_13_sys_sigreturn_args ap;
    620 
    621 	SCARG(&ap, sigcntxp) = (void *)SCARG(uap, sigcntxp);
    622 
    623 	return compat_13_sys_sigreturn(l, &ap, retval);
    624 }
    625 
    626 int
    627 ultrix_sys_sigsuspend(struct lwp *l, const struct ultrix_sys_sigsuspend_args *uap, register_t *retval)
    628 {
    629 	int mask = SCARG(uap, mask);
    630 	sigset_t ss;
    631 
    632 	ss.__bits[0] = mask;
    633 	ss.__bits[1] = 0;
    634 	ss.__bits[2] = 0;
    635 	ss.__bits[3] = 0;
    636 
    637 	return sigsuspend1(l, &ss);
    638 }
    639 
    640 #define ULTRIX_SV_ONSTACK 0x0001  /* take signal on signal stack */
    641 #define ULTRIX_SV_INTERRUPT 0x0002  /* do not restart system on signal return */
    642 #define ULTRIX_SV_OLDSIG 0x1000  /* Emulate old signal() for POSIX */
    643 
    644 int
    645 ultrix_sys_sigvec(struct lwp *l, const struct ultrix_sys_sigvec_args *uap, register_t *retval)
    646 {
    647 	struct sigvec nsv, osv;
    648 	struct sigaction nsa, osa;
    649 	int error;
    650 
    651 	if (SCARG(uap, nsv)) {
    652 		error = copyin(SCARG(uap, nsv), &nsv, sizeof(nsv));
    653 		if (error)
    654 			return error;
    655 		nsa.sa_handler = nsv.sv_handler;
    656 #if 0 /* documentation */
    657 		/* ONSTACK is identical */
    658 		nsa.sa_flags = nsv.sv_flags & ULTRIX_SV_ONSTACK;
    659 		if ((nsv.sv_flags & ULTRIX_SV_OLDSIG)
    660 		    /* old signal() - always restart */
    661 		    || (!(nsv.sv_flags & ULTRIX_SV_INTERRUPT))
    662 		    /* inverted meaning (same bit) */
    663 		    )
    664 			nsa.sa_flags |= SA_RESTART;
    665 #else /* optimized - assuming ULTRIX_SV_OLDSIG=>!ULTRIX_SV_INTERRUPT */
    666 		nsa.sa_flags = nsv.sv_flags & ~ULTRIX_SV_OLDSIG;
    667 		nsa.sa_flags ^= SA_RESTART;
    668 #endif
    669 		native_sigset13_to_sigset(&nsv.sv_mask, &nsa.sa_mask);
    670 	}
    671 	error = sigaction1(l, SCARG(uap, signum),
    672 	    SCARG(uap, nsv) ? &nsa : 0, SCARG(uap, osv) ? &osa : 0,
    673 	    NULL, 0);
    674 	if (error)
    675 		return error;
    676 	if (SCARG(uap, osv)) {
    677 		osv.sv_handler = osa.sa_handler;
    678 		osv.sv_flags = osa.sa_flags ^ SA_RESTART;
    679 		osv.sv_flags &= (ULTRIX_SV_ONSTACK | ULTRIX_SV_INTERRUPT);
    680 		native_sigset_to_sigset13(&osa.sa_mask, &osv.sv_mask);
    681 		error = copyout(&osv, SCARG(uap, osv), sizeof(osv));
    682 		if (error)
    683 			return error;
    684 	}
    685 	return 0;
    686 }
    687 
    688 int
    689 ultrix_sys_shmsys(struct lwp *l, const struct ultrix_sys_shmsys_args *uap, register_t *retval)
    690 {
    691 
    692 #ifdef SYSVSHM
    693 	/* Ultrix SVSHM weirndess: */
    694 	struct sys_shmat_args shmat_args;
    695 	struct compat_14_sys_shmctl_args shmctl_args;
    696 	struct sys_shmdt_args shmdt_args;
    697 	struct sys_shmget_args shmget_args;
    698 
    699 
    700 	switch (SCARG(uap, shmop)) {
    701 	case 0:						/* Ultrix shmat() */
    702 		SCARG(&shmat_args, shmid) = SCARG(uap, a2);
    703 		SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a3);
    704 		SCARG(&shmat_args, shmflg) = SCARG(uap, a4);
    705 		return sys_shmat(l, &shmat_args, retval);
    706 
    707 	case 1:						/* Ultrix shmctl() */
    708 		SCARG(&shmctl_args, shmid) = SCARG(uap, a2);
    709 		SCARG(&shmctl_args, cmd) = SCARG(uap, a3);
    710 		SCARG(&shmctl_args, buf) = (struct shmid_ds14 *)SCARG(uap, a4);
    711 		return compat_14_sys_shmctl(l, &shmctl_args, retval);
    712 
    713 	case 2:						/* Ultrix shmdt() */
    714 		SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a2);
    715 		return sys_shmdt(l, &shmdt_args, retval);
    716 
    717 	case 3:						/* Ultrix shmget() */
    718 		SCARG(&shmget_args, key) = SCARG(uap, a2);
    719 		SCARG(&shmget_args, size) = SCARG(uap, a3);
    720 		SCARG(&shmget_args, shmflg) = SCARG(uap, a4)
    721 		    & (IPC_CREAT|IPC_EXCL|IPC_NOWAIT);
    722 		return sys_shmget(l, &shmget_args, retval);
    723 
    724 	default:
    725 		return EINVAL;
    726 	}
    727 #else
    728 	return EOPNOTSUPP;
    729 #endif	/* SYSVSHM */
    730 }
    731 
    732 static int
    733 ultrix_to_bsd_flock(struct ultrix_flock *ufl, struct flock *fl)
    734 {
    735 
    736 	fl->l_start = ufl->l_start;
    737 	fl->l_len = ufl->l_len;
    738 	fl->l_pid = ufl->l_pid;
    739 	fl->l_whence = ufl->l_whence;
    740 
    741 	switch (ufl->l_type) {
    742 	case ULTRIX_F_RDLCK:
    743 		fl->l_type = F_RDLCK;
    744 		break;
    745 	case ULTRIX_F_WRLCK:
    746 		fl->l_type = F_WRLCK;
    747 		break;
    748 	case ULTRIX_F_UNLCK:
    749 		fl->l_type = F_UNLCK;
    750 		break;
    751 	default:
    752 		return EINVAL;
    753 	}
    754 
    755 	return 0;
    756 }
    757 
    758 static void
    759 bsd_to_ultrix_flock(struct flock *fl, struct ultrix_flock *ufl)
    760 {
    761 
    762 	ufl->l_start = fl->l_start;
    763 	ufl->l_len = fl->l_len;
    764 	ufl->l_pid = fl->l_pid;
    765 	ufl->l_whence = fl->l_whence;
    766 
    767 	switch (fl->l_type) {
    768 	case F_RDLCK:
    769 		ufl->l_type = ULTRIX_F_RDLCK;
    770 		break;
    771 	case F_WRLCK:
    772 		ufl->l_type = ULTRIX_F_WRLCK;
    773 		break;
    774 	case F_UNLCK:
    775 		ufl->l_type = ULTRIX_F_UNLCK;
    776 		break;
    777 	}
    778 }
    779 
    780 int
    781 ultrix_sys_fcntl(struct lwp *l, const struct ultrix_sys_fcntl_args *uap, register_t *retval)
    782 {
    783 	int error;
    784 	struct ultrix_flock ufl;
    785 	struct flock fl;
    786 
    787 	switch (SCARG(uap, cmd)) {
    788 	case F_GETLK:
    789 	case F_SETLK:
    790 	case F_SETLKW:
    791 		error = copyin(SCARG(uap, arg), &ufl, sizeof(ufl));
    792 		if (error)
    793 			return error;
    794 		error = ultrix_to_bsd_flock(&ufl, &fl);
    795 		if (error)
    796 			return error;
    797 		error = do_fcntl_lock(SCARG(uap, fd), SCARG(uap, cmd), &fl);
    798 		if (SCARG(uap, cmd) != F_GETLK || error != 0)
    799 			return error;
    800 		bsd_to_ultrix_flock(&fl, &ufl);
    801 		return copyout(&ufl, SCARG(uap, arg), sizeof(ufl));
    802 
    803 	default:
    804 		break;
    805 	}
    806 
    807 	return sys_fcntl(l, (const void *)uap, retval);
    808 }
    809