Home | History | Annotate | Line # | Download | only in netbsd32
netbsd32_netbsd.c revision 1.5
      1 /*	$NetBSD: netbsd32_netbsd.c,v 1.5 1998/09/11 00:01:57 eeh Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1998 Matthew R. Green
      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. The name of the author may not be used to endorse or promote products
     16  *    derived from this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     23  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     25  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     26  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     28  * SUCH DAMAGE.
     29  */
     30 
     31 #include "opt_ktrace.h"
     32 
     33 #include <sys/param.h>
     34 #include <sys/systm.h>
     35 #include <sys/ipc.h>
     36 #include <sys/msg.h>
     37 #include <sys/sem.h>
     38 #include <sys/shm.h>
     39 #include <sys/malloc.h>
     40 #include <sys/mount.h>
     41 #include <sys/socket.h>
     42 #include <sys/sockio.h>
     43 #include <sys/stat.h>
     44 #include <sys/time.h>
     45 #include <sys/timex.h>
     46 #include <sys/signalvar.h>
     47 
     48 #include <vm/vm.h>
     49 #include <sys/syscallargs.h>
     50 
     51 #include <net/if.h>
     52 
     53 #include <compat/sparc32/sparc32.h>
     54 #include <compat/sparc32/sparc32_syscallargs.h>
     55 
     56 #include <machine/frame.h>
     57 
     58 static __inline void sparc32_from_timeval __P((struct timeval *, struct sparc32_timeval *));
     59 static __inline void sparc32_to_timeval __P((struct sparc32_timeval *, struct timeval *));
     60 static __inline void sparc32_from_itimerval __P((struct itimerval *, struct sparc32_itimerval *));
     61 static __inline void sparc32_to_itimerval __P((struct sparc32_itimerval *, struct itimerval *));
     62 static __inline void sparc32_to_timespec __P((struct sparc32_timespec *, struct timespec *));
     63 static __inline void sparc32_from_timespec __P((struct timespec *, struct sparc32_timespec *));
     64 static __inline void sparc32_from_rusage __P((struct rusage *, struct sparc32_rusage *));
     65 static __inline void sparc32_to_rusage __P((struct sparc32_rusage *, struct rusage *));
     66 static __inline void sparc32_to_iovec __P((struct sparc32_iovec *, struct iovec *, int));
     67 static __inline void sparc32_to_msghdr __P((struct sparc32_msghdr *, struct msghdr *));
     68 static __inline void sparc32_from_statfs __P((struct statfs *, struct sparc32_statfs *));
     69 static __inline void sparc32_from_timex __P((struct timex *, struct sparc32_timex *));
     70 static __inline void sparc32_to_timex __P((struct sparc32_timex *, struct timex *));
     71 static __inline void sparc32_from___stat13 __P((struct stat *, struct sparc32_stat *));
     72 static __inline void sparc32_to_ipc_perm __P((struct sparc32_ipc_perm *, struct ipc_perm *));
     73 static __inline void sparc32_from_ipc_perm __P((struct ipc_perm *, struct sparc32_ipc_perm *));
     74 static __inline void sparc32_to_msg __P((struct sparc32_msg *, struct msg *));
     75 static __inline void sparc32_from_msg __P((struct msg *, struct sparc32_msg *));
     76 static __inline void sparc32_to_msqid_ds __P((struct sparc32_msqid_ds *, struct msqid_ds *));
     77 static __inline void sparc32_from_msqid_ds __P((struct msqid_ds *, struct sparc32_msqid_ds *));
     78 static __inline void sparc32_to_shmid_ds __P((struct sparc32_shmid_ds *, struct shmid_ds *));
     79 static __inline void sparc32_from_shmid_ds __P((struct shmid_ds *, struct sparc32_shmid_ds *));
     80 static __inline void sparc32_to_semid_ds __P((struct  sparc32_semid_ds *, struct  semid_ds *));
     81 static __inline void sparc32_from_semid_ds __P((struct  semid_ds *, struct  sparc32_semid_ds *));
     82 
     83 /* converters for structures that we need */
     84 static __inline void
     85 sparc32_from_timeval(tv, tv32)
     86 	struct timeval *tv;
     87 	struct sparc32_timeval *tv32;
     88 {
     89 
     90 	tv32->tv_sec = (sparc32_long)tv->tv_sec;
     91 	tv32->tv_usec = (sparc32_long)tv->tv_usec;
     92 }
     93 
     94 static __inline void
     95 sparc32_to_timeval(tv32, tv)
     96 	struct sparc32_timeval *tv32;
     97 	struct timeval *tv;
     98 {
     99 
    100 	tv->tv_sec = (long)tv32->tv_sec;
    101 	tv->tv_usec = (long)tv32->tv_usec;
    102 }
    103 
    104 static __inline void
    105 sparc32_from_itimerval(itv, itv32)
    106 	struct itimerval *itv;
    107 	struct sparc32_itimerval *itv32;
    108 {
    109 
    110 	sparc32_from_timeval(&itv->it_interval, &itv32->it_interval);
    111 	sparc32_from_timeval(&itv->it_value, &itv32->it_value);
    112 }
    113 
    114 static __inline void
    115 sparc32_to_itimerval(itv32, itv)
    116 	struct sparc32_itimerval *itv32;
    117 	struct itimerval *itv;
    118 {
    119 
    120 	sparc32_to_timeval(&itv->it_interval, &itv32->it_interval);
    121 	sparc32_to_timeval(&itv->it_value, &itv32->it_value);
    122 }
    123 
    124 static __inline void
    125 sparc32_to_timespec(s32p, p)
    126 	struct sparc32_timespec *s32p;
    127 	struct timespec *p;
    128 {
    129 
    130 	p->tv_sec = s32p->tv_sec;
    131 	p->tv_nsec = (long)s32p->tv_nsec;
    132 }
    133 
    134 static __inline void
    135 sparc32_from_timespec(p, s32p)
    136 	struct timespec *p;
    137 	struct sparc32_timespec *s32p;
    138 {
    139 
    140 	s32p->tv_sec = p->tv_sec;
    141 	s32p->tv_nsec = (sparc32_long)p->tv_nsec;
    142 }
    143 
    144 static __inline void
    145 sparc32_from_rusage(rup, ru32p)
    146 	struct rusage *rup;
    147 	struct sparc32_rusage *ru32p;
    148 {
    149 
    150 	sparc32_from_timeval(&rup->ru_utime, &ru32p->ru_utime);
    151 	sparc32_from_timeval(&rup->ru_stime, &ru32p->ru_stime);
    152 #define C(var)	ru32p->var = (sparc32_long)rup->var
    153 	C(ru_maxrss);
    154 	C(ru_ixrss);
    155 	C(ru_idrss);
    156 	C(ru_isrss);
    157 	C(ru_minflt);
    158 	C(ru_majflt);
    159 	C(ru_nswap);
    160 	C(ru_inblock);
    161 	C(ru_oublock);
    162 	C(ru_msgsnd);
    163 	C(ru_msgrcv);
    164 	C(ru_nsignals);
    165 	C(ru_nvcsw);
    166 	C(ru_nivcsw);
    167 #undef C
    168 }
    169 
    170 static __inline void
    171 sparc32_to_rusage(ru32p, rup)
    172 	struct sparc32_rusage *ru32p;
    173 	struct rusage *rup;
    174 {
    175 
    176 	sparc32_to_timeval(&ru32p->ru_utime, &rup->ru_utime);
    177 	sparc32_to_timeval(&ru32p->ru_stime, &rup->ru_stime);
    178 #define C(var)	rup->var = (long)ru32p->var
    179 	C(ru_maxrss);
    180 	C(ru_ixrss);
    181 	C(ru_idrss);
    182 	C(ru_isrss);
    183 	C(ru_minflt);
    184 	C(ru_majflt);
    185 	C(ru_nswap);
    186 	C(ru_inblock);
    187 	C(ru_oublock);
    188 	C(ru_msgsnd);
    189 	C(ru_msgrcv);
    190 	C(ru_nsignals);
    191 	C(ru_nvcsw);
    192 	C(ru_nivcsw);
    193 #undef C
    194 }
    195 
    196 static __inline void
    197 sparc32_to_iovec(iov32p, iovp, len)
    198 	struct sparc32_iovec *iov32p;
    199 	struct iovec *iovp;
    200 	int len;
    201 {
    202 	int i;
    203 
    204 	for (i = 0; i < len; i++, iovp++, iov32p++) {
    205 		iovp->iov_base = (void *)(u_long)iov32p->iov_base;
    206 		iovp->iov_len = (size_t)iov32p->iov_len;
    207 	}
    208 }
    209 
    210 /* assumes that mhp's msg_iov has been allocated */
    211 static __inline void
    212 sparc32_to_msghdr(mhp32, mhp)
    213 	struct sparc32_msghdr *mhp32;
    214 	struct msghdr *mhp;
    215 {
    216 
    217 	mhp->msg_name = (caddr_t)(u_long)mhp32->msg_name;
    218 	mhp->msg_namelen = mhp32->msg_namelen;
    219 	mhp->msg_iovlen = (size_t)mhp32->msg_iovlen;
    220 	mhp->msg_control = (caddr_t)(u_long)mhp32->msg_control;
    221 	mhp->msg_controllen = mhp32->msg_controllen;
    222 	mhp->msg_flags = mhp32->msg_flags;
    223 	sparc32_to_iovec(mhp32->msg_iov, mhp->msg_iov, mhp->msg_iovlen);
    224 }
    225 
    226 static __inline void
    227 sparc32_from_statfs(sbp, sb32p)
    228 	struct statfs *sbp;
    229 	struct sparc32_statfs *sb32p;
    230 {
    231 
    232 	sb32p->f_type = sbp->f_type;
    233 	sb32p->f_flags = sbp->f_flags;
    234 	sb32p->f_bsize = (sparc32_long)sbp->f_bsize;
    235 	sb32p->f_iosize = (sparc32_long)sbp->f_iosize;
    236 	sb32p->f_blocks = (sparc32_long)sbp->f_blocks;
    237 	sb32p->f_bfree = (sparc32_long)sbp->f_bfree;
    238 	sb32p->f_bavail = (sparc32_long)sbp->f_bavail;
    239 	sb32p->f_files = (sparc32_long)sbp->f_files;
    240 	sb32p->f_ffree = (sparc32_long)sbp->f_ffree;
    241 	sb32p->f_fsid = sbp->f_fsid;
    242 	sb32p->f_owner = sbp->f_owner;
    243 	strncpy(sbp->f_fstypename, sb32p->f_fstypename, MFSNAMELEN);
    244 	strncpy(sbp->f_fstypename, sb32p->f_fstypename, MNAMELEN);
    245 	strncpy(sbp->f_fstypename, sb32p->f_mntfromname, MNAMELEN);
    246 }
    247 
    248 static __inline void
    249 sparc32_from_timex(txp, tx32p)
    250 	struct timex *txp;
    251 	struct sparc32_timex *tx32p;
    252 {
    253 
    254 	tx32p->modes = txp->modes;
    255 	tx32p->offset = (sparc32_long)txp->offset;
    256 	tx32p->freq = (sparc32_long)txp->freq;
    257 	tx32p->maxerror = (sparc32_long)txp->maxerror;
    258 	tx32p->esterror = (sparc32_long)txp->esterror;
    259 	tx32p->status = txp->status;
    260 	tx32p->constant = (sparc32_long)txp->constant;
    261 	tx32p->precision = (sparc32_long)txp->precision;
    262 	tx32p->tolerance = (sparc32_long)txp->tolerance;
    263 	tx32p->ppsfreq = (sparc32_long)txp->ppsfreq;
    264 	tx32p->jitter = (sparc32_long)txp->jitter;
    265 	tx32p->shift = txp->shift;
    266 	tx32p->stabil = (sparc32_long)txp->stabil;
    267 	tx32p->jitcnt = (sparc32_long)txp->jitcnt;
    268 	tx32p->calcnt = (sparc32_long)txp->calcnt;
    269 	tx32p->errcnt = (sparc32_long)txp->errcnt;
    270 	tx32p->stbcnt = (sparc32_long)txp->stbcnt;
    271 }
    272 
    273 static __inline void
    274 sparc32_to_timex(tx32p, txp)
    275 	struct sparc32_timex *tx32p;
    276 	struct timex *txp;
    277 {
    278 
    279 	txp->modes = tx32p->modes;
    280 	txp->offset = (long)tx32p->offset;
    281 	txp->freq = (long)tx32p->freq;
    282 	txp->maxerror = (long)tx32p->maxerror;
    283 	txp->esterror = (long)tx32p->esterror;
    284 	txp->status = tx32p->status;
    285 	txp->constant = (long)tx32p->constant;
    286 	txp->precision = (long)tx32p->precision;
    287 	txp->tolerance = (long)tx32p->tolerance;
    288 	txp->ppsfreq = (long)tx32p->ppsfreq;
    289 	txp->jitter = (long)tx32p->jitter;
    290 	txp->shift = tx32p->shift;
    291 	txp->stabil = (long)tx32p->stabil;
    292 	txp->jitcnt = (long)tx32p->jitcnt;
    293 	txp->calcnt = (long)tx32p->calcnt;
    294 	txp->errcnt = (long)tx32p->errcnt;
    295 	txp->stbcnt = (long)tx32p->stbcnt;
    296 }
    297 
    298 static __inline void
    299 sparc32_from___stat13(sbp, sb32p)
    300 	struct stat *sbp;
    301 	struct sparc32_stat *sb32p;
    302 {
    303 	sb32p->st_dev = sbp->st_dev;
    304 	sb32p->st_ino = sbp->st_ino;
    305 	sb32p->st_mode = sbp->st_mode;
    306 	sb32p->st_nlink = sbp->st_nlink;
    307 	sb32p->st_uid = sbp->st_uid;
    308 	sb32p->st_gid = sbp->st_gid;
    309 	sb32p->st_rdev = sbp->st_rdev;
    310 	if (sbp->st_size < (quad_t)1 << 32)
    311 		sb32p->st_size = sbp->st_size;
    312 	else
    313 		sb32p->st_size = -2;
    314 	sb32p->st_atimespec.tv_sec = sbp->st_atimespec.tv_sec;
    315 	sb32p->st_atimespec.tv_nsec = (sparc32_long)sbp->st_atimespec.tv_nsec;
    316 	sb32p->st_mtimespec.tv_sec = sbp->st_mtimespec.tv_sec;
    317 	sb32p->st_mtimespec.tv_nsec = (sparc32_long)sbp->st_mtimespec.tv_nsec;
    318 	sb32p->st_ctimespec.tv_sec = sbp->st_ctimespec.tv_sec;
    319 	sb32p->st_ctimespec.tv_nsec = (sparc32_long)sbp->st_ctimespec.tv_nsec;
    320 	sb32p->st_blksize = sbp->st_blksize;
    321 	sb32p->st_blocks = sbp->st_blocks;
    322 	sb32p->st_flags = sbp->st_flags;
    323 	sb32p->st_gen = sbp->st_gen;
    324 }
    325 
    326 static __inline void
    327 sparc32_to_ipc_perm(ip32p, ipp)
    328 	struct sparc32_ipc_perm *ip32p;
    329 	struct ipc_perm *ipp;
    330 {
    331 
    332 	ipp->cuid = ip32p->cuid;
    333 	ipp->cgid = ip32p->cgid;
    334 	ipp->uid = ip32p->uid;
    335 	ipp->gid = ip32p->gid;
    336 	ipp->mode = ip32p->mode;
    337 	ipp->seq = ip32p->seq;
    338 	ipp->key = (key_t)ip32p->key;
    339 }
    340 
    341 static __inline void
    342 sparc32_from_ipc_perm(ipp, ip32p)
    343 	struct ipc_perm *ipp;
    344 	struct sparc32_ipc_perm *ip32p;
    345 {
    346 
    347 	ip32p->cuid = ipp->cuid;
    348 	ip32p->cgid = ipp->cgid;
    349 	ip32p->uid = ipp->uid;
    350 	ip32p->gid = ipp->gid;
    351 	ip32p->mode = ipp->mode;
    352 	ip32p->seq = ipp->seq;
    353 	ip32p->key = (sparc32_key_t)ipp->key;
    354 }
    355 
    356 static __inline void
    357 sparc32_to_msg(m32p, mp)
    358 	struct sparc32_msg *m32p;
    359 	struct msg *mp;
    360 {
    361 
    362 	mp->msg_next = (struct msg *)(u_long)m32p->msg_next;
    363 	mp->msg_type = (long)m32p->msg_type;
    364 	mp->msg_ts = m32p->msg_ts;
    365 	mp->msg_spot = m32p->msg_spot;
    366 }
    367 
    368 static __inline void
    369 sparc32_from_msg(mp, m32p)
    370 	struct msg *mp;
    371 	struct sparc32_msg *m32p;
    372 {
    373 
    374 	m32p->msg_next = (sparc32_msgp_t)(u_long)mp->msg_next;
    375 	m32p->msg_type = (sparc32_long)mp->msg_type;
    376 	m32p->msg_ts = mp->msg_ts;
    377 	m32p->msg_spot = mp->msg_spot;
    378 }
    379 
    380 static __inline void
    381 sparc32_to_msqid_ds(ds32p, dsp)
    382 	struct sparc32_msqid_ds *ds32p;
    383 	struct msqid_ds *dsp;
    384 {
    385 
    386 	sparc32_to_ipc_perm(&ds32p->msg_perm, &dsp->msg_perm);
    387 	sparc32_to_msg(&ds32p->msg_first, &dsp->msg_first);
    388 	sparc32_to_msg(&ds32p->msg_last, &dsp->msg_last);
    389 	dsp->msg_cbytes = (u_long)ds32p->msg_cbytes;
    390 	dsp->msg_qnum = (u_long)ds32p->msg_qnum;
    391 	dsp->msg_qbytes = (u_long)ds32p->msg_qbytes;
    392 	dsp->msg_lspid = ds32p->msg_lspid;
    393 	dsp->msg_lrpid = ds32p->msg_lrpid;
    394 	dsp->msg_rtime = (time_t)ds32p->msg_rtime;
    395 	dsp->msg_stime = (time_t)ds32p->msg_stime;
    396 	dsp->msg_ctime = (time_t)ds32p->msg_ctime;
    397 }
    398 
    399 static __inline void
    400 sparc32_from_msqid_ds(dsp, ds32p)
    401 	struct msqid_ds *dsp;
    402 	struct sparc32_msqid_ds *ds32p;
    403 {
    404 
    405 	sparc32_from_ipc_perm(&dsp->msg_perm, &ds32p->msg_perm);
    406 	sparc32_from_msg(&dsp->msg_first, &ds32p->msg_first);
    407 	sparc32_from_msg(&dsp->msg_last, &ds32p->msg_last);
    408 	ds32p->msg_cbytes = (sparc32_u_long)dsp->msg_cbytes;
    409 	ds32p->msg_qnum = (sparc32_u_long)dsp->msg_qnum;
    410 	ds32p->msg_qbytes = (sparc32_u_long)dsp->msg_qbytes;
    411 	ds32p->msg_lspid = dsp->msg_lspid;
    412 	ds32p->msg_lrpid = dsp->msg_lrpid;
    413 	ds32p->msg_rtime = dsp->msg_rtime;
    414 	ds32p->msg_stime = dsp->msg_stime;
    415 	ds32p->msg_ctime = dsp->msg_ctime;
    416 }
    417 
    418 static __inline void
    419 sparc32_to_shmid_ds(ds32p, dsp)
    420 	struct sparc32_shmid_ds *ds32p;
    421 	struct shmid_ds *dsp;
    422 {
    423 
    424 	sparc32_to_ipc_perm(&ds32p->shm_perm, &dsp->shm_perm);
    425 	dsp->shm_segsz = ds32p->shm_segsz;
    426 	dsp->shm_lpid = ds32p->shm_lpid;
    427 	dsp->shm_cpid = ds32p->shm_cpid;
    428 	dsp->shm_nattch = ds32p->shm_nattch;
    429 	dsp->shm_atime = (long)ds32p->shm_atime;
    430 	dsp->shm_dtime = (long)ds32p->shm_dtime;
    431 	dsp->shm_ctime = (long)ds32p->shm_ctime;
    432 	dsp->shm_internal = (void *)(u_long)ds32p->shm_internal;
    433 }
    434 
    435 static __inline void
    436 sparc32_from_shmid_ds(dsp, ds32p)
    437 	struct shmid_ds *dsp;
    438 	struct sparc32_shmid_ds *ds32p;
    439 {
    440 
    441 	sparc32_from_ipc_perm(&dsp->shm_perm, &ds32p->shm_perm);
    442 	ds32p->shm_segsz = dsp->shm_segsz;
    443 	ds32p->shm_lpid = dsp->shm_lpid;
    444 	ds32p->shm_cpid = dsp->shm_cpid;
    445 	ds32p->shm_nattch = dsp->shm_nattch;
    446 	ds32p->shm_atime = (sparc32_long)dsp->shm_atime;
    447 	ds32p->shm_dtime = (sparc32_long)dsp->shm_dtime;
    448 	ds32p->shm_ctime = (sparc32_long)dsp->shm_ctime;
    449 	ds32p->shm_internal = (sparc32_voidp)(u_long)dsp->shm_internal;
    450 }
    451 
    452 static __inline void
    453 sparc32_to_semid_ds(s32dsp, dsp)
    454 	struct  sparc32_semid_ds *s32dsp;
    455 	struct  semid_ds *dsp;
    456 {
    457 
    458 	sparc32_from_ipc_perm(&dsp->sem_perm, &s32dsp->sem_perm);
    459 	dsp->sem_base = (struct sem *)(u_long)s32dsp->sem_base;
    460 	dsp->sem_nsems = s32dsp->sem_nsems;
    461 	dsp->sem_otime = s32dsp->sem_otime;
    462 	dsp->sem_ctime = s32dsp->sem_ctime;
    463 }
    464 
    465 static __inline void
    466 sparc32_from_semid_ds(dsp, s32dsp)
    467 	struct  semid_ds *dsp;
    468 	struct  sparc32_semid_ds *s32dsp;
    469 {
    470 
    471 	sparc32_to_ipc_perm(&s32dsp->sem_perm, &dsp->sem_perm);
    472 	s32dsp->sem_base = (sparc32_semp_t)(u_long)dsp->sem_base;
    473 	s32dsp->sem_nsems = dsp->sem_nsems;
    474 	s32dsp->sem_otime = dsp->sem_otime;
    475 	s32dsp->sem_ctime = dsp->sem_ctime;
    476 }
    477 
    478 /*
    479  * below are all the standard NetBSD system calls, in the 32bit
    480  * environment, witht he necessary conversions to 64bit before
    481  * calling the real syscall.
    482  */
    483 
    484 int
    485 compat_sparc32_read(p, v, retval)
    486 	struct proc *p;
    487 	void *v;
    488 	register_t *retval;
    489 {
    490 	struct compat_sparc32_read_args /* {
    491 		syscallarg(int) fd;
    492 		syscallarg(sparc32_voidp) buf;
    493 		syscallarg(sparc32_size_t) nbyte;
    494 	} */ *uap = v;
    495 	struct sys_read_args ua;
    496 	ssize_t rt;
    497 	int error;
    498 
    499 	SPARC32TO64_UAP(fd);
    500 	SPARC32TOP_UAP(buf, void *);
    501 	SPARC32TOX_UAP(nbyte, size_t);
    502 	error = sys_read(p, &ua, (register_t *)&rt);
    503 	*(sparc32_ssize_t *)retval = rt;
    504 
    505 	return (error);
    506 }
    507 
    508 int
    509 compat_sparc32_write(p, v, retval)
    510 	struct proc *p;
    511 	void *v;
    512 	register_t *retval;
    513 {
    514 	struct compat_sparc32_write_args /* {
    515 		syscallarg(int) fd;
    516 		syscallarg(const sparc32_voidp) buf;
    517 		syscallarg(sparc32_size_t) nbyte;
    518 	} */ *uap = v;
    519 	struct sys_write_args ua;
    520 	ssize_t rt;
    521 	int error;
    522 
    523 	SPARC32TO64_UAP(fd);
    524 	SPARC32TOP_UAP(buf, void *);
    525 	SPARC32TOX_UAP(nbyte, size_t);
    526 	error = sys_write(p, &ua, (register_t *)&rt);
    527 	*(sparc32_ssize_t *)retval = rt;
    528 
    529 	return (error);
    530 }
    531 
    532 int
    533 compat_sparc32_open(p, v, retval)
    534 	struct proc *p;
    535 	void *v;
    536 	register_t *retval;
    537 {
    538 	struct compat_sparc32_open_args /* {
    539 		syscallarg(const sparc32_charp) path;
    540 		syscallarg(int) flags;
    541 		syscallarg(mode_t) mode;
    542 	} */ *uap = v;
    543 	struct sys_open_args ua;
    544 	caddr_t sg;
    545 
    546 	SPARC32TOP_UAP(path, const char);
    547 	SPARC32TO64_UAP(flags);
    548 	SPARC32TO64_UAP(mode);
    549 	sg = stackgap_init(p->p_emul);
    550 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
    551 
    552 	return (sys_open(p, &ua, retval));
    553 }
    554 
    555 int
    556 compat_sparc32_wait4(p, v, retval)
    557 	struct proc *p;
    558 	void *v;
    559 	register_t *retval;
    560 {
    561 	struct compat_sparc32_wait4_args /* {
    562 		syscallarg(int) pid;
    563 		syscallarg(sparc32_intp) status;
    564 		syscallarg(int) options;
    565 		syscallarg(sparc32_rusagep_t) rusage;
    566 	} */ *uap = v;
    567 	struct sys_wait4_args ua;
    568 	struct rusage ru;
    569 	struct sparc32_rusage *ru32p;
    570 	struct sparc32_rusage ru32;
    571 	int error;
    572 
    573 	SPARC32TO64_UAP(pid);
    574 	SPARC32TOP_UAP(status, int);
    575 	SPARC32TO64_UAP(options);
    576 	ru32p = (struct sparc32_rusage *)(u_long)SCARG(uap, rusage);
    577 	if (ru32p) {
    578 		if (copyin(ru32p, &ru32, sizeof(ru32)))
    579 			return (EFAULT);
    580 		SCARG(&ua, rusage) = &ru;
    581 		sparc32_to_rusage(&ru32, &ru);
    582 	} else
    583 		SCARG(&ua, rusage) = NULL;
    584 
    585 	error = sys_wait4(p, &ua, retval);
    586 	if (ru32p) {
    587 		sparc32_from_rusage(&ru, &ru32);
    588 		if (copyout(&ru32, ru32p, sizeof(ru32)))
    589 			error = EFAULT;
    590 	}
    591 	return (error);
    592 }
    593 
    594 int
    595 compat_sparc32_link(p, v, retval)
    596 	struct proc *p;
    597 	void *v;
    598 	register_t *retval;
    599 {
    600 	struct compat_sparc32_link_args /* {
    601 		syscallarg(const sparc32_charp) path;
    602 		syscallarg(const sparc32_charp) link;
    603 	} */ *uap = v;
    604 	struct sys_link_args ua;
    605 
    606 	SPARC32TOP_UAP(path, const char);
    607 	SPARC32TOP_UAP(link, const char);
    608 	return (sys_link(p, &ua, retval));
    609 }
    610 
    611 int
    612 compat_sparc32_unlink(p, v, retval)
    613 	struct proc *p;
    614 	void *v;
    615 	register_t *retval;
    616 {
    617 	struct compat_sparc32_unlink_args /* {
    618 		syscallarg(const sparc32_charp) path;
    619 	} */ *uap = v;
    620 	struct sys_unlink_args ua;
    621 
    622 	SPARC32TOP_UAP(path, const char);
    623 
    624 	return (sys_unlink(p, &ua, retval));
    625 }
    626 
    627 int
    628 compat_sparc32_chdir(p, v, retval)
    629 	struct proc *p;
    630 	void *v;
    631 	register_t *retval;
    632 {
    633 	struct compat_sparc32_chdir_args /* {
    634 		syscallarg(const sparc32_charp) path;
    635 	} */ *uap = v;
    636 	struct sys_chdir_args ua;
    637 
    638 	SPARC32TOP_UAP(path, const char);
    639 
    640 	return (sys_chdir(p, &ua, retval));
    641 }
    642 
    643 int
    644 compat_sparc32_mknod(p, v, retval)
    645 	struct proc *p;
    646 	void *v;
    647 	register_t *retval;
    648 {
    649 	struct compat_sparc32_mknod_args /* {
    650 		syscallarg(const sparc32_charp) path;
    651 		syscallarg(mode_t) mode;
    652 		syscallarg(dev_t) dev;
    653 	} */ *uap = v;
    654 	struct sys_mknod_args ua;
    655 
    656 	SPARC32TOP_UAP(path, const char);
    657 	SPARC32TO64_UAP(dev);
    658 	SPARC32TO64_UAP(mode);
    659 
    660 	return (sys_mknod(p, &ua, retval));
    661 }
    662 
    663 int
    664 compat_sparc32_chmod(p, v, retval)
    665 	struct proc *p;
    666 	void *v;
    667 	register_t *retval;
    668 {
    669 	struct compat_sparc32_chmod_args /* {
    670 		syscallarg(const sparc32_charp) path;
    671 		syscallarg(mode_t) mode;
    672 	} */ *uap = v;
    673 	struct sys_chmod_args ua;
    674 
    675 	SPARC32TOP_UAP(path, const char);
    676 	SPARC32TO64_UAP(mode);
    677 
    678 	return (sys_chmod(p, &ua, retval));
    679 }
    680 
    681 int
    682 compat_sparc32_chown(p, v, retval)
    683 	struct proc *p;
    684 	void *v;
    685 	register_t *retval;
    686 {
    687 	struct compat_sparc32_chown_args /* {
    688 		syscallarg(const sparc32_charp) path;
    689 		syscallarg(uid_t) uid;
    690 		syscallarg(gid_t) gid;
    691 	} */ *uap = v;
    692 	struct sys_chown_args ua;
    693 
    694 	SPARC32TOP_UAP(path, const char);
    695 	SPARC32TO64_UAP(uid);
    696 	SPARC32TO64_UAP(gid);
    697 
    698 	return (sys_chown(p, &ua, retval));
    699 }
    700 
    701 int
    702 compat_sparc32_break(p, v, retval)
    703 	struct proc *p;
    704 	void *v;
    705 	register_t *retval;
    706 {
    707 	struct compat_sparc32_break_args /* {
    708 		syscallarg(sparc32_charp) nsize;
    709 	} */ *uap = v;
    710 	struct sys_obreak_args ua;
    711 
    712 	SCARG(&ua, nsize) = (char *)(u_long)SCARG(uap, nsize);
    713 	SPARC32TOP_UAP(nsize, char);
    714 	return (sys_obreak(p, &ua, retval));
    715 }
    716 
    717 int
    718 compat_sparc32_getfsstat(p, v, retval)
    719 	struct proc *p;
    720 	void *v;
    721 	register_t *retval;
    722 {
    723 	struct compat_sparc32_getfsstat_args /* {
    724 		syscallarg(sparc32_statfsp_t) buf;
    725 		syscallarg(sparc32_long) bufsize;
    726 		syscallarg(int) flags;
    727 	} */ *uap = v;
    728 	struct sys_getfsstat_args ua;
    729 	struct statfs sb;
    730 	struct sparc32_statfs *sb32p;
    731 	int error;
    732 
    733 	sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf);
    734 	if (sb32p)
    735 		SCARG(&ua, buf) = &sb;
    736 	else
    737 		SCARG(&ua, buf) = NULL;
    738 	SPARC32TOX_UAP(bufsize, long);
    739 	SPARC32TO64_UAP(flags);
    740 	error = sys_getfsstat(p, &ua, retval);
    741 	if (error)
    742 		return (error);
    743 
    744 	if (sb32p) {
    745 		struct sparc32_statfs sb32;
    746 		sparc32_from_statfs(&sb, &sb32);
    747 		if (copyout(&sb32, sb32p, sizeof(sb32)))
    748 			return EFAULT;
    749 	}
    750 	return (0);
    751 }
    752 
    753 int
    754 compat_sparc32_mount(p, v, retval)
    755 	struct proc *p;
    756 	void *v;
    757 	register_t *retval;
    758 {
    759 	struct compat_sparc32_mount_args /* {
    760 		syscallarg(const sparc32_charp) type;
    761 		syscallarg(const sparc32_charp) path;
    762 		syscallarg(int) flags;
    763 		syscallarg(sparc32_voidp) data;
    764 	} */ *uap = v;
    765 	struct sys_mount_args ua;
    766 
    767 	SPARC32TOP_UAP(type, const char);
    768 	SPARC32TOP_UAP(path, const char);
    769 	SPARC32TO64_UAP(flags);
    770 	SPARC32TOP_UAP(data, void);
    771 	return (sys_mount(p, &ua, retval));
    772 }
    773 
    774 int
    775 compat_sparc32_unmount(p, v, retval)
    776 	struct proc *p;
    777 	void *v;
    778 	register_t *retval;
    779 {
    780 	struct compat_sparc32_unmount_args /* {
    781 		syscallarg(const sparc32_charp) path;
    782 		syscallarg(int) flags;
    783 	} */ *uap = v;
    784 	struct sys_unmount_args ua;
    785 
    786 	SPARC32TOP_UAP(path, const char);
    787 	SPARC32TO64_UAP(flags);
    788 	return (sys_unmount(p, &ua, retval));
    789 }
    790 
    791 int
    792 compat_sparc32_ptrace(p, v, retval)
    793 	struct proc *p;
    794 	void *v;
    795 	register_t *retval;
    796 {
    797 	struct compat_sparc32_ptrace_args /* {
    798 		syscallarg(int) req;
    799 		syscallarg(pid_t) pid;
    800 		syscallarg(sparc32_caddr_t) addr;
    801 		syscallarg(int) data;
    802 	} */ *uap = v;
    803 	struct sys_ptrace_args ua;
    804 
    805 	SPARC32TO64_UAP(req);
    806 	SPARC32TO64_UAP(pid);
    807 	SPARC32TOX64_UAP(addr, caddr_t);
    808 	SPARC32TO64_UAP(data);
    809 	return (sys_ptrace(p, &ua, retval));
    810 }
    811 
    812 int
    813 compat_sparc32_recvmsg(p, v, retval)
    814 	struct proc *p;
    815 	void *v;
    816 	register_t *retval;
    817 {
    818 	struct compat_sparc32_recvmsg_args /* {
    819 		syscallarg(int) s;
    820 		syscallarg(sparc32_msghdrp_t) msg;
    821 		syscallarg(int) flags;
    822 	} */ *uap = v;
    823 	struct sys_recvmsg_args ua;
    824 	struct msghdr mh;
    825 	struct msghdr *mhp = &mh;
    826 	struct sparc32_msghdr *mhp32, mh32;
    827 	ssize_t rt;
    828 	int error;
    829 
    830 	SPARC32TO64_UAP(s);
    831 	SPARC32TO64_UAP(flags);
    832 
    833 	SCARG(&ua, msg) = mhp;
    834 	mhp32 = (struct sparc32_msghdr *)(u_long)SCARG(uap, msg);
    835 	if (copyin(mhp32, &mh32, sizeof(mh32)))
    836 		return EFAULT;
    837 	/* sparc32_msghdr needs the iov pre-allocated */
    838 	MALLOC(mhp->msg_iov, struct iovec *,
    839 	    sizeof(struct iovec) * mh32.msg_iovlen, M_TEMP, M_WAITOK);
    840 	sparc32_to_msghdr(&mh32, mhp);
    841 
    842 	error = sys_recvmsg(p, &ua, (register_t *)&rt);
    843 	FREE(mhp->msg_iov, M_TEMP);
    844 	*(sparc32_ssize_t *)retval = rt;
    845 	return (error);
    846 }
    847 
    848 int
    849 compat_sparc32_sendmsg(p, v, retval)
    850 	struct proc *p;
    851 	void *v;
    852 	register_t *retval;
    853 {
    854 	struct compat_sparc32_sendmsg_args /* {
    855 		syscallarg(int) s;
    856 		syscallarg(const sparc32_msghdrp_t) msg;
    857 		syscallarg(int) flags;
    858 	} */ *uap = v;
    859 	struct sys_sendmsg_args ua;
    860 	struct msghdr mh;
    861 	struct msghdr *mhp = &mh;
    862 	struct sparc32_msghdr *mhp32, mh32;
    863 	ssize_t rt;
    864 	int error;
    865 
    866 	SPARC32TO64_UAP(s);
    867 	SPARC32TO64_UAP(flags);
    868 
    869 	SCARG(&ua, msg) = mhp;
    870 	mhp32 = (struct sparc32_msghdr *)(u_long)SCARG(uap, msg);
    871 	if (copyin(mhp32, &mh32, sizeof(mh32)))
    872 		return EFAULT;
    873 	/* sparc32_msghdr needs the iov pre-allocated */
    874 	MALLOC(mhp->msg_iov, struct iovec *,
    875 	    sizeof(struct iovec) * mh32.msg_iovlen, M_TEMP, M_WAITOK);
    876 	sparc32_to_msghdr(mhp32, mhp);
    877 
    878 	error = sys_sendmsg(p, &ua, (register_t *)&rt);
    879 	FREE(mhp->msg_iov, M_TEMP);
    880 	*(sparc32_ssize_t *)retval = rt;
    881 	return (error);
    882 }
    883 
    884 int
    885 compat_sparc32_recvfrom(p, v, retval)
    886 	struct proc *p;
    887 	void *v;
    888 	register_t *retval;
    889 {
    890 	struct compat_sparc32_recvfrom_args /* {
    891 		syscallarg(int) s;
    892 		syscallarg(sparc32_voidp) buf;
    893 		syscallarg(sparc32_size_t) len;
    894 		syscallarg(int) flags;
    895 		syscallarg(sparc32_sockaddrp_t) from;
    896 		syscallarg(sparc32_intp) fromlenaddr;
    897 	} */ *uap = v;
    898 	struct sys_recvfrom_args ua;
    899 	off_t rt;
    900 	int error;
    901 
    902 	SPARC32TO64_UAP(s);
    903 	SPARC32TOP_UAP(buf, void);
    904 	SPARC32TOX_UAP(len, size_t);
    905 	SPARC32TO64_UAP(flags);
    906 	SPARC32TOP_UAP(from, struct sockaddr);
    907 	SPARC32TOP_UAP(fromlenaddr, int);
    908 
    909 	error = sys_recvfrom(p, &ua, (register_t *)&rt);
    910 	*(sparc32_ssize_t *)retval = rt;
    911 	return (error);
    912 }
    913 
    914 int
    915 compat_sparc32_sendto(p, v, retval)
    916 	struct proc *p;
    917 	void *v;
    918 	register_t *retval;
    919 {
    920 	struct compat_sparc32_sendto_args /* {
    921 		syscallarg(int) s;
    922 		syscallarg(const sparc32_voidp) buf;
    923 		syscallarg(sparc32_size_t) len;
    924 		syscallarg(int) flags;
    925 		syscallarg(const sparc32_sockaddrp_t) to;
    926 		syscallarg(int) tolen;
    927 	} */ *uap = v;
    928 	struct sys_sendto_args ua;
    929 	off_t rt;
    930 	int error;
    931 
    932 	SPARC32TO64_UAP(s);
    933 	SPARC32TOP_UAP(buf, void);
    934 	SPARC32TOX_UAP(len, size_t);
    935 	SPARC32TO64_UAP(flags);
    936 	SPARC32TOP_UAP(to, struct sockaddr);
    937 	SPARC32TOX_UAP(tolen, int);
    938 
    939 	error = sys_sendto(p, &ua, (register_t *)&rt);
    940 	*(sparc32_ssize_t *)retval = rt;
    941 	return (error);
    942 }
    943 
    944 int
    945 compat_sparc32_socketpair(p, v, retval)
    946 	struct proc *p;
    947 	void *v;
    948 	register_t *retval;
    949 {
    950 	struct compat_sparc32_socketpair_args /* {
    951 		syscallarg(int) domain;
    952 		syscallarg(int) type;
    953 		syscallarg(int) protocol;
    954 		syscallarg(sparc32_intp) rsv;
    955 	} */ *uap = v;
    956 	struct sys_socketpair_args ua;
    957 
    958 	SPARC32TO64_UAP(domain);
    959 	SPARC32TO64_UAP(type);
    960 	SPARC32TO64_UAP(protocol);
    961 	SPARC32TOP_UAP(rsv, int);
    962 	return (sys_socketpair(p, &ua, retval));
    963 }
    964 
    965 int
    966 compat_sparc32_accept(p, v, retval)
    967 	struct proc *p;
    968 	void *v;
    969 	register_t *retval;
    970 {
    971 	struct compat_sparc32_accept_args /* {
    972 		syscallarg(int) s;
    973 		syscallarg(sparc32_sockaddrp_t) name;
    974 		syscallarg(sparc32_intp) anamelen;
    975 	} */ *uap = v;
    976 	struct sys_accept_args ua;
    977 
    978 	SPARC32TO64_UAP(s);
    979 	SPARC32TOP_UAP(name, struct sockaddr);
    980 	SPARC32TOP_UAP(anamelen, int);
    981 	return (sys_accept(p, &ua, retval));
    982 }
    983 
    984 int
    985 compat_sparc32_getpeername(p, v, retval)
    986 	struct proc *p;
    987 	void *v;
    988 	register_t *retval;
    989 {
    990 	struct compat_sparc32_getpeername_args /* {
    991 		syscallarg(int) fdes;
    992 		syscallarg(sparc32_sockaddrp_t) asa;
    993 		syscallarg(sparc32_intp) alen;
    994 	} */ *uap = v;
    995 	struct sys_getpeername_args ua;
    996 
    997 	SPARC32TO64_UAP(fdes);
    998 	SPARC32TOP_UAP(asa, struct sockaddr);
    999 	SPARC32TOP_UAP(alen, int);
   1000 	return (sys_getpeername(p, &ua, retval));
   1001 }
   1002 
   1003 int
   1004 compat_sparc32_getsockname(p, v, retval)
   1005 	struct proc *p;
   1006 	void *v;
   1007 	register_t *retval;
   1008 {
   1009 	struct compat_sparc32_getsockname_args /* {
   1010 		syscallarg(int) fdes;
   1011 		syscallarg(sparc32_sockaddrp_t) asa;
   1012 		syscallarg(sparc32_intp) alen;
   1013 	} */ *uap = v;
   1014 	struct sys_getsockname_args ua;
   1015 
   1016 	SPARC32TO64_UAP(fdes);
   1017 	SPARC32TOP_UAP(asa, struct sockaddr);
   1018 	SPARC32TOP_UAP(alen, int);
   1019 	return (sys_getsockname(p, &ua, retval));
   1020 }
   1021 
   1022 int
   1023 compat_sparc32_access(p, v, retval)
   1024 	struct proc *p;
   1025 	void *v;
   1026 	register_t *retval;
   1027 {
   1028 	struct compat_sparc32_access_args /* {
   1029 		syscallarg(const sparc32_charp) path;
   1030 		syscallarg(int) flags;
   1031 	} */ *uap = v;
   1032 	struct sys_access_args ua;
   1033 	caddr_t sg;
   1034 
   1035 	SPARC32TOP_UAP(path, const char);
   1036 	SPARC32TO64_UAP(flags);
   1037 	sg = stackgap_init(p->p_emul);
   1038 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   1039 
   1040 	return (sys_access(p, &ua, retval));
   1041 }
   1042 
   1043 int
   1044 compat_sparc32_chflags(p, v, retval)
   1045 	struct proc *p;
   1046 	void *v;
   1047 	register_t *retval;
   1048 {
   1049 	struct compat_sparc32_chflags_args /* {
   1050 		syscallarg(const sparc32_charp) path;
   1051 		syscallarg(sparc32_u_long) flags;
   1052 	} */ *uap = v;
   1053 	struct sys_chflags_args ua;
   1054 
   1055 	SPARC32TOP_UAP(path, const char);
   1056 	SPARC32TO64_UAP(flags);
   1057 
   1058 	return (sys_chflags(p, &ua, retval));
   1059 }
   1060 
   1061 int
   1062 compat_sparc32_fchflags(p, v, retval)
   1063 	struct proc *p;
   1064 	void *v;
   1065 	register_t *retval;
   1066 {
   1067 	struct compat_sparc32_fchflags_args /* {
   1068 		syscallarg(int) fd;
   1069 		syscallarg(sparc32_u_long) flags;
   1070 	} */ *uap = v;
   1071 	struct sys_fchflags_args ua;
   1072 
   1073 	SPARC32TO64_UAP(fd);
   1074 	SPARC32TO64_UAP(flags);
   1075 
   1076 	return (sys_fchflags(p, &ua, retval));
   1077 }
   1078 
   1079 int
   1080 compat_sparc32_profil(p, v, retval)
   1081 	struct proc *p;
   1082 	void *v;
   1083 	register_t *retval;
   1084 {
   1085 	struct compat_sparc32_profil_args /* {
   1086 		syscallarg(sparc32_caddr_t) samples;
   1087 		syscallarg(sparc32_size_t) size;
   1088 		syscallarg(sparc32_u_long) offset;
   1089 		syscallarg(u_int) scale;
   1090 	} */ *uap = v;
   1091 	struct sys_profil_args ua;
   1092 
   1093 	SPARC32TOX64_UAP(samples, caddr_t);
   1094 	SPARC32TOX_UAP(size, size_t);
   1095 	SPARC32TOX_UAP(offset, u_long);
   1096 	SPARC32TO64_UAP(scale);
   1097 	return (sys_profil(p, &ua, retval));
   1098 }
   1099 
   1100 int
   1101 compat_sparc32_ktrace(p, v, retval)
   1102 	struct proc *p;
   1103 	void *v;
   1104 	register_t *retval;
   1105 {
   1106 	struct compat_sparc32_ktrace_args /* {
   1107 		syscallarg(const sparc32_charp) fname;
   1108 		syscallarg(int) ops;
   1109 		syscallarg(int) facs;
   1110 		syscallarg(int) pid;
   1111 	} */ *uap = v;
   1112 	struct sys_ktrace_args ua;
   1113 
   1114 	SPARC32TOP_UAP(fname, const char);
   1115 	SPARC32TO64_UAP(ops);
   1116 	SPARC32TO64_UAP(facs);
   1117 	SPARC32TO64_UAP(pid);
   1118 	return (sys_ktrace(p, &ua, retval));
   1119 }
   1120 
   1121 int
   1122 compat_sparc32_sigaction(p, v, retval)
   1123 	struct proc *p;
   1124 	void *v;
   1125 	register_t *retval;
   1126 {
   1127 	struct compat_sparc32_sigaction_args /* {
   1128 		syscallarg(int) signum;
   1129 		syscallarg(const sparc32_sigactionp_t) nsa;
   1130 		syscallarg(sparc32_sigactionp_t) osa;
   1131 	} */ *uap = v;
   1132 	struct sys_sigaction_args ua;
   1133 	struct sigaction nsa, osa;
   1134 	struct sparc32_sigaction *sa32p, sa32;
   1135 	int error;
   1136 
   1137 	SPARC32TO64_UAP(signum);
   1138 	if (SCARG(uap, osa))
   1139 		SCARG(&ua, osa) = &osa;
   1140 	else
   1141 		SCARG(&ua, osa) = NULL;
   1142 	if (SCARG(uap, nsa)) {
   1143 		SCARG(&ua, nsa) = &nsa;
   1144 		sa32p = (struct sparc32_sigaction *)(u_long)SCARG(uap, nsa);
   1145 		if (copyin(sa32p, &sa32, sizeof(sa32)))
   1146 			return EFAULT;
   1147 		nsa.sa_handler = (void *)(u_long)sa32.sa_handler;
   1148 		nsa.sa_mask = sa32.sa_mask;
   1149 		nsa.sa_flags = sa32.sa_flags;
   1150 	} else
   1151 		SCARG(&ua, nsa) = NULL;
   1152 	SCARG(&ua, nsa) = &osa;
   1153 	error = sys_sigaction(p, &ua, retval);
   1154 	if (error)
   1155 		return (error);
   1156 
   1157 	if (SCARG(uap, osa)) {
   1158 		sa32.sa_handler = (sparc32_sigactionp_t)(u_long)osa.sa_handler;
   1159 		sa32.sa_mask = osa.sa_mask;
   1160 		sa32.sa_flags = osa.sa_flags;
   1161 		sa32p = (struct sparc32_sigaction *)(u_long)SCARG(uap, osa);
   1162 		if (copyout(&sa32, sa32p, sizeof(sa32)))
   1163 			return EFAULT;
   1164 	}
   1165 
   1166 	return (0);
   1167 }
   1168 
   1169 int
   1170 compat_sparc32___getlogin(p, v, retval)
   1171 	struct proc *p;
   1172 	void *v;
   1173 	register_t *retval;
   1174 {
   1175 	struct compat_sparc32___getlogin_args /* {
   1176 		syscallarg(sparc32_charp) namebuf;
   1177 		syscallarg(u_int) namelen;
   1178 	} */ *uap = v;
   1179 	struct sys___getlogin_args ua;
   1180 
   1181 	SPARC32TOP_UAP(namebuf, char);
   1182 	SPARC32TO64_UAP(namelen);
   1183 	return (sys___getlogin(p, &ua, retval));
   1184 }
   1185 
   1186 int
   1187 compat_sparc32_setlogin(p, v, retval)
   1188 	struct proc *p;
   1189 	void *v;
   1190 	register_t *retval;
   1191 {
   1192 	struct compat_sparc32_setlogin_args /* {
   1193 		syscallarg(const sparc32_charp) namebuf;
   1194 	} */ *uap = v;
   1195 	struct sys_setlogin_args ua;
   1196 
   1197 	SPARC32TOP_UAP(namebuf, char);
   1198 	return (sys_setlogin(p, &ua, retval));
   1199 }
   1200 
   1201 int
   1202 compat_sparc32_acct(p, v, retval)
   1203 	struct proc *p;
   1204 	void *v;
   1205 	register_t *retval;
   1206 {
   1207 	struct compat_sparc32_acct_args /* {
   1208 		syscallarg(const sparc32_charp) path;
   1209 	} */ *uap = v;
   1210 	struct sys_acct_args ua;
   1211 
   1212 	SPARC32TOP_UAP(path, const char);
   1213 	return (sys_acct(p, &ua, retval));
   1214 }
   1215 
   1216 int
   1217 compat_sparc32_revoke(p, v, retval)
   1218 	struct proc *p;
   1219 	void *v;
   1220 	register_t *retval;
   1221 {
   1222 	struct compat_sparc32_revoke_args /* {
   1223 		syscallarg(const sparc32_charp) path;
   1224 	} */ *uap = v;
   1225 	struct sys_revoke_args ua;
   1226 	caddr_t sg;
   1227 
   1228 	SPARC32TOP_UAP(path, const char);
   1229 	sg = stackgap_init(p->p_emul);
   1230 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   1231 
   1232 	return (sys_revoke(p, &ua, retval));
   1233 }
   1234 
   1235 int
   1236 compat_sparc32_symlink(p, v, retval)
   1237 	struct proc *p;
   1238 	void *v;
   1239 	register_t *retval;
   1240 {
   1241 	struct compat_sparc32_symlink_args /* {
   1242 		syscallarg(const sparc32_charp) path;
   1243 		syscallarg(const sparc32_charp) link;
   1244 	} */ *uap = v;
   1245 	struct sys_symlink_args ua;
   1246 
   1247 	SPARC32TOP_UAP(path, const char);
   1248 	SPARC32TOP_UAP(link, const char);
   1249 
   1250 	return (sys_symlink(p, &ua, retval));
   1251 }
   1252 
   1253 int
   1254 compat_sparc32_readlink(p, v, retval)
   1255 	struct proc *p;
   1256 	void *v;
   1257 	register_t *retval;
   1258 {
   1259 	struct compat_sparc32_readlink_args /* {
   1260 		syscallarg(const sparc32_charp) path;
   1261 		syscallarg(sparc32_charp) buf;
   1262 		syscallarg(sparc32_size_t) count;
   1263 	} */ *uap = v;
   1264 	struct sys_readlink_args ua;
   1265 	caddr_t sg;
   1266 
   1267 	SPARC32TOP_UAP(path, const char);
   1268 	SPARC32TOP_UAP(buf, char);
   1269 	SPARC32TOX_UAP(count, size_t);
   1270 	sg = stackgap_init(p->p_emul);
   1271 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   1272 
   1273 	return (sys_readlink(p, &ua, retval));
   1274 }
   1275 
   1276 int
   1277 compat_sparc32_execve(p, v, retval)
   1278 	struct proc *p;
   1279 	void *v;
   1280 	register_t *retval;
   1281 {
   1282 	struct compat_sparc32_execve_args /* {
   1283 		syscallarg(const sparc32_charp) path;
   1284 		syscallarg(sparc32_charpp) argp;
   1285 		syscallarg(sparc32_charpp) envp;
   1286 	} */ *uap = v;
   1287 	struct sys_execve_args ua;
   1288 	caddr_t sg;
   1289 
   1290 	SPARC32TOP_UAP(path, const char);
   1291 	SPARC32TOP_UAP(argp, char *);
   1292 	SPARC32TOP_UAP(envp, char *);
   1293 	sg = stackgap_init(p->p_emul);
   1294 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   1295 
   1296 	return (sys_execve(p, &ua, retval));
   1297 }
   1298 
   1299 int
   1300 compat_sparc32_chroot(p, v, retval)
   1301 	struct proc *p;
   1302 	void *v;
   1303 	register_t *retval;
   1304 {
   1305 	struct compat_sparc32_chroot_args /* {
   1306 		syscallarg(const sparc32_charp) path;
   1307 	} */ *uap = v;
   1308 	struct sys_chroot_args ua;
   1309 
   1310 	SPARC32TOP_UAP(path, const char);
   1311 	return (sys_chroot(p, &ua, retval));
   1312 }
   1313 
   1314 int
   1315 compat_sparc32_munmap(p, v, retval)
   1316 	struct proc *p;
   1317 	void *v;
   1318 	register_t *retval;
   1319 {
   1320 	struct compat_sparc32_munmap_args /* {
   1321 		syscallarg(sparc32_voidp) addr;
   1322 		syscallarg(sparc32_size_t) len;
   1323 	} */ *uap = v;
   1324 	struct sys_munmap_args ua;
   1325 
   1326 	SPARC32TOP_UAP(addr, void);
   1327 	SPARC32TOX_UAP(len, size_t);
   1328 	return (sys_munmap(p, &ua, retval));
   1329 }
   1330 
   1331 int
   1332 compat_sparc32_mprotect(p, v, retval)
   1333 	struct proc *p;
   1334 	void *v;
   1335 	register_t *retval;
   1336 {
   1337 	struct compat_sparc32_mprotect_args /* {
   1338 		syscallarg(sparc32_voidp) addr;
   1339 		syscallarg(sparc32_size_t) len;
   1340 		syscallarg(int) prot;
   1341 	} */ *uap = v;
   1342 	struct sys_mprotect_args ua;
   1343 
   1344 	SPARC32TOP_UAP(addr, void);
   1345 	SPARC32TOX_UAP(len, size_t);
   1346 	SPARC32TO64_UAP(prot);
   1347 	return (sys_mprotect(p, &ua, retval));
   1348 }
   1349 
   1350 int
   1351 compat_sparc32_madvise(p, v, retval)
   1352 	struct proc *p;
   1353 	void *v;
   1354 	register_t *retval;
   1355 {
   1356 	struct compat_sparc32_madvise_args /* {
   1357 		syscallarg(sparc32_voidp) addr;
   1358 		syscallarg(sparc32_size_t) len;
   1359 		syscallarg(int) behav;
   1360 	} */ *uap = v;
   1361 	struct sys_madvise_args ua;
   1362 
   1363 	SPARC32TOP_UAP(addr, void);
   1364 	SPARC32TOX_UAP(len, size_t);
   1365 	SPARC32TO64_UAP(behav);
   1366 	return (sys_madvise(p, &ua, retval));
   1367 }
   1368 
   1369 int
   1370 compat_sparc32_mincore(p, v, retval)
   1371 	struct proc *p;
   1372 	void *v;
   1373 	register_t *retval;
   1374 {
   1375 	struct compat_sparc32_mincore_args /* {
   1376 		syscallarg(sparc32_caddr_t) addr;
   1377 		syscallarg(sparc32_size_t) len;
   1378 		syscallarg(sparc32_charp) vec;
   1379 	} */ *uap = v;
   1380 	struct sys_mincore_args ua;
   1381 
   1382 	SPARC32TOX64_UAP(addr, caddr_t);
   1383 	SPARC32TOX_UAP(len, size_t);
   1384 	SPARC32TOP_UAP(vec, char);
   1385 	return (sys_mincore(p, &ua, retval));
   1386 }
   1387 
   1388 int
   1389 compat_sparc32_getgroups(p, v, retval)
   1390 	struct proc *p;
   1391 	void *v;
   1392 	register_t *retval;
   1393 {
   1394 	struct compat_sparc32_getgroups_args /* {
   1395 		syscallarg(int) gidsetsize;
   1396 		syscallarg(sparc32_gid_tp) gidset;
   1397 	} */ *uap = v;
   1398 	struct sys_getgroups_args ua;
   1399 
   1400 	SPARC32TO64_UAP(gidsetsize);
   1401 	SPARC32TOP_UAP(gidset, gid_t);
   1402 	return (sys_getgroups(p, &ua, retval));
   1403 }
   1404 
   1405 int
   1406 compat_sparc32_setgroups(p, v, retval)
   1407 	struct proc *p;
   1408 	void *v;
   1409 	register_t *retval;
   1410 {
   1411 	struct compat_sparc32_setgroups_args /* {
   1412 		syscallarg(int) gidsetsize;
   1413 		syscallarg(const sparc32_gid_tp) gidset;
   1414 	} */ *uap = v;
   1415 	struct sys_setgroups_args ua;
   1416 
   1417 	SPARC32TO64_UAP(gidsetsize);
   1418 	SPARC32TOP_UAP(gidset, gid_t);
   1419 	return (sys_setgroups(p, &ua, retval));
   1420 }
   1421 
   1422 int
   1423 compat_sparc32_setitimer(p, v, retval)
   1424 	struct proc *p;
   1425 	void *v;
   1426 	register_t *retval;
   1427 {
   1428 	struct compat_sparc32_setitimer_args /* {
   1429 		syscallarg(int) which;
   1430 		syscallarg(const sparc32_itimervalp_t) itv;
   1431 		syscallarg(sparc32_itimervalp_t) oitv;
   1432 	} */ *uap = v;
   1433 	struct sys_setitimer_args ua;
   1434 	struct itimerval iit, oit;
   1435 	struct sparc32_itimerval *s32itp, s32it;
   1436 	int error;
   1437 
   1438 	SPARC32TO64_UAP(which);
   1439 	s32itp = (struct sparc32_itimerval *)(u_long)SCARG(uap, itv);
   1440 	if (s32itp) {
   1441 		if (copyin(s32itp, &s32it, sizeof(s32it)))
   1442 			return EFAULT;
   1443 		SCARG(&ua, itv) = &iit;
   1444 		sparc32_to_itimerval(&s32it, &iit);
   1445 	} else
   1446 		SCARG(&ua, itv) = NULL;
   1447 	s32itp = (struct sparc32_itimerval *)(u_long)SCARG(uap, oitv);
   1448 	if (s32itp)
   1449 		SCARG(&ua, oitv) = &oit;
   1450 	else
   1451 		SCARG(&ua, oitv) = NULL;
   1452 
   1453 	error = sys_setitimer(p, &ua, retval);
   1454 	if (error)
   1455 		return (error);
   1456 
   1457 	if (s32itp) {
   1458 		sparc32_from_itimerval(&oit, &s32it);
   1459 		if (copyout(&s32it, s32itp, sizeof(s32it)))
   1460 			return EFAULT;
   1461 	}
   1462 	return (0);
   1463 }
   1464 
   1465 int
   1466 compat_sparc32_getitimer(p, v, retval)
   1467 	struct proc *p;
   1468 	void *v;
   1469 	register_t *retval;
   1470 {
   1471 	struct compat_sparc32_getitimer_args /* {
   1472 		syscallarg(int) which;
   1473 		syscallarg(sparc32_itimervalp_t) itv;
   1474 	} */ *uap = v;
   1475 	struct sys_getitimer_args ua;
   1476 	struct itimerval it;
   1477 	struct sparc32_itimerval *s32itp, s32it;
   1478 	int error;
   1479 
   1480 	SPARC32TO64_UAP(which);
   1481 	s32itp = (struct sparc32_itimerval *)(u_long)SCARG(uap, itv);
   1482 	if (s32itp == NULL)
   1483 		SCARG(&ua, itv) = &it;
   1484 	else
   1485 		SCARG(&ua, itv) = NULL;
   1486 
   1487 	error = sys_getitimer(p, &ua, retval);
   1488 	if (error)
   1489 		return (error);
   1490 
   1491 	if (s32itp) {
   1492 		sparc32_from_itimerval(&it, &s32it);
   1493 		if (copyout(&s32it, s32itp, sizeof(s32it)))
   1494 			return EFAULT;
   1495 	}
   1496 	return (0);
   1497 }
   1498 
   1499 int
   1500 compat_sparc32_fcntl(p, v, retval)
   1501 	struct proc *p;
   1502 	void *v;
   1503 	register_t *retval;
   1504 {
   1505 	struct compat_sparc32_fcntl_args /* {
   1506 		syscallarg(int) fd;
   1507 		syscallarg(int) cmd;
   1508 		syscallarg(sparc32_voidp) arg;
   1509 	} */ *uap = v;
   1510 	struct sys_fcntl_args ua;
   1511 
   1512 	SPARC32TO64_UAP(fd);
   1513 	SPARC32TO64_UAP(cmd);
   1514 	SPARC32TOP_UAP(arg, void);
   1515 	return (sys_fcntl(p, &ua, retval));
   1516 }
   1517 
   1518 int
   1519 compat_sparc32_select(p, v, retval)
   1520 	struct proc *p;
   1521 	void *v;
   1522 	register_t *retval;
   1523 {
   1524 	struct compat_sparc32_select_args /* {
   1525 		syscallarg(int) nd;
   1526 		syscallarg(sparc32_fd_setp_t) in;
   1527 		syscallarg(sparc32_fd_setp_t) ou;
   1528 		syscallarg(sparc32_fd_setp_t) ex;
   1529 		syscallarg(sparc32_timevalp_t) tv;
   1530 	} */ *uap = v;
   1531 	struct sys_select_args ua;
   1532 	struct timeval tv;
   1533 	struct sparc32_timeval *tv32p, tv32;
   1534 	int error;
   1535 
   1536 	SPARC32TO64_UAP(nd);
   1537 	SPARC32TOP_UAP(in, fd_set);
   1538 	SPARC32TOP_UAP(ou, fd_set);
   1539 	SPARC32TOP_UAP(ex, fd_set);
   1540 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tv);
   1541 	if (tv32p) {
   1542 		if (copyin(tv32p &tv32, sizeof(tv32)))
   1543 			return EFAULT;
   1544 		sparc32_to_timeval(&tv32, &tv);
   1545 	}
   1546 	SCARG(&ua, tv) = &tv;
   1547 
   1548 	error = sys_select(p, &ua, retval);
   1549 	if (tv32p) {
   1550 		sparc32_from_timeval(&tv, &tv32);
   1551 		if (copyout(&tv32 tv32p, sizeof(tv32)))
   1552 			return EFAULT;
   1553 	}
   1554 
   1555 	return (error);
   1556 }
   1557 
   1558 int
   1559 compat_sparc32_connect(p, v, retval)
   1560 	struct proc *p;
   1561 	void *v;
   1562 	register_t *retval;
   1563 {
   1564 	struct compat_sparc32_connect_args /* {
   1565 		syscallarg(int) s;
   1566 		syscallarg(const sparc32_sockaddrp_t) name;
   1567 		syscallarg(int) namelen;
   1568 	} */ *uap = v;
   1569 	struct sys_connect_args ua;
   1570 
   1571 	SPARC32TO64_UAP(s);
   1572 	SPARC32TOP_UAP(name, struct sockaddr);
   1573 	SPARC32TO64_UAP(namelen);
   1574 	return (sys_connect(p, &ua, retval));
   1575 }
   1576 
   1577 #undef DEBUG
   1578 int
   1579 compat_sparc32_sigreturn(p, v, retval)
   1580 	struct proc *p;
   1581 	void *v;
   1582 	register_t *retval;
   1583 {
   1584 	struct compat_sparc32_sigreturn_args /* {
   1585 		syscallarg(struct sparc32_sigcontext *) sigcntxp;
   1586 	} */ *uap = v;
   1587 	struct sparc32_sigcontext *scp;
   1588 	struct sparc32_sigcontext sc;
   1589 	register struct trapframe *tf;
   1590 	struct rwindow32 *rwstack, *kstack;
   1591 	int i;
   1592 
   1593 	/* First ensure consistent stack state (see sendsig). */
   1594 	write_user_windows();
   1595 	if (rwindow_save(p)) {
   1596 #ifdef DEBUG
   1597 		printf("sigreturn: rwindow_save(%p) failed, sending SIGILL\n", p);
   1598 		Debugger();
   1599 #endif
   1600 		sigexit(p, SIGILL);
   1601 	}
   1602 #ifdef DEBUG
   1603 	if (sigdebug & SDB_FOLLOW) {
   1604 		printf("sigreturn: %s[%d], sigcntxp %p\n",
   1605 		    p->p_comm, p->p_pid, SCARG(uap, sigcntxp));
   1606 		if (sigdebug & SDB_DDB) Debugger();
   1607 	}
   1608 #endif
   1609 	scp = SCARG(uap, sigcntxp);
   1610  	if ((int)scp & 3 || (copyin((caddr_t)scp, &sc, sizeof sc) != 0))
   1611 #ifdef DEBUG
   1612 	{
   1613 		printf("sigreturn: copyin failed\n");
   1614 		Debugger();
   1615 		return (EINVAL);
   1616 	}
   1617 #else
   1618 		return (EINVAL);
   1619 #endif
   1620 	tf = p->p_md.md_tf;
   1621 	/*
   1622 	 * Only the icc bits in the psr are used, so it need not be
   1623 	 * verified.  pc and npc must be multiples of 4.  This is all
   1624 	 * that is required; if it holds, just do it.
   1625 	 */
   1626 	if (((sc.sc_pc | sc.sc_npc) & 3) != 0)
   1627 #ifdef DEBUG
   1628 	{
   1629 		printf("sigreturn: pc %p or npc %p invalid\n", sc.sc_pc, sc.sc_npc);
   1630 		Debugger();
   1631 		return (EINVAL);
   1632 	}
   1633 #else
   1634 		return (EINVAL);
   1635 #endif
   1636 	/* take only psr ICC field */
   1637 	tf->tf_tstate = (int64_t)(tf->tf_tstate & ~TSTATE_CCR) | PSRCC_TO_TSTATE(sc.sc_psr);
   1638 	tf->tf_pc = (int64_t)sc.sc_pc;
   1639 	tf->tf_npc = (int64_t)sc.sc_npc;
   1640 	tf->tf_global[1] = (int64_t)sc.sc_g1;
   1641 	tf->tf_out[0] = (int64_t)sc.sc_o0;
   1642 	tf->tf_out[6] = (int64_t)sc.sc_sp;
   1643 	rwstack = (struct rwindow32 *)tf->tf_out[6];
   1644 	kstack = (struct rwindow32 *)(((caddr_t)tf)-CCFSZ);
   1645 	for (i=0; i<8; i++) {
   1646 		int tmp;
   1647 		if (copyin((caddr_t)&rwstack->rw_local[i], &tmp, sizeof tmp)) {
   1648 			printf("sigreturn: cannot load \%l%d from %p\n", i, &rwstack->rw_local[i]);
   1649 			Debugger();
   1650 		}
   1651 		tf->tf_local[i] = (int64_t)tmp;
   1652 		if (copyin((caddr_t)&rwstack->rw_in[i], &tmp, sizeof tmp)) {
   1653 			printf("sigreturn: cannot load \%i%d from %p\n", i, &rwstack->rw_in[i]);
   1654 			Debugger();
   1655 		}
   1656 		tf->tf_in[i] = (int)tmp;
   1657 	}
   1658 #ifdef DEBUG
   1659 	/* Need to sync tf locals and ins with stack to prevent panic */
   1660 	{
   1661 		int i;
   1662 
   1663 		kstack = (struct rwindow32 *)tf->tf_out[6];
   1664 		for (i=0; i<8; i++) {
   1665 			tf->tf_local[i] = fuword(&kstack->rw_local[i]);
   1666 			tf->tf_in[i] = fuword(&kstack->rw_in[i]);
   1667 		}
   1668 	}
   1669 #endif
   1670 #ifdef DEBUG
   1671 	if (sigdebug & SDB_FOLLOW) {
   1672 		printf("sys_sigreturn: return trapframe pc=%p sp=%p tstate=%x\n",
   1673 		       (int)tf->tf_pc, (int)tf->tf_out[6], (int)tf->tf_tstate);
   1674 		if (sigdebug & SDB_DDB) Debugger();
   1675 	}
   1676 #endif
   1677 	if (sc.sc_onstack & 1)
   1678 		p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
   1679 	else
   1680 		p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
   1681 	p->p_sigmask = sc.sc_mask & ~sigcantmask;
   1682 	return (EJUSTRETURN);
   1683 }
   1684 
   1685 
   1686 int
   1687 compat_sparc32_bind(p, v, retval)
   1688 	struct proc *p;
   1689 	void *v;
   1690 	register_t *retval;
   1691 {
   1692 	struct compat_sparc32_bind_args /* {
   1693 		syscallarg(int) s;
   1694 		syscallarg(const sparc32_sockaddrp_t) name;
   1695 		syscallarg(int) namelen;
   1696 	} */ *uap = v;
   1697 	struct sys_connect_args ua;
   1698 
   1699 	SPARC32TO64_UAP(s);
   1700 	SPARC32TOP_UAP(name, struct sockaddr);
   1701 	SPARC32TO64_UAP(namelen);
   1702 	return (sys_connect(p, &ua, retval));
   1703 }
   1704 
   1705 int
   1706 compat_sparc32_setsockopt(p, v, retval)
   1707 	struct proc *p;
   1708 	void *v;
   1709 	register_t *retval;
   1710 {
   1711 	struct compat_sparc32_setsockopt_args /* {
   1712 		syscallarg(int) s;
   1713 		syscallarg(int) level;
   1714 		syscallarg(int) name;
   1715 		syscallarg(const sparc32_voidp) val;
   1716 		syscallarg(int) valsize;
   1717 	} */ *uap = v;
   1718 	struct sys_setsockopt_args ua;
   1719 
   1720 	SPARC32TO64_UAP(s);
   1721 	SPARC32TO64_UAP(level);
   1722 	SPARC32TO64_UAP(name);
   1723 	SPARC32TOP_UAP(val, void);
   1724 	SPARC32TO64_UAP(valsize);
   1725 	return (sys_setsockopt(p, &ua, retval));
   1726 }
   1727 
   1728 int
   1729 compat_sparc32_gettimeofday(p, v, retval)
   1730 	struct proc *p;
   1731 	void *v;
   1732 	register_t *retval;
   1733 {
   1734 	struct compat_sparc32_gettimeofday_args /* {
   1735 		syscallarg(sparc32_timevalp_t) tp;
   1736 		syscallarg(sparc32_timezonep_t) tzp;
   1737 	} */ *uap = v;
   1738 	struct sys_gettimeofday_args ua;
   1739 	struct timeval tv;
   1740 	struct sparc32_timeval *tv32p, tv32;
   1741 	int error;
   1742 
   1743 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tp);
   1744 	if (tv32p) {
   1745 		SCARG(&ua, tp) = &tv;
   1746 		if (copyin(tv32p, &tv32, sizeof(tv32)))
   1747 			return EINVAL;
   1748 		sparc32_to_timeval(tv32p, &tv);
   1749 	} else
   1750 		SCARG(&ua, tp) = NULL;
   1751 	SPARC32TOP_UAP(tzp, struct timezone)
   1752 
   1753 	error = sys_gettimeofday(p, &ua, retval);
   1754 	if (error)
   1755 		return (error);
   1756 
   1757 	if (tv32p)
   1758 		sparc32_from_timeval(&tv, tv32p);
   1759 
   1760 	return (0);
   1761 }
   1762 
   1763 int
   1764 compat_sparc32_settimeofday(p, v, retval)
   1765 	struct proc *p;
   1766 	void *v;
   1767 	register_t *retval;
   1768 {
   1769 	struct compat_sparc32_settimeofday_args /* {
   1770 		syscallarg(const sparc32_timevalp_t) tv;
   1771 		syscallarg(const sparc32_timezonep_t) tzp;
   1772 	} */ *uap = v;
   1773 	struct sys_settimeofday_args ua;
   1774 	struct timeval tv;
   1775 	struct sparc32_timeval *tv32p;
   1776 	int error;
   1777 
   1778 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tv);
   1779 	if (tv32p) {
   1780 		SCARG(&ua, tv) = &tv;
   1781 		sparc32_to_timeval(tv32p, &tv);
   1782 	} else
   1783 		SCARG(&ua, tv) = NULL;
   1784 	SPARC32TOP_UAP(tzp, struct timezone)
   1785 
   1786 	error = sys_settimeofday(p, &ua, retval);
   1787 	if (error)
   1788 		return (error);
   1789 
   1790 	if (tv32p)
   1791 		sparc32_from_timeval(&tv, tv32p);
   1792 
   1793 	return (0);
   1794 }
   1795 
   1796 int
   1797 compat_sparc32_getrusage(p, v, retval)
   1798 	struct proc *p;
   1799 	void *v;
   1800 	register_t *retval;
   1801 {
   1802 	struct compat_sparc32_getrusage_args /* {
   1803 		syscallarg(int) who;
   1804 		syscallarg(sparc32_rusagep_t) rusage;
   1805 	} */ *uap = v;
   1806 	struct sys_getrusage_args ua;
   1807 	struct rusage ru;
   1808 	struct sparc32_rusage *ru32p;
   1809 	int error;
   1810 
   1811 	SPARC32TO64_UAP(who);
   1812 	ru32p = (struct sparc32_rusage *)(u_long)SCARG(uap, rusage);
   1813 	if (ru32p) {
   1814 		SCARG(&ua, rusage) = &ru;
   1815 		sparc32_to_rusage(ru32p, &ru);
   1816 	} else
   1817 		SCARG(&ua, rusage) = NULL;
   1818 
   1819 	error = sys_getrusage(p, &ua, retval);
   1820 	if (ru32p)
   1821 		sparc32_from_rusage(&ru, ru32p);
   1822 
   1823 	return (error);
   1824 }
   1825 
   1826 int
   1827 compat_sparc32_getsockopt(p, v, retval)
   1828 	struct proc *p;
   1829 	void *v;
   1830 	register_t *retval;
   1831 {
   1832 	struct compat_sparc32_getsockopt_args /* {
   1833 		syscallarg(int) s;
   1834 		syscallarg(int) level;
   1835 		syscallarg(int) name;
   1836 		syscallarg(sparc32_voidp) val;
   1837 		syscallarg(sparc32_intp) avalsize;
   1838 	} */ *uap = v;
   1839 	struct sys_getsockopt_args ua;
   1840 
   1841 	SPARC32TO64_UAP(s);
   1842 	SPARC32TO64_UAP(level);
   1843 	SPARC32TO64_UAP(name);
   1844 	SPARC32TOP_UAP(val, void)
   1845 	SPARC32TOP_UAP(avalsize, int);
   1846 	return (sys_getsockopt(p, &ua, retval));
   1847 }
   1848 
   1849 int
   1850 compat_sparc32_readv(p, v, retval)
   1851 	struct proc *p;
   1852 	void *v;
   1853 	register_t *retval;
   1854 {
   1855 	struct compat_sparc32_readv_args /* {
   1856 		syscallarg(int) fd;
   1857 		syscallarg(const sparc32_iovecp_t) iovp;
   1858 		syscallarg(int) iovcnt;
   1859 	} */ *uap = v;
   1860 	struct sys_readv_args ua;
   1861 	struct iovec *iov;
   1862 	ssize_t rt;
   1863 	int error;
   1864 
   1865 	SPARC32TO64_UAP(fd)
   1866 	SPARC32TO64_UAP(iovcnt);
   1867 	MALLOC(iov, struct iovec *,
   1868 	    sizeof(struct iovec) * SCARG(uap, iovcnt), M_TEMP, M_WAITOK);
   1869 	sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
   1870 	    SCARG(uap, iovcnt));
   1871 	SCARG(&ua, iovp) = iov;
   1872 
   1873 	error = sys_readv(p, &ua, (register_t *)&rt);
   1874 	FREE(iov, M_TEMP);
   1875 	*(sparc32_ssize_t *)retval = rt;
   1876 	return (error);
   1877 }
   1878 
   1879 int
   1880 compat_sparc32_writev(p, v, retval)
   1881 	struct proc *p;
   1882 	void *v;
   1883 	register_t *retval;
   1884 {
   1885 	struct compat_sparc32_writev_args /* {
   1886 		syscallarg(int) fd;
   1887 		syscallarg(const sparc32_iovecp_t) iovp;
   1888 		syscallarg(int) iovcnt;
   1889 	} */ *uap = v;
   1890 	struct sys_writev_args ua;
   1891 	struct iovec *iov;
   1892 	ssize_t rt;
   1893 	int error;
   1894 
   1895 	SPARC32TO64_UAP(fd)
   1896 	SPARC32TO64_UAP(iovcnt);
   1897 	MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt),
   1898 	    M_TEMP, M_WAITOK);
   1899 	sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
   1900 	    SCARG(uap, iovcnt));
   1901 	SCARG(&ua, iovp) = iov;
   1902 
   1903 	error = sys_writev(p, &ua, (register_t *)&rt);
   1904 	FREE(iov, M_TEMP);
   1905 	*(sparc32_ssize_t *)retval = rt;
   1906 	return (error);
   1907 }
   1908 
   1909 int
   1910 compat_sparc32_rename(p, v, retval)
   1911 	struct proc *p;
   1912 	void *v;
   1913 	register_t *retval;
   1914 {
   1915 	struct compat_sparc32_rename_args /* {
   1916 		syscallarg(const sparc32_charp) from;
   1917 		syscallarg(const sparc32_charp) to;
   1918 	} */ *uap = v;
   1919 	struct sys_rename_args ua;
   1920 
   1921 	SPARC32TOP_UAP(from, const char)
   1922 	SPARC32TOP_UAP(to, const char)
   1923 	return (sys_rename(p, &ua, retval));
   1924 }
   1925 
   1926 int
   1927 compat_sparc32_mkfifo(p, v, retval)
   1928 	struct proc *p;
   1929 	void *v;
   1930 	register_t *retval;
   1931 {
   1932 	struct compat_sparc32_mkfifo_args /* {
   1933 		syscallarg(const sparc32_charp) path;
   1934 		syscallarg(mode_t) mode;
   1935 	} */ *uap = v;
   1936 	struct sys_mkfifo_args ua;
   1937 
   1938 	SPARC32TOP_UAP(path, const char)
   1939 	SPARC32TO64_UAP(mode);
   1940 	return (sys_mkfifo(p, &ua, retval));
   1941 }
   1942 
   1943 int
   1944 compat_sparc32_mkdir(p, v, retval)
   1945 	struct proc *p;
   1946 	void *v;
   1947 	register_t *retval;
   1948 {
   1949 	struct compat_sparc32_mkdir_args /* {
   1950 		syscallarg(const sparc32_charp) path;
   1951 		syscallarg(mode_t) mode;
   1952 	} */ *uap = v;
   1953 	struct sys_mkdir_args ua;
   1954 
   1955 	SPARC32TOP_UAP(path, const char)
   1956 	SPARC32TO64_UAP(mode);
   1957 	return (sys_mkdir(p, &ua, retval));
   1958 }
   1959 
   1960 int
   1961 compat_sparc32_rmdir(p, v, retval)
   1962 	struct proc *p;
   1963 	void *v;
   1964 	register_t *retval;
   1965 {
   1966 	struct compat_sparc32_rmdir_args /* {
   1967 		syscallarg(const sparc32_charp) path;
   1968 	} */ *uap = v;
   1969 	struct sys_rmdir_args ua;
   1970 
   1971 	SPARC32TOP_UAP(path, const char);
   1972 	return (sys_rmdir(p, &ua, retval));
   1973 }
   1974 
   1975 int
   1976 compat_sparc32_utimes(p, v, retval)
   1977 	struct proc *p;
   1978 	void *v;
   1979 	register_t *retval;
   1980 {
   1981 	struct compat_sparc32_utimes_args /* {
   1982 		syscallarg(const sparc32_charp) path;
   1983 		syscallarg(const sparc32_timevalp_t) tptr;
   1984 	} */ *uap = v;
   1985 	struct sys_utimes_args ua;
   1986 	struct timeval tv;
   1987 	struct sparc32_timeval *tv32p;
   1988 
   1989 	SPARC32TOP_UAP(path, const char);
   1990 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr);
   1991 	if (tv32p) {
   1992 		SCARG(&ua, tptr) = &tv;
   1993 		sparc32_to_timeval(tv32p, &tv);
   1994 	} else
   1995 		SCARG(&ua, tptr) = NULL;
   1996 
   1997 	return (sys_utimes(p, &ua, retval));
   1998 }
   1999 
   2000 int
   2001 compat_sparc32_adjtime(p, v, retval)
   2002 	struct proc *p;
   2003 	void *v;
   2004 	register_t *retval;
   2005 {
   2006 	struct compat_sparc32_adjtime_args /* {
   2007 		syscallarg(const sparc32_timevalp_t) delta;
   2008 		syscallarg(sparc32_timevalp_t) olddelta;
   2009 	} */ *uap = v;
   2010 	struct sys_adjtime_args ua;
   2011 	struct timeval tv, otv;
   2012 	struct sparc32_timeval *tv32p, *otv32p;
   2013 	int error;
   2014 
   2015 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, delta);
   2016 	otv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, olddelta);
   2017 
   2018 	if (tv32p) {
   2019 		SCARG(&ua, delta) = &tv;
   2020 		sparc32_to_timeval(tv32p, &tv);
   2021 	} else
   2022 		SCARG(&ua, delta) = NULL;
   2023 	if (otv32p)
   2024 		SCARG(&ua, olddelta) = &otv;
   2025 	else
   2026 		SCARG(&ua, olddelta) = NULL;
   2027 	error = sys_adjtime(p, &ua, retval);
   2028 	if (error)
   2029 		return (error);
   2030 
   2031 	if (otv32p)
   2032 		sparc32_from_timeval(&otv, otv32p);
   2033 	return (0);
   2034 }
   2035 
   2036 int
   2037 compat_sparc32_quotactl(p, v, retval)
   2038 	struct proc *p;
   2039 	void *v;
   2040 	register_t *retval;
   2041 {
   2042 	struct compat_sparc32_quotactl_args /* {
   2043 		syscallarg(const sparc32_charp) path;
   2044 		syscallarg(int) cmd;
   2045 		syscallarg(int) uid;
   2046 		syscallarg(sparc32_caddr_t) arg;
   2047 	} */ *uap = v;
   2048 	struct sys_quotactl_args ua;
   2049 
   2050 	SPARC32TOP_UAP(path, const char);
   2051 	SPARC32TO64_UAP(cmd);
   2052 	SPARC32TO64_UAP(uid);
   2053 	SPARC32TOX64_UAP(arg, caddr_t);
   2054 	return (sys_quotactl(p, &ua, retval));
   2055 }
   2056 
   2057 int
   2058 compat_sparc32_nfssvc(p, v, retval)
   2059 	struct proc *p;
   2060 	void *v;
   2061 	register_t *retval;
   2062 {
   2063 	struct compat_sparc32_nfssvc_args /* {
   2064 		syscallarg(int) flag;
   2065 		syscallarg(sparc32_voidp) argp;
   2066 	} */ *uap = v;
   2067 	struct sys_nfssvc_args ua;
   2068 
   2069 	SPARC32TO64_UAP(flag);
   2070 	SPARC32TOP_UAP(argp, void);
   2071 	return (sys_nfssvc(p, &ua, retval));
   2072 }
   2073 
   2074 int
   2075 compat_sparc32_statfs(p, v, retval)
   2076 	struct proc *p;
   2077 	void *v;
   2078 	register_t *retval;
   2079 {
   2080 	struct compat_sparc32_statfs_args /* {
   2081 		syscallarg(const sparc32_charp) path;
   2082 		syscallarg(sparc32_statfsp_t) buf;
   2083 	} */ *uap = v;
   2084 	struct sys_statfs_args ua;
   2085 	struct statfs sb;
   2086 	struct sparc32_statfs *sb32p;
   2087 	caddr_t sg;
   2088 	int error;
   2089 
   2090 	SPARC32TOP_UAP(path, const char);
   2091 	sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf);
   2092 	if (sb32p)
   2093 		SCARG(&ua, buf) = &sb;
   2094 	else
   2095 		SCARG(&ua, buf) = NULL;
   2096 	sg = stackgap_init(p->p_emul);
   2097 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   2098 	error = sys_statfs(p, &ua, retval);
   2099 	if (error)
   2100 		return (error);
   2101 
   2102 	if (sb32p)
   2103 		sparc32_from_statfs(&sb, sb32p);
   2104 	return (0);
   2105 }
   2106 
   2107 int
   2108 compat_sparc32_fstatfs(p, v, retval)
   2109 	struct proc *p;
   2110 	void *v;
   2111 	register_t *retval;
   2112 {
   2113 	struct compat_sparc32_fstatfs_args /* {
   2114 		syscallarg(int) fd;
   2115 		syscallarg(sparc32_statfsp_t) buf;
   2116 	} */ *uap = v;
   2117 	struct sys_fstatfs_args ua;
   2118 	struct statfs sb;
   2119 	struct sparc32_statfs *sb32p;
   2120 	int error;
   2121 
   2122 	SPARC32TO64_UAP(fd);
   2123 	sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf);
   2124 	if (sb32p)
   2125 		SCARG(&ua, buf) = &sb;
   2126 	else
   2127 		SCARG(&ua, buf) = NULL;
   2128 	error = sys_fstatfs(p, &ua, retval);
   2129 	if (error)
   2130 		return (error);
   2131 
   2132 	if (sb32p)
   2133 		sparc32_from_statfs(&sb, sb32p);
   2134 	return (0);
   2135 }
   2136 
   2137 int
   2138 compat_sparc32_getfh(p, v, retval)
   2139 	struct proc *p;
   2140 	void *v;
   2141 	register_t *retval;
   2142 {
   2143 	struct compat_sparc32_getfh_args /* {
   2144 		syscallarg(const sparc32_charp) fname;
   2145 		syscallarg(sparc32_fhandlep_t) fhp;
   2146 	} */ *uap = v;
   2147 	struct sys_getfh_args ua;
   2148 
   2149 	SPARC32TOP_UAP(fname, const char);
   2150 	SPARC32TOP_UAP(fhp, struct fhandle);
   2151 	return (sys_getfh(p, &ua, retval));
   2152 }
   2153 
   2154 int
   2155 compat_sparc32_sysarch(p, v, retval)
   2156 	struct proc *p;
   2157 	void *v;
   2158 	register_t *retval;
   2159 {
   2160 	struct compat_sparc32_sysarch_args /* {
   2161 		syscallarg(int) op;
   2162 		syscallarg(sparc32_voidp) parms;
   2163 	} */ *uap = v;
   2164 	struct sys_sysarch_args ua;
   2165 
   2166 	SPARC32TO64_UAP(op);
   2167 	SPARC32TOP_UAP(parms, void);
   2168 	return (sys_getfh(p, &ua, retval));
   2169 }
   2170 
   2171 int
   2172 compat_sparc32_pread(p, v, retval)
   2173 	struct proc *p;
   2174 	void *v;
   2175 	register_t *retval;
   2176 {
   2177 	struct compat_sparc32_pread_args /* {
   2178 		syscallarg(int) fd;
   2179 		syscallarg(sparc32_voidp) buf;
   2180 		syscallarg(sparc32_size_t) nbyte;
   2181 		syscallarg(int) pad;
   2182 		syscallarg(off_t) offset;
   2183 	} */ *uap = v;
   2184 	struct sys_pread_args ua;
   2185 	ssize_t rt;
   2186 	int error;
   2187 
   2188 	SPARC32TO64_UAP(fd);
   2189 	SPARC32TOP_UAP(buf, void);
   2190 	SPARC32TOX_UAP(nbyte, size_t);
   2191 	SPARC32TO64_UAP(pad);
   2192 	SPARC32TO64_UAP(offset);
   2193 	error = sys_pread(p, &ua, (register_t *)&rt);
   2194 	*(sparc32_ssize_t *)retval = rt;
   2195 	return (error);
   2196 }
   2197 
   2198 int
   2199 compat_sparc32_pwrite(p, v, retval)
   2200 	struct proc *p;
   2201 	void *v;
   2202 	register_t *retval;
   2203 {
   2204 	struct compat_sparc32_pwrite_args /* {
   2205 		syscallarg(int) fd;
   2206 		syscallarg(const sparc32_voidp) buf;
   2207 		syscallarg(sparc32_size_t) nbyte;
   2208 		syscallarg(int) pad;
   2209 		syscallarg(off_t) offset;
   2210 	} */ *uap = v;
   2211 	struct sys_pwrite_args ua;
   2212 	ssize_t rt;
   2213 	int error;
   2214 
   2215 	SPARC32TO64_UAP(fd);
   2216 	SPARC32TOP_UAP(buf, void);
   2217 	SPARC32TOX_UAP(nbyte, size_t);
   2218 	SPARC32TO64_UAP(pad);
   2219 	SPARC32TO64_UAP(offset);
   2220 	error = sys_pwrite(p, &ua, (register_t *)&rt);
   2221 	*(sparc32_ssize_t *)retval = rt;
   2222 	return (error);
   2223 }
   2224 
   2225 int
   2226 compat_sparc32_ntp_gettime(p, v, retval)
   2227 	struct proc *p;
   2228 	void *v;
   2229 	register_t *retval;
   2230 {
   2231 	struct compat_sparc32_ntp_gettime_args /* {
   2232 		syscallarg(sparc32_ntptimevalp_t) ntvp;
   2233 	} */ *uap = v;
   2234 	struct sys_ntp_gettime_args ua;
   2235 	struct ntptimeval ntv;
   2236 	struct sparc32_ntptimeval *ntv32p;
   2237 	int error;
   2238 
   2239 	ntv32p = (struct sparc32_ntptimeval *)(u_long)SCARG(uap, ntvp);
   2240 	if (ntv32p)
   2241 		SCARG(&ua, ntvp) = &ntv;
   2242 	else
   2243 		SCARG(&ua, ntvp) = NULL;
   2244 	error = sys_ntp_gettime(p, &ua, retval);
   2245 	if (error)
   2246 		return (error);
   2247 
   2248 	if (ntv32p) {
   2249 		sparc32_from_timeval(&ntv, ntv32p);
   2250 		ntv32.maxerror = (sparc32_long)ntv.maxerror;
   2251 		ntv32.esterror = (sparc32_long)ntv.esterror;
   2252 	}
   2253 	return (0);
   2254 }
   2255 
   2256 int
   2257 compat_sparc32_ntp_adjtime(p, v, retval)
   2258 	struct proc *p;
   2259 	void *v;
   2260 	register_t *retval;
   2261 {
   2262 	struct compat_sparc32_ntp_adjtime_args /* {
   2263 		syscallarg(sparc32_timexp_t) tp;
   2264 	} */ *uap = v;
   2265 	struct sys_ntp_adjtime_args ua;
   2266 	struct timex tx;
   2267 	struct sparc32_timex *tx32p;
   2268 	int error;
   2269 
   2270 	tx32p = (struct sparc32_timex *)(u_long)SCARG(uap, tp);
   2271 	if (tx32p) {
   2272 		SCARG(&ua, tp) = &tx;
   2273 		sparc32_to_timex(tx32p, &tx);
   2274 	} else
   2275 		SCARG(&ua, tp) = NULL;
   2276 	error = sys_ntp_adjtime(p, &ua, retval);
   2277 	if (error)
   2278 		return (error);
   2279 
   2280 	if (tx32p)
   2281 		sparc32_from_timeval(&tx, tx32p);
   2282 	return (0);
   2283 }
   2284 
   2285 int
   2286 compat_sparc32_lfs_bmapv(p, v, retval)
   2287 	struct proc *p;
   2288 	void *v;
   2289 	register_t *retval;
   2290 {
   2291 	struct compat_sparc32_lfs_bmapv_args /* {
   2292 		syscallarg(sparc32_fsid_tp_t) fsidp;
   2293 		syscallarg(sparc32_block_infop_t) blkiov;
   2294 		syscallarg(int) blkcnt;
   2295 	} */ *uap = v;
   2296 #if 0
   2297 	struct sys_lfs_bmapv_args ua;
   2298 
   2299 	SPARC32TOP_UAP(fdidp, struct fsid);
   2300 	SPARC32TO64_UAP(blkcnt);
   2301 	/* XXX finish me */
   2302 #else
   2303 
   2304 	return (ENOSYS);	/* XXX */
   2305 #endif
   2306 }
   2307 
   2308 int
   2309 compat_sparc32_lfs_markv(p, v, retval)
   2310 	struct proc *p;
   2311 	void *v;
   2312 	register_t *retval;
   2313 {
   2314 	struct compat_sparc32_lfs_markv_args /* {
   2315 		syscallarg(sparc32_fsid_tp_t) fsidp;
   2316 		syscallarg(sparc32_block_infop_t) blkiov;
   2317 		syscallarg(int) blkcnt;
   2318 	} */ *uap = v;
   2319 
   2320 	return (ENOSYS);	/* XXX */
   2321 }
   2322 
   2323 int
   2324 compat_sparc32_lfs_segclean(p, v, retval)
   2325 	struct proc *p;
   2326 	void *v;
   2327 	register_t *retval;
   2328 {
   2329 	struct compat_sparc32_lfs_segclean_args /* {
   2330 		syscallarg(sparc32_fsid_tp_t) fsidp;
   2331 		syscallarg(sparc32_u_long) segment;
   2332 	} */ *uap = v;
   2333 	return (ENOSYS);	/* XXX */
   2334 }
   2335 
   2336 int
   2337 compat_sparc32_lfs_segwait(p, v, retval)
   2338 	struct proc *p;
   2339 	void *v;
   2340 	register_t *retval;
   2341 {
   2342 	struct compat_sparc32_lfs_segwait_args /* {
   2343 		syscallarg(sparc32_fsid_tp_t) fsidp;
   2344 		syscallarg(sparc32_timevalp_t) tv;
   2345 	} */ *uap = v;
   2346 	return (ENOSYS);	/* XXX */
   2347 }
   2348 
   2349 int
   2350 compat_sparc32_pathconf(p, v, retval)
   2351 	struct proc *p;
   2352 	void *v;
   2353 	register_t *retval;
   2354 {
   2355 	struct compat_sparc32_pathconf_args /* {
   2356 		syscallarg(int) fd;
   2357 		syscallarg(int) name;
   2358 	} */ *uap = v;
   2359 	struct sys_pathconf_args ua;
   2360 	long rt;
   2361 	int error;
   2362 
   2363 	SPARC32TOP_UAP(path, const char);
   2364 	SPARC32TO64_UAP(name);
   2365 	error = sys_pathconf(p, &ua, (register_t *)&rt);
   2366 	*(sparc32_long *)retval = (sparc32_long)rt;
   2367 	return (error);
   2368 }
   2369 
   2370 int
   2371 compat_sparc32_fpathconf(p, v, retval)
   2372 	struct proc *p;
   2373 	void *v;
   2374 	register_t *retval;
   2375 {
   2376 	struct compat_sparc32_fpathconf_args /* {
   2377 		syscallarg(int) fd;
   2378 		syscallarg(int) name;
   2379 	} */ *uap = v;
   2380 	struct sys_fpathconf_args ua;
   2381 	long rt;
   2382 	int error;
   2383 
   2384 	SPARC32TO64_UAP(fd);
   2385 	SPARC32TO64_UAP(name);
   2386 	error = sys_fpathconf(p, &ua, (register_t *)&rt);
   2387 	*(sparc32_long *)retval = (sparc32_long)rt;
   2388 	return (error);
   2389 }
   2390 
   2391 int
   2392 compat_sparc32_getrlimit(p, v, retval)
   2393 	struct proc *p;
   2394 	void *v;
   2395 	register_t *retval;
   2396 {
   2397 	struct compat_sparc32_getrlimit_args /* {
   2398 		syscallarg(int) which;
   2399 		syscallarg(sparc32_rlimitp_t) rlp;
   2400 	} */ *uap = v;
   2401 	struct sys_getrlimit_args ua;
   2402 
   2403 	SPARC32TO64_UAP(which);
   2404 	SPARC32TOP_UAP(rlp, struct rlimit);
   2405 	return (sys_getrlimit(p, &ua, retval));
   2406 }
   2407 
   2408 int
   2409 compat_sparc32_setrlimit(p, v, retval)
   2410 	struct proc *p;
   2411 	void *v;
   2412 	register_t *retval;
   2413 {
   2414 	struct compat_sparc32_setrlimit_args /* {
   2415 		syscallarg(int) which;
   2416 		syscallarg(const sparc32_rlimitp_t) rlp;
   2417 	} */ *uap = v;
   2418 	struct sys_setrlimit_args ua;
   2419 
   2420 	SPARC32TO64_UAP(which);
   2421 	SPARC32TOP_UAP(rlp, struct rlimit);
   2422 	return (sys_setrlimit(p, &ua, retval));
   2423 }
   2424 
   2425 int
   2426 compat_sparc32_mmap(p, v, retval)
   2427 	struct proc *p;
   2428 	void *v;
   2429 	register_t *retval;
   2430 {
   2431 	struct compat_sparc32_mmap_args /* {
   2432 		syscallarg(sparc32_voidp) addr;
   2433 		syscallarg(sparc32_size_t) len;
   2434 		syscallarg(int) prot;
   2435 		syscallarg(int) flags;
   2436 		syscallarg(int) fd;
   2437 		syscallarg(sparc32_long) pad;
   2438 		syscallarg(off_t) pos;
   2439 	} */ *uap = v;
   2440 	struct sys_mmap_args ua;
   2441 	void *rt;
   2442 	int error;
   2443 
   2444 	SPARC32TOP_UAP(addr, void);
   2445 	SPARC32TOX_UAP(len, size_t);
   2446 	SPARC32TO64_UAP(prot);
   2447 	SPARC32TO64_UAP(flags);
   2448 	SPARC32TO64_UAP(fd);
   2449 	SPARC32TOX_UAP(pad, long);
   2450 	SPARC32TOX_UAP(pos, off_t);
   2451 	error = sys_mmap(p, &ua, (register_t *)&rt);
   2452 	if ((long)rt > (long)UINT_MAX)
   2453 		printf("compat_sparc32_mmap: retval out of range: 0x%qx",
   2454 		    rt);
   2455 	*retval = (sparc32_voidp)(u_long)rt;
   2456 	return (error);
   2457 }
   2458 
   2459 int
   2460 compat_sparc32_truncate(p, v, retval)
   2461 	struct proc *p;
   2462 	void *v;
   2463 	register_t *retval;
   2464 {
   2465 	struct compat_sparc32_truncate_args /* {
   2466 		syscallarg(const sparc32_charp) path;
   2467 		syscallarg(int) pad;
   2468 		syscallarg(off_t) length;
   2469 	} */ *uap = v;
   2470 	struct sys_truncate_args ua;
   2471 
   2472 	SPARC32TOP_UAP(path, const char);
   2473 	SPARC32TO64_UAP(pad);
   2474 	SPARC32TO64_UAP(length);
   2475 	return (sys_truncate(p, &ua, retval));
   2476 }
   2477 
   2478 int
   2479 compat_sparc32___sysctl(p, v, retval)
   2480 	struct proc *p;
   2481 	void *v;
   2482 	register_t *retval;
   2483 {
   2484 	struct compat_sparc32___sysctl_args /* {
   2485 		syscallarg(sparc32_intp) name;
   2486 		syscallarg(u_int) namelen;
   2487 		syscallarg(sparc32_voidp) old;
   2488 		syscallarg(sparc32_size_tp) oldlenp;
   2489 		syscallarg(sparc32_voidp) new;
   2490 		syscallarg(sparc32_size_t) newlen;
   2491 	} */ *uap = v;
   2492 	struct sys___sysctl_args ua;
   2493 
   2494 	SPARC32TO64_UAP(namelen);
   2495 	SPARC32TOP_UAP(name, int);
   2496 	SPARC32TOP_UAP(old, void);
   2497 	SPARC32TOP_UAP(oldlenp, size_t);
   2498 	SPARC32TOP_UAP(new, void);
   2499 	SPARC32TOX_UAP(newlen, size_t);
   2500 	return (sys___sysctl(p, &ua, retval));
   2501 }
   2502 
   2503 int
   2504 compat_sparc32_mlock(p, v, retval)
   2505 	struct proc *p;
   2506 	void *v;
   2507 	register_t *retval;
   2508 {
   2509 	struct compat_sparc32_mlock_args /* {
   2510 		syscallarg(const sparc32_voidp) addr;
   2511 		syscallarg(sparc32_size_t) len;
   2512 	} */ *uap = v;
   2513 	struct sys_mlock_args ua;
   2514 
   2515 	SPARC32TOP_UAP(addr, const void);
   2516 	SPARC32TO64_UAP(len);
   2517 	return (sys_mlock(p, &ua, retval));
   2518 }
   2519 
   2520 int
   2521 compat_sparc32_munlock(p, v, retval)
   2522 	struct proc *p;
   2523 	void *v;
   2524 	register_t *retval;
   2525 {
   2526 	struct compat_sparc32_munlock_args /* {
   2527 		syscallarg(const sparc32_voidp) addr;
   2528 		syscallarg(sparc32_size_t) len;
   2529 	} */ *uap = v;
   2530 	struct sys_munlock_args ua;
   2531 
   2532 	SPARC32TOP_UAP(addr, const void);
   2533 	SPARC32TO64_UAP(len);
   2534 	return (sys_munlock(p, &ua, retval));
   2535 }
   2536 
   2537 int
   2538 compat_sparc32_undelete(p, v, retval)
   2539 	struct proc *p;
   2540 	void *v;
   2541 	register_t *retval;
   2542 {
   2543 	struct compat_sparc32_undelete_args /* {
   2544 		syscallarg(const sparc32_charp) path;
   2545 	} */ *uap = v;
   2546 	struct sys_undelete_args ua;
   2547 
   2548 	SPARC32TOP_UAP(path, const char);
   2549 	return (sys_undelete(p, &ua, retval));
   2550 }
   2551 
   2552 int
   2553 compat_sparc32_futimes(p, v, retval)
   2554 	struct proc *p;
   2555 	void *v;
   2556 	register_t *retval;
   2557 {
   2558 	struct compat_sparc32_futimes_args /* {
   2559 		syscallarg(int) fd;
   2560 		syscallarg(const sparc32_timevalp_t) tptr;
   2561 	} */ *uap = v;
   2562 	struct sys_futimes_args ua;
   2563 	struct timeval tv;
   2564 	struct sparc32_timeval *tv32p;
   2565 
   2566 	SPARC32TO64_UAP(fd);
   2567 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr);
   2568 	if (tv32p) {
   2569 		SCARG(&ua, tptr) = &tv;
   2570 		sparc32_to_timeval(tv32p, &tv);
   2571 	} else
   2572 		SCARG(&ua, tptr) = NULL;
   2573 	return (sys_futimes(p, &ua, retval));
   2574 }
   2575 
   2576 int
   2577 compat_sparc32_reboot(p, v, retval)
   2578 	struct proc *p;
   2579 	void *v;
   2580 	register_t *retval;
   2581 {
   2582 	struct compat_sparc32_reboot_args /* {
   2583 		syscallarg(int) opt;
   2584 		syscallarg(sparc32_charp) bootstr;
   2585 	} */ *uap = v;
   2586 	struct sys_reboot_args ua;
   2587 
   2588 	SPARC32TO64_UAP(opt);
   2589 	SPARC32TOP_UAP(bootstr, char);
   2590 	return (sys_reboot(p, &ua, retval));
   2591 }
   2592 
   2593 int
   2594 compat_sparc32_poll(p, v, retval)
   2595 	struct proc *p;
   2596 	void *v;
   2597 	register_t *retval;
   2598 {
   2599 	struct compat_sparc32_poll_args /* {
   2600 		syscallarg(sparc32_pollfdp_t) fds;
   2601 		syscallarg(u_int) nfds;
   2602 		syscallarg(int) timeout;
   2603 	} */ *uap = v;
   2604 	struct sys_poll_args ua;
   2605 
   2606 	SPARC32TOP_UAP(fds, struct pollfd);
   2607 	SPARC32TO64_UAP(nfds);
   2608 	SPARC32TO64_UAP(timeout);
   2609 	return (sys_poll(p, &ua, retval));
   2610 }
   2611 
   2612 int
   2613 compat_sparc32___semctl(p, v, retval)
   2614 	struct proc *p;
   2615 	void *v;
   2616 	register_t *retval;
   2617 {
   2618 	struct compat_sparc32___semctl_args /* {
   2619 		syscallarg(int) semid;
   2620 		syscallarg(int) semnum;
   2621 		syscallarg(int) cmd;
   2622 		syscallarg(sparc32_semunu_t) arg;
   2623 	} */ *uap = v;
   2624 	struct sys___semctl_args ua;
   2625 	struct semid_ds ds, *dsp = &ds;
   2626 	union sparc32_semun *sem32p;
   2627 	int error;
   2628 
   2629 	SPARC32TO64_UAP(semid);
   2630 	SPARC32TO64_UAP(semnum);
   2631 	SPARC32TO64_UAP(cmd);
   2632 	sem32p = (union sparc32_semun *)(u_long)SCARG(uap, arg);
   2633 	if (sem32p) {
   2634 		SCARG(&ua, arg)->buf = dsp;
   2635 		switch (SCARG(uap, cmd)) {
   2636 		case IPC_SET:
   2637 			sparc32_to_semid_ds(sem32.buf, &ds);
   2638 			break;
   2639 		case SETVAL:
   2640 			SCARG(&ua, arg)->val = sem32.val;
   2641 			break;
   2642 		case SETALL:
   2643 			SCARG(&ua, arg)->array = (u_short *)(u_long)sem32.array;
   2644 			break;
   2645 		}
   2646 	} else
   2647 		SCARG(&ua, arg) = NULL;
   2648 
   2649 	error = sys___semctl(p, &ua, retval);
   2650 	if (error)
   2651 		return (error);
   2652 
   2653 	if (sem32p) {
   2654 		switch (SCARG(uap, cmd)) {
   2655 		case IPC_STAT:
   2656 			sparc32_from_semid_ds(&ds, sem32.buf);
   2657 			break;
   2658 		}
   2659 	}
   2660 	return (0);
   2661 }
   2662 
   2663 int
   2664 compat_sparc32_semget(p, v, retval)
   2665 	struct proc *p;
   2666 	void *v;
   2667 	register_t *retval;
   2668 {
   2669 	struct compat_sparc32_semget_args /* {
   2670 		syscallarg(sparc32_key_t) key;
   2671 		syscallarg(int) nsems;
   2672 		syscallarg(int) semflg;
   2673 	} */ *uap = v;
   2674 	struct sys_semget_args ua;
   2675 
   2676 	SPARC32TOX_UAP(key, key_t);
   2677 	SPARC32TO64_UAP(nsems);
   2678 	SPARC32TO64_UAP(semflg);
   2679 	return (sys_semget(p, &ua, retval));
   2680 }
   2681 
   2682 int
   2683 compat_sparc32_semop(p, v, retval)
   2684 	struct proc *p;
   2685 	void *v;
   2686 	register_t *retval;
   2687 {
   2688 	struct compat_sparc32_semop_args /* {
   2689 		syscallarg(int) semid;
   2690 		syscallarg(sparc32_sembufp_t) sops;
   2691 		syscallarg(sparc32_size_t) nsops;
   2692 	} */ *uap = v;
   2693 	struct sys_semop_args ua;
   2694 
   2695 	SPARC32TO64_UAP(semid);
   2696 	SPARC32TOP_UAP(sops, struct sembuf);
   2697 	SPARC32TOX_UAP(nsops, size_t);
   2698 	return (sys_semop(p, &ua, retval));
   2699 }
   2700 
   2701 int
   2702 compat_sparc32_msgctl(p, v, retval)
   2703 	struct proc *p;
   2704 	void *v;
   2705 	register_t *retval;
   2706 {
   2707 	struct compat_sparc32_msgctl_args /* {
   2708 		syscallarg(int) msqid;
   2709 		syscallarg(int) cmd;
   2710 		syscallarg(sparc32_msqid_dsp_t) buf;
   2711 	} */ *uap = v;
   2712 	struct sys_msgctl_args ua;
   2713 	struct msqid_ds ds;
   2714 	struct sparc32_msqid_ds *ds32p;
   2715 	int error;
   2716 
   2717 	SPARC32TO64_UAP(msqid);
   2718 	SPARC32TO64_UAP(cmd);
   2719 	ds32p = (struct sparc32_msqid_ds *)(u_long)SCARG(uap, buf);
   2720 	if (ds32p) {
   2721 		SCARG(&ua, buf) = NULL;
   2722 		sparc32_to_msqid_ds(ds32p, &ds);
   2723 	} else
   2724 		SCARG(&ua, buf) = NULL;
   2725 	error = sys_msgctl(p, &ua, retval);
   2726 	if (error)
   2727 		return (error);
   2728 
   2729 	if (ds32p)
   2730 		sparc32_from_msqid_ds(&ds, ds32p);
   2731 	return (0);
   2732 }
   2733 
   2734 int
   2735 compat_sparc32_msgget(p, v, retval)
   2736 	struct proc *p;
   2737 	void *v;
   2738 	register_t *retval;
   2739 {
   2740 	struct compat_sparc32_msgget_args /* {
   2741 		syscallarg(sparc32_key_t) key;
   2742 		syscallarg(int) msgflg;
   2743 	} */ *uap = v;
   2744 	struct sys_msgget_args ua;
   2745 
   2746 	SPARC32TOX_UAP(key, key_t);
   2747 	SPARC32TO64_UAP(msgflg);
   2748 	return (sys_msgget(p, &ua, retval));
   2749 }
   2750 
   2751 int
   2752 compat_sparc32_msgsnd(p, v, retval)
   2753 	struct proc *p;
   2754 	void *v;
   2755 	register_t *retval;
   2756 {
   2757 	struct compat_sparc32_msgsnd_args /* {
   2758 		syscallarg(int) msqid;
   2759 		syscallarg(const sparc32_voidp) msgp;
   2760 		syscallarg(sparc32_size_t) msgsz;
   2761 		syscallarg(int) msgflg;
   2762 	} */ *uap = v;
   2763 	struct sys_msgsnd_args ua;
   2764 
   2765 	SPARC32TO64_UAP(msqid);
   2766 	SPARC32TOP_UAP(msgp, void);
   2767 	SPARC32TOX_UAP(msgsz, size_t);
   2768 	SPARC32TO64_UAP(msgflg);
   2769 	return (sys_msgsnd(p, &ua, retval));
   2770 }
   2771 
   2772 int
   2773 compat_sparc32_msgrcv(p, v, retval)
   2774 	struct proc *p;
   2775 	void *v;
   2776 	register_t *retval;
   2777 {
   2778 	struct compat_sparc32_msgrcv_args /* {
   2779 		syscallarg(int) msqid;
   2780 		syscallarg(sparc32_voidp) msgp;
   2781 		syscallarg(sparc32_size_t) msgsz;
   2782 		syscallarg(sparc32_long) msgtyp;
   2783 		syscallarg(int) msgflg;
   2784 	} */ *uap = v;
   2785 	struct sys_msgrcv_args ua;
   2786 	ssize_t rt;
   2787 	int error;
   2788 
   2789 	SPARC32TO64_UAP(msqid);
   2790 	SPARC32TOP_UAP(msgp, void);
   2791 	SPARC32TOX_UAP(msgsz, size_t);
   2792 	SPARC32TOX_UAP(msgtyp, long);
   2793 	SPARC32TO64_UAP(msgflg);
   2794 	error = sys_msgrcv(p, &ua, (register_t *)&rt);
   2795 	*(sparc32_ssize_t *)retval = rt;
   2796 	return (error);
   2797 }
   2798 
   2799 int
   2800 compat_sparc32_shmat(p, v, retval)
   2801 	struct proc *p;
   2802 	void *v;
   2803 	register_t *retval;
   2804 {
   2805 	struct compat_sparc32_shmat_args /* {
   2806 		syscallarg(int) shmid;
   2807 		syscallarg(const sparc32_voidp) shmaddr;
   2808 		syscallarg(int) shmflg;
   2809 	} */ *uap = v;
   2810 	struct sys_shmat_args ua;
   2811 	void *rt;
   2812 	int error;
   2813 
   2814 	SPARC32TO64_UAP(shmid);
   2815 	SPARC32TOP_UAP(shmaddr, void);
   2816 	SPARC32TO64_UAP(shmflg);
   2817 	error = sys_shmat(p, &ua, (register_t *)&rt);
   2818 	*retval = (sparc32_voidp)(u_long)rt;
   2819 	return (error);
   2820 }
   2821 
   2822 int
   2823 compat_sparc32_shmctl(p, v, retval)
   2824 	struct proc *p;
   2825 	void *v;
   2826 	register_t *retval;
   2827 {
   2828 	struct compat_sparc32_shmctl_args /* {
   2829 		syscallarg(int) shmid;
   2830 		syscallarg(int) cmd;
   2831 		syscallarg(sparc32_shmid_dsp_t) buf;
   2832 	} */ *uap = v;
   2833 	struct sys_shmctl_args ua;
   2834 	struct shmid_ds ds;
   2835 	struct sparc32_shmid_ds *ds32p;
   2836 	int error;
   2837 
   2838 	SPARC32TO64_UAP(shmid);
   2839 	SPARC32TO64_UAP(cmd);
   2840 	ds32p = (struct sparc32_shmid_ds *)(u_long)SCARG(uap, buf);
   2841 	if (ds32p) {
   2842 		SCARG(&ua, buf) = NULL;
   2843 		sparc32_to_shmid_ds(ds32p, &ds);
   2844 	} else
   2845 		SCARG(&ua, buf) = NULL;
   2846 	error = sys_shmctl(p, &ua, retval);
   2847 	if (error)
   2848 		return (error);
   2849 
   2850 	if (ds32p)
   2851 		sparc32_from_shmid_ds(&ds, ds32p);
   2852 	return (0);
   2853 }
   2854 
   2855 int
   2856 compat_sparc32_shmdt(p, v, retval)
   2857 	struct proc *p;
   2858 	void *v;
   2859 	register_t *retval;
   2860 {
   2861 	struct compat_sparc32_shmdt_args /* {
   2862 		syscallarg(const sparc32_voidp) shmaddr;
   2863 	} */ *uap = v;
   2864 	struct sys_shmdt_args ua;
   2865 
   2866 	SPARC32TOP_UAP(shmaddr, const char);
   2867 	return (sys_shmdt(p, &ua, retval));
   2868 }
   2869 
   2870 int
   2871 compat_sparc32_shmget(p, v, retval)
   2872 	struct proc *p;
   2873 	void *v;
   2874 	register_t *retval;
   2875 {
   2876 	struct compat_sparc32_shmget_args /* {
   2877 		syscallarg(sparc32_key_t) key;
   2878 		syscallarg(sparc32_size_t) size;
   2879 		syscallarg(int) shmflg;
   2880 	} */ *uap = v;
   2881 	struct sys_shmget_args ua;
   2882 
   2883 	SPARC32TOX_UAP(key, key_t)
   2884 	SPARC32TOX_UAP(size, size_t)
   2885 	SPARC32TO64_UAP(shmflg);
   2886 	return (sys_shmget(p, &ua, retval));
   2887 }
   2888 
   2889 int
   2890 compat_sparc32_clock_gettime(p, v, retval)
   2891 	struct proc *p;
   2892 	void *v;
   2893 	register_t *retval;
   2894 {
   2895 	struct compat_sparc32_clock_gettime_args /* {
   2896 		syscallarg(sparc32_clockid_t) clock_id;
   2897 		syscallarg(sparc32_timespecp_t) tp;
   2898 	} */ *uap = v;
   2899 	struct sys_clock_gettime_args ua;
   2900 	struct timespec ts;
   2901 	struct sparc32_timespec *ts32p;
   2902 	int error;
   2903 
   2904 	SPARC32TO64_UAP(clock_id);
   2905 	ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp);
   2906 	if (ts32p)
   2907 		SCARG(&ua, tp) = &ts;
   2908 	else
   2909 		SCARG(&ua, tp) = NULL;
   2910 	error = sys_clock_gettime(p, &ua, retval);
   2911 	if (error)
   2912 		return (error);
   2913 
   2914 	if (ts32p)
   2915 		sparc32_from_timespec(&ts, ts32p);
   2916 	return (0);
   2917 }
   2918 
   2919 int
   2920 compat_sparc32_clock_settime(p, v, retval)
   2921 	struct proc *p;
   2922 	void *v;
   2923 	register_t *retval;
   2924 {
   2925 	struct compat_sparc32_clock_settime_args /* {
   2926 		syscallarg(sparc32_clockid_t) clock_id;
   2927 		syscallarg(const sparc32_timespecp_t) tp;
   2928 	} */ *uap = v;
   2929 	struct sys_clock_settime_args ua;
   2930 	struct timespec ts;
   2931 	struct sparc32_timespec *ts32p;
   2932 
   2933 	SPARC32TO64_UAP(clock_id);
   2934 	ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp);
   2935 	if (ts32p) {
   2936 		SCARG(&ua, tp) = &ts;
   2937 		sparc32_to_timespec(ts32p, &ts);
   2938 	} else
   2939 		SCARG(&ua, tp) = NULL;
   2940 	return (sys_clock_settime(p, &ua, retval));
   2941 }
   2942 
   2943 int
   2944 compat_sparc32_clock_getres(p, v, retval)
   2945 	struct proc *p;
   2946 	void *v;
   2947 	register_t *retval;
   2948 {
   2949 	struct compat_sparc32_clock_getres_args /* {
   2950 		syscallarg(sparc32_clockid_t) clock_id;
   2951 		syscallarg(sparc32_timespecp_t) tp;
   2952 	} */ *uap = v;
   2953 	struct sys_clock_getres_args ua;
   2954 	struct timespec ts;
   2955 	struct sparc32_timespec *ts32p;
   2956 	int error;
   2957 
   2958 	SPARC32TO64_UAP(clock_id);
   2959 	ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp);
   2960 	if (ts32p)
   2961 		SCARG(&ua, tp) = &ts;
   2962 	else
   2963 		SCARG(&ua, tp) = NULL;
   2964 	error = sys_clock_getres(p, &ua, retval);
   2965 	if (error)
   2966 		return (error);
   2967 
   2968 	if (ts32p)
   2969 		sparc32_from_timespec(&ts, ts32p);
   2970 	return (0);
   2971 }
   2972 
   2973 int
   2974 compat_sparc32_nanosleep(p, v, retval)
   2975 	struct proc *p;
   2976 	void *v;
   2977 	register_t *retval;
   2978 {
   2979 	struct compat_sparc32_nanosleep_args /* {
   2980 		syscallarg(const sparc32_timespecp_t) rqtp;
   2981 		syscallarg(sparc32_timespecp_t) rmtp;
   2982 	} */ *uap = v;
   2983 	struct sys_nanosleep_args ua;
   2984 	struct timespec qts, mts;
   2985 	struct sparc32_timespec *qts32p, *mts32p;
   2986 	int error;
   2987 
   2988 	qts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, rqtp);
   2989 	mts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, rmtp);
   2990 	if (qts32p) {
   2991 		SCARG(&ua, rqtp) = &qts;
   2992 		sparc32_to_timespec(qts32p, &qts);
   2993 	} else
   2994 		SCARG(&ua, rqtp) = NULL;
   2995 	if (mts32p) {
   2996 		SCARG(&ua, rmtp) = &mts;
   2997 	} else
   2998 		SCARG(&ua, rmtp) = NULL;
   2999 	error = sys_nanosleep(p, &ua, retval);
   3000 	if (error)
   3001 		return (error);
   3002 
   3003 	if (mts32p)
   3004 		sparc32_from_timespec(&mts, mts32p);
   3005 	return (0);
   3006 }
   3007 
   3008 int
   3009 compat_sparc32___posix_rename(p, v, retval)
   3010 	struct proc *p;
   3011 	void *v;
   3012 	register_t *retval;
   3013 {
   3014 	struct compat_sparc32___posix_rename_args /* {
   3015 		syscallarg(const sparc32_charp) from;
   3016 		syscallarg(const sparc32_charp) to;
   3017 	} */ *uap = v;
   3018 	struct sys___posix_rename_args ua;
   3019 
   3020 	SPARC32TOP_UAP(from, const char)
   3021 	SPARC32TOP_UAP(to, const char)
   3022 	return (sys___posix_rename(p, &ua, retval));
   3023 }
   3024 
   3025 int
   3026 compat_sparc32_swapctl(p, v, retval)
   3027 	struct proc *p;
   3028 	void *v;
   3029 	register_t *retval;
   3030 {
   3031 	struct compat_sparc32_swapctl_args /* {
   3032 		syscallarg(int) cmd;
   3033 		syscallarg(const sparc32_voidp) arg;
   3034 		syscallarg(int) misc;
   3035 	} */ *uap = v;
   3036 	struct sys_swapctl_args ua;
   3037 
   3038 	SPARC32TO64_UAP(cmd);
   3039 	SPARC32TOP_UAP(arg, const void);
   3040 	SPARC32TO64_UAP(misc);
   3041 	return (sys_swapctl(p, &ua, retval));
   3042 }
   3043 
   3044 int
   3045 compat_sparc32_getdents(p, v, retval)
   3046 	struct proc *p;
   3047 	void *v;
   3048 	register_t *retval;
   3049 {
   3050 	struct compat_sparc32_getdents_args /* {
   3051 		syscallarg(int) fd;
   3052 		syscallarg(sparc32_charp) buf;
   3053 		syscallarg(sparc32_size_t) count;
   3054 	} */ *uap = v;
   3055 	struct sys_getdents_args ua;
   3056 
   3057 	SPARC32TO64_UAP(fd);
   3058 	SPARC32TOP_UAP(buf, char);
   3059 	SPARC32TOX_UAP(count, size_t);
   3060 	return (sys_getdents(p, &ua, retval));
   3061 }
   3062 
   3063 int
   3064 compat_sparc32_minherit(p, v, retval)
   3065 	struct proc *p;
   3066 	void *v;
   3067 	register_t *retval;
   3068 {
   3069 	struct compat_sparc32_minherit_args /* {
   3070 		syscallarg(sparc32_voidp) addr;
   3071 		syscallarg(sparc32_size_t) len;
   3072 		syscallarg(int) inherit;
   3073 	} */ *uap = v;
   3074 	struct sys_minherit_args ua;
   3075 
   3076 	SPARC32TOP_UAP(addr, void);
   3077 	SPARC32TOX_UAP(len, size_t);
   3078 	SPARC32TO64_UAP(inherit);
   3079 	return (sys_minherit(p, &ua, retval));
   3080 }
   3081 
   3082 int
   3083 compat_sparc32_lchmod(p, v, retval)
   3084 	struct proc *p;
   3085 	void *v;
   3086 	register_t *retval;
   3087 {
   3088 	struct compat_sparc32_lchmod_args /* {
   3089 		syscallarg(const sparc32_charp) path;
   3090 		syscallarg(mode_t) mode;
   3091 	} */ *uap = v;
   3092 	struct sys_lchmod_args ua;
   3093 
   3094 	SPARC32TOP_UAP(path, const char);
   3095 	SPARC32TO64_UAP(mode);
   3096 	return (sys_lchmod(p, &ua, retval));
   3097 }
   3098 
   3099 int
   3100 compat_sparc32_lchown(p, v, retval)
   3101 	struct proc *p;
   3102 	void *v;
   3103 	register_t *retval;
   3104 {
   3105 	struct compat_sparc32_lchown_args /* {
   3106 		syscallarg(const sparc32_charp) path;
   3107 		syscallarg(uid_t) uid;
   3108 		syscallarg(gid_t) gid;
   3109 	} */ *uap = v;
   3110 	struct sys_lchown_args ua;
   3111 
   3112 	SPARC32TOP_UAP(path, const char);
   3113 	SPARC32TO64_UAP(uid);
   3114 	SPARC32TO64_UAP(gid);
   3115 	return (sys_lchown(p, &ua, retval));
   3116 }
   3117 
   3118 int
   3119 compat_sparc32_lutimes(p, v, retval)
   3120 	struct proc *p;
   3121 	void *v;
   3122 	register_t *retval;
   3123 {
   3124 	struct compat_sparc32_lutimes_args /* {
   3125 		syscallarg(const sparc32_charp) path;
   3126 		syscallarg(const sparc32_timevalp_t) tptr;
   3127 	} */ *uap = v;
   3128 	struct sys_lutimes_args ua;
   3129 	struct timeval tv;
   3130 	struct sparc32_timeval *tv32p;
   3131 
   3132 	SPARC32TOP_UAP(path, const char);
   3133 	tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr);
   3134 	if (tv32p) {
   3135 		SCARG(&ua, tptr) = &tv;
   3136 		sparc32_to_timeval(tv32p, &tv);
   3137 	}
   3138 		SCARG(&ua, tptr) = NULL;
   3139 	return (sys_lutimes(p, &ua, retval));
   3140 }
   3141 
   3142 int
   3143 compat_sparc32___msync13(p, v, retval)
   3144 	struct proc *p;
   3145 	void *v;
   3146 	register_t *retval;
   3147 {
   3148 	struct compat_sparc32___msync13_args /* {
   3149 		syscallarg(sparc32_voidp) addr;
   3150 		syscallarg(sparc32_size_t) len;
   3151 		syscallarg(int) flags;
   3152 	} */ *uap = v;
   3153 	struct sys___msync13_args ua;
   3154 
   3155 	SPARC32TOP_UAP(addr, void);
   3156 	SPARC32TOX_UAP(len, size_t);
   3157 	SPARC32TO64_UAP(flags);
   3158 	return (sys___msync13(p, &ua, retval));
   3159 }
   3160 
   3161 int
   3162 compat_sparc32___stat13(p, v, retval)
   3163 	struct proc *p;
   3164 	void *v;
   3165 	register_t *retval;
   3166 {
   3167 	struct compat_sparc32___stat13_args /* {
   3168 		syscallarg(const sparc32_charp) path;
   3169 		syscallarg(sparc32_statp_t) ub;
   3170 	} */ *uap = v;
   3171 	struct sys___stat13_args ua;
   3172 	struct stat sb;
   3173 	struct sparc32_stat *sb32p;
   3174 	caddr_t sg;
   3175 	int error;
   3176 
   3177 	SPARC32TOP_UAP(path, const char);
   3178 	sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, ub);
   3179 	if (sb32p)
   3180 		SCARG(&ua, ub) = &sb;
   3181 	else
   3182 		SCARG(&ua, ub) = NULL;
   3183 	sg = stackgap_init(p->p_emul);
   3184 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   3185 
   3186 	error = sys___stat13(p, &ua, retval);
   3187 	if (error)
   3188 		return (error);
   3189 
   3190 	if (sb32p)
   3191 		sparc32_from___stat13(&sb, sb32p);
   3192 	return (0);
   3193 }
   3194 
   3195 int
   3196 compat_sparc32___fstat13(p, v, retval)
   3197 	struct proc *p;
   3198 	void *v;
   3199 	register_t *retval;
   3200 {
   3201 	struct compat_sparc32___fstat13_args /* {
   3202 		syscallarg(int) fd;
   3203 		syscallarg(sparc32_statp_t) sb;
   3204 	} */ *uap = v;
   3205 	struct sys___fstat13_args ua;
   3206 	struct stat sb;
   3207 	struct sparc32_stat *sb32p;
   3208 	int error;
   3209 
   3210 	SPARC32TO64_UAP(fd);
   3211 	sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, sb);
   3212 	if (sb32p)
   3213 		SCARG(&ua, sb) = &sb;
   3214 	else
   3215 		SCARG(&ua, sb) = NULL;
   3216 	error = sys___fstat13(p, &ua, retval);
   3217 	if (error)
   3218 		return (error);
   3219 
   3220 	if (sb32p)
   3221 		sparc32_from___stat13(&sb, sb32p);
   3222 	return (0);
   3223 }
   3224 
   3225 int
   3226 compat_sparc32___lstat13(p, v, retval)
   3227 	struct proc *p;
   3228 	void *v;
   3229 	register_t *retval;
   3230 {
   3231 	struct compat_sparc32___lstat13_args /* {
   3232 		syscallarg(const sparc32_charp) path;
   3233 		syscallarg(sparc32_statp_t) ub;
   3234 	} */ *uap = v;
   3235 
   3236 	struct sys___lstat13_args ua;
   3237 	struct stat sb;
   3238 	struct sparc32_stat *sb32p;
   3239 	caddr_t sg;
   3240 	int error;
   3241 
   3242 	SPARC32TOP_UAP(path, const char);
   3243 	sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, ub);
   3244 	if (sb32p)
   3245 		SCARG(&ua, ub) = &sb;
   3246 	else
   3247 		SCARG(&ua, ub) = NULL;
   3248 	sg = stackgap_init(p->p_emul);
   3249 	SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
   3250 	error = sys___lstat13(p, &ua, retval);
   3251 	if (error)
   3252 		return (error);
   3253 
   3254 	if (sb32p)
   3255 		sparc32_from___stat13(&sb, sb32p);
   3256 	return (0);
   3257 }
   3258 
   3259 int
   3260 compat_sparc32___sigaltstack14(p, v, retval)
   3261 	struct proc *p;
   3262 	void *v;
   3263 	register_t *retval;
   3264 {
   3265 	struct compat_sparc32___sigaltstack14_args /* {
   3266 		syscallarg(const sparc32_sigaltstackp_t) nss;
   3267 		syscallarg(sparc32_sigaltstackp_t) oss;
   3268 	} */ *uap = v;
   3269 	struct sys___sigaltstack14_args ua;
   3270 	struct sparc32_sigaltstack *nss32, *oss32;
   3271 	struct sigaltstack nss, oss;
   3272 	int error;
   3273 
   3274 	nss32 = (struct sparc32_sigaltstack *)(u_long)SCARG(uap, nss);
   3275 	oss32 = (struct sparc32_sigaltstack *)(u_long)SCARG(uap, oss);
   3276 	if (nss32) {
   3277 		SCARG(&ua, nss) = &nss;
   3278 		nss.ss_sp = (void *)(u_long)nss32->ss_sp;
   3279 		nss.ss_size = (size_t)nss32->ss_size;
   3280 		nss.ss_flags = nss32->ss_flags;
   3281 	} else
   3282 		SCARG(&ua, nss) = NULL;
   3283 	if (oss32)
   3284 		SCARG(&ua, oss) = &oss;
   3285 	else
   3286 		SCARG(&ua, oss) = NULL;
   3287 
   3288 	error = sys___sigaltstack14(p, &ua, retval);
   3289 	if (error)
   3290 		return (error);
   3291 
   3292 	if (oss32) {
   3293 		oss32->ss_sp = (sparc32_voidp)(u_long)oss.ss_sp;
   3294 		oss32->ss_size = (sparc32_size_t)oss.ss_size;
   3295 		oss32->ss_flags = oss.ss_flags;
   3296 	}
   3297 	return (0);
   3298 }
   3299 
   3300 int
   3301 compat_sparc32___posix_chown(p, v, retval)
   3302 	struct proc *p;
   3303 	void *v;
   3304 	register_t *retval;
   3305 {
   3306 	struct compat_sparc32___posix_chown_args /* {
   3307 		syscallarg(const sparc32_charp) path;
   3308 		syscallarg(uid_t) uid;
   3309 		syscallarg(gid_t) gid;
   3310 	} */ *uap = v;
   3311 	struct sys___posix_chown_args ua;
   3312 
   3313 	SPARC32TOP_UAP(path, const char);
   3314 	SPARC32TO64_UAP(uid);
   3315 	SPARC32TO64_UAP(gid);
   3316 	return (sys___posix_chown(p, &ua, retval));
   3317 }
   3318 
   3319 int
   3320 compat_sparc32___posix_lchown(p, v, retval)
   3321 	struct proc *p;
   3322 	void *v;
   3323 	register_t *retval;
   3324 {
   3325 	struct compat_sparc32___posix_lchown_args /* {
   3326 		syscallarg(const sparc32_charp) path;
   3327 		syscallarg(uid_t) uid;
   3328 		syscallarg(gid_t) gid;
   3329 	} */ *uap = v;
   3330 	struct sys___posix_lchown_args ua;
   3331 
   3332 	SPARC32TOP_UAP(path, const char);
   3333 	SPARC32TO64_UAP(uid);
   3334 	SPARC32TO64_UAP(gid);
   3335 	return (sys___posix_lchown(p, &ua, retval));
   3336 }
   3337 
   3338 int
   3339 compat_sparc32_preadv(p, v, retval)
   3340 	struct proc *p;
   3341 	void *v;
   3342 	register_t *retval;
   3343 {
   3344 	struct compat_sparc32_preadv_args /* {
   3345 		syscallarg(int) fd;
   3346 		syscallarg(const sparc32_iovecp_t) iovp;
   3347 		syscallarg(int) iovcnt;
   3348 		syscallarg(int) pad;
   3349 		syscallarg(off_t) offset;
   3350 	} */ *uap = v;
   3351 	struct sys_preadv_args ua;
   3352 	struct iovec *iov;
   3353 	ssize_t rt;
   3354 	int error;
   3355 
   3356 	SPARC32TO64_UAP(fd);
   3357 	SPARC32TO64_UAP(iovcnt);
   3358 	SPARC32TO64_UAP(pad);
   3359 	SPARC32TO64_UAP(offset);
   3360 	MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt),
   3361 	    M_TEMP, M_WAITOK);
   3362 	sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
   3363 	    SCARG(uap, iovcnt));
   3364 	SCARG(&ua, iovp) = iov;
   3365 
   3366 	error = sys_preadv(p, &ua, (register_t *)&rt);
   3367 	FREE(iov, M_TEMP);
   3368 	*(sparc32_ssize_t *)retval = rt;
   3369 	return (error);
   3370 }
   3371 
   3372 int
   3373 compat_sparc32_pwritev(p, v, retval)
   3374 	struct proc *p;
   3375 	void *v;
   3376 	register_t *retval;
   3377 {
   3378 	struct compat_sparc32_pwritev_args /* {
   3379 		syscallarg(int) fd;
   3380 		syscallarg(const sparc32_iovecp_t) iovp;
   3381 		syscallarg(int) iovcnt;
   3382 		syscallarg(int) pad;
   3383 		syscallarg(off_t) offset;
   3384 	} */ *uap = v;
   3385 	struct sys_pwritev_args ua;
   3386 	struct iovec *iov;
   3387 	ssize_t rt;
   3388 	int error;
   3389 
   3390 	SPARC32TO64_UAP(fd);
   3391 	SPARC32TO64_UAP(iovcnt);
   3392 	SPARC32TO64_UAP(pad);
   3393 	SPARC32TO64_UAP(offset);
   3394 	MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt),
   3395 	    M_TEMP, M_WAITOK);
   3396 	sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
   3397 	    SCARG(uap, iovcnt));
   3398 	SCARG(&ua, iovp) = iov;
   3399 
   3400 	error = sys_pwritev(p, &ua, (register_t *)&rt);
   3401 	FREE(iov, M_TEMP);
   3402 	*(sparc32_ssize_t *)retval = rt;
   3403 	return (error);
   3404 }
   3405