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