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