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) = ⁢ 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
Indexes created Wed Sep 24 05:09:52 GMT 2025