netbsd32_netbsd.c revision 1.3
1 /* $NetBSD: netbsd32_netbsd.c,v 1.3 1998/08/29 18:16:57 eeh Exp $ */ 2 3 /* 4 * Copyright (c) 1998 Matthew R. Green 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <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 #undef DEBUG 1517 int 1518 compat_sparc32_sigreturn(p, v, retval) 1519 struct proc *p; 1520 void *v; 1521 register_t *retval; 1522 { 1523 struct compat_sparc32_sigreturn_args /* { 1524 syscallarg(struct sparc32_sigcontext *) sigcntxp; 1525 } */ *uap = v; 1526 struct sparc32_sigcontext *scp; 1527 struct sparc32_sigcontext sc; 1528 register struct trapframe *tf; 1529 struct rwindow32 *rwstack, *kstack; 1530 1531 /* First ensure consistent stack state (see sendsig). */ 1532 write_user_windows(); 1533 if (rwindow_save(p)) { 1534 #ifdef DEBUG 1535 printf("sigreturn: rwindow_save(%p) failed, sending SIGILL\n", p); 1536 Debugger(); 1537 #endif 1538 sigexit(p, SIGILL); 1539 } 1540 #ifdef DEBUG 1541 if (sigdebug & SDB_FOLLOW) { 1542 printf("sigreturn: %s[%d], sigcntxp %p\n", 1543 p->p_comm, p->p_pid, SCARG(uap, sigcntxp)); 1544 if (sigdebug & SDB_DDB) Debugger(); 1545 } 1546 #endif 1547 scp = SCARG(uap, sigcntxp); 1548 if ((int)scp & 3 || (copyin((caddr_t)scp, &sc, sizeof sc) != 0)) 1549 #ifdef DEBUG 1550 { 1551 printf("sigreturn: copyin failed\n"); 1552 Debugger(); 1553 return (EINVAL); 1554 } 1555 #else 1556 return (EINVAL); 1557 #endif 1558 tf = p->p_md.md_tf; 1559 /* 1560 * Only the icc bits in the psr are used, so it need not be 1561 * verified. pc and npc must be multiples of 4. This is all 1562 * that is required; if it holds, just do it. 1563 */ 1564 if (((sc.sc_pc | sc.sc_npc) & 3) != 0) 1565 #ifdef DEBUG 1566 { 1567 printf("sigreturn: pc %p or npc %p invalid\n", sc.sc_pc, sc.sc_npc); 1568 Debugger(); 1569 return (EINVAL); 1570 } 1571 #else 1572 return (EINVAL); 1573 #endif 1574 /* take only psr ICC field */ 1575 tf->tf_tstate = (int64_t)(tf->tf_tstate & ~TSTATE_CCR) | PSRCC_TO_TSTATE(sc.sc_psr); 1576 tf->tf_pc = (int64_t)sc.sc_pc; 1577 tf->tf_npc = (int64_t)sc.sc_npc; 1578 tf->tf_global[1] = (int64_t)sc.sc_g1; 1579 tf->tf_out[0] = (int64_t)sc.sc_o0; 1580 tf->tf_out[6] = (int64_t)sc.sc_sp; 1581 rwstack = (struct rwindow32 *)tf->tf_out[6]; 1582 kstack = (struct rwindow32 *)(((caddr_t)tf)-CCFSZ); 1583 for (i=0; i<8; i++) { 1584 int tmp; 1585 if (copyin((caddr_t)&rwstack->rw_local[i], &tmp, sizeof tmp)) { 1586 printf("sigreturn: cannot load \%l%d from %p\n", i, &rwstack->rw_local[i]); 1587 Debugger(); 1588 } 1589 tf->tf_local[i] = (int64_t)tmp; 1590 if (copyin((caddr_t)&rwstack->rw_in[i], &tmp, sizeof tmp)) { 1591 printf("sigreturn: cannot load \%i%d from %p\n", i, &rwstack->rw_in[i]); 1592 Debugger(); 1593 } 1594 tf->tf_in[i] = (int)tmp; 1595 } 1596 #ifdef DEBUG 1597 /* Need to sync tf locals and ins with stack to prevent panic */ 1598 { 1599 int i; 1600 1601 kstack = (struct rwindow32 *)tf->tf_out[6]; 1602 for (i=0; i<8; i++) { 1603 tf->tf_local[i] = fuword(&kstack->rw_local[i]); 1604 tf->tf_in[i] = fuword(&kstack->rw_in[i]); 1605 } 1606 } 1607 #endif 1608 #ifdef DEBUG 1609 if (sigdebug & SDB_FOLLOW) { 1610 printf("sys_sigreturn: return trapframe pc=%p sp=%p tstate=%x\n", 1611 (int)tf->tf_pc, (int)tf->tf_out[6], (int)tf->tf_tstate); 1612 if (sigdebug & SDB_DDB) Debugger(); 1613 } 1614 #endif 1615 if (sc.sc_onstack & 1) 1616 p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK; 1617 else 1618 p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK; 1619 p->p_sigmask = sc.sc_mask & ~sigcantmask; 1620 return (EJUSTRETURN); 1621 } 1622 1623 1624 int 1625 compat_sparc32_bind(p, v, retval) 1626 struct proc *p; 1627 void *v; 1628 register_t *retval; 1629 { 1630 struct compat_sparc32_bind_args /* { 1631 syscallarg(int) s; 1632 syscallarg(const sparc32_sockaddrp_t) name; 1633 syscallarg(int) namelen; 1634 } */ *uap = v; 1635 struct sys_connect_args ua; 1636 1637 SPARC32TO64_UAP(s); 1638 SPARC32TOP_UAP(name, struct sockaddr); 1639 SPARC32TO64_UAP(namelen); 1640 return (sys_connect(p, &ua, retval)); 1641 } 1642 1643 int 1644 compat_sparc32_setsockopt(p, v, retval) 1645 struct proc *p; 1646 void *v; 1647 register_t *retval; 1648 { 1649 struct compat_sparc32_setsockopt_args /* { 1650 syscallarg(int) s; 1651 syscallarg(int) level; 1652 syscallarg(int) name; 1653 syscallarg(const sparc32_voidp) val; 1654 syscallarg(int) valsize; 1655 } */ *uap = v; 1656 struct sys_setsockopt_args ua; 1657 1658 SPARC32TO64_UAP(s); 1659 SPARC32TO64_UAP(level); 1660 SPARC32TO64_UAP(name); 1661 SPARC32TOP_UAP(val, void); 1662 SPARC32TO64_UAP(valsize); 1663 return (sys_setsockopt(p, &ua, retval)); 1664 } 1665 1666 int 1667 compat_sparc32_gettimeofday(p, v, retval) 1668 struct proc *p; 1669 void *v; 1670 register_t *retval; 1671 { 1672 struct compat_sparc32_gettimeofday_args /* { 1673 syscallarg(sparc32_timevalp_t) tp; 1674 syscallarg(sparc32_timezonep_t) tzp; 1675 } */ *uap = v; 1676 struct sys_gettimeofday_args ua; 1677 struct timeval tv; 1678 struct sparc32_timeval *tv32p; 1679 int error; 1680 1681 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tp); 1682 if (tv32p) { 1683 SCARG(&ua, tp) = &tv; 1684 sparc32_to_timeval(tv32p, &tv); 1685 } else 1686 SCARG(&ua, tp) = NULL; 1687 SPARC32TOP_UAP(tzp, struct timezone) 1688 1689 error = sys_gettimeofday(p, &ua, retval); 1690 if (error) 1691 return (error); 1692 1693 if (tv32p) 1694 sparc32_from_timeval(&tv, tv32p); 1695 1696 return (0); 1697 } 1698 1699 int 1700 compat_sparc32_settimeofday(p, v, retval) 1701 struct proc *p; 1702 void *v; 1703 register_t *retval; 1704 { 1705 struct compat_sparc32_settimeofday_args /* { 1706 syscallarg(const sparc32_timevalp_t) tv; 1707 syscallarg(const sparc32_timezonep_t) tzp; 1708 } */ *uap = v; 1709 struct sys_settimeofday_args ua; 1710 struct timeval tv; 1711 struct sparc32_timeval *tv32p; 1712 int error; 1713 1714 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tv); 1715 if (tv32p) { 1716 SCARG(&ua, tv) = &tv; 1717 sparc32_to_timeval(tv32p, &tv); 1718 } else 1719 SCARG(&ua, tv) = NULL; 1720 SPARC32TOP_UAP(tzp, struct timezone) 1721 1722 error = sys_settimeofday(p, &ua, retval); 1723 if (error) 1724 return (error); 1725 1726 if (tv32p) 1727 sparc32_from_timeval(&tv, tv32p); 1728 1729 return (0); 1730 } 1731 1732 int 1733 compat_sparc32_getrusage(p, v, retval) 1734 struct proc *p; 1735 void *v; 1736 register_t *retval; 1737 { 1738 struct compat_sparc32_getrusage_args /* { 1739 syscallarg(int) who; 1740 syscallarg(sparc32_rusagep_t) rusage; 1741 } */ *uap = v; 1742 struct sys_getrusage_args ua; 1743 struct rusage ru; 1744 struct sparc32_rusage *ru32p; 1745 int error; 1746 1747 SPARC32TO64_UAP(who); 1748 ru32p = (struct sparc32_rusage *)(u_long)SCARG(uap, rusage); 1749 if (ru32p) { 1750 SCARG(&ua, rusage) = &ru; 1751 sparc32_to_rusage(ru32p, &ru); 1752 } else 1753 SCARG(&ua, rusage) = NULL; 1754 1755 error = sys_getrusage(p, &ua, retval); 1756 if (ru32p) 1757 sparc32_from_rusage(&ru, ru32p); 1758 1759 return (error); 1760 } 1761 1762 int 1763 compat_sparc32_getsockopt(p, v, retval) 1764 struct proc *p; 1765 void *v; 1766 register_t *retval; 1767 { 1768 struct compat_sparc32_getsockopt_args /* { 1769 syscallarg(int) s; 1770 syscallarg(int) level; 1771 syscallarg(int) name; 1772 syscallarg(sparc32_voidp) val; 1773 syscallarg(sparc32_intp) avalsize; 1774 } */ *uap = v; 1775 struct sys_getsockopt_args ua; 1776 1777 SPARC32TO64_UAP(s); 1778 SPARC32TO64_UAP(level); 1779 SPARC32TO64_UAP(name); 1780 SPARC32TOP_UAP(val, void) 1781 SPARC32TOP_UAP(avalsize, int); 1782 return (sys_getsockopt(p, &ua, retval)); 1783 } 1784 1785 int 1786 compat_sparc32_readv(p, v, retval) 1787 struct proc *p; 1788 void *v; 1789 register_t *retval; 1790 { 1791 struct compat_sparc32_readv_args /* { 1792 syscallarg(int) fd; 1793 syscallarg(const sparc32_iovecp_t) iovp; 1794 syscallarg(int) iovcnt; 1795 } */ *uap = v; 1796 struct sys_readv_args ua; 1797 struct iovec *iov; 1798 ssize_t rt; 1799 int error; 1800 1801 SPARC32TO64_UAP(fd) 1802 SPARC32TO64_UAP(iovcnt); 1803 MALLOC(iov, struct iovec *, 1804 sizeof(struct iovec) * SCARG(uap, iovcnt), M_TEMP, M_WAITOK); 1805 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov, 1806 SCARG(uap, iovcnt)); 1807 SCARG(&ua, iovp) = iov; 1808 1809 error = sys_readv(p, &ua, (register_t *)&rt); 1810 FREE(iov, M_TEMP); 1811 *(sparc32_ssize_t *)retval = rt; 1812 return (error); 1813 } 1814 1815 int 1816 compat_sparc32_writev(p, v, retval) 1817 struct proc *p; 1818 void *v; 1819 register_t *retval; 1820 { 1821 struct compat_sparc32_writev_args /* { 1822 syscallarg(int) fd; 1823 syscallarg(const sparc32_iovecp_t) iovp; 1824 syscallarg(int) iovcnt; 1825 } */ *uap = v; 1826 struct sys_writev_args ua; 1827 struct iovec *iov; 1828 ssize_t rt; 1829 int error; 1830 1831 SPARC32TO64_UAP(fd) 1832 SPARC32TO64_UAP(iovcnt); 1833 MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt), 1834 M_TEMP, M_WAITOK); 1835 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov, 1836 SCARG(uap, iovcnt)); 1837 SCARG(&ua, iovp) = iov; 1838 1839 error = sys_writev(p, &ua, (register_t *)&rt); 1840 FREE(iov, M_TEMP); 1841 *(sparc32_ssize_t *)retval = rt; 1842 return (error); 1843 } 1844 1845 int 1846 compat_sparc32_rename(p, v, retval) 1847 struct proc *p; 1848 void *v; 1849 register_t *retval; 1850 { 1851 struct compat_sparc32_rename_args /* { 1852 syscallarg(const sparc32_charp) from; 1853 syscallarg(const sparc32_charp) to; 1854 } */ *uap = v; 1855 struct sys_rename_args ua; 1856 1857 SPARC32TOP_UAP(from, const char) 1858 SPARC32TOP_UAP(to, const char) 1859 return (sys_rename(p, &ua, retval)); 1860 } 1861 1862 int 1863 compat_sparc32_mkfifo(p, v, retval) 1864 struct proc *p; 1865 void *v; 1866 register_t *retval; 1867 { 1868 struct compat_sparc32_mkfifo_args /* { 1869 syscallarg(const sparc32_charp) path; 1870 syscallarg(mode_t) mode; 1871 } */ *uap = v; 1872 struct sys_mkfifo_args ua; 1873 1874 SPARC32TOP_UAP(path, const char) 1875 SPARC32TO64_UAP(mode); 1876 return (sys_mkfifo(p, &ua, retval)); 1877 } 1878 1879 int 1880 compat_sparc32_mkdir(p, v, retval) 1881 struct proc *p; 1882 void *v; 1883 register_t *retval; 1884 { 1885 struct compat_sparc32_mkdir_args /* { 1886 syscallarg(const sparc32_charp) path; 1887 syscallarg(mode_t) mode; 1888 } */ *uap = v; 1889 struct sys_mkdir_args ua; 1890 1891 SPARC32TOP_UAP(path, const char) 1892 SPARC32TO64_UAP(mode); 1893 return (sys_mkdir(p, &ua, retval)); 1894 } 1895 1896 int 1897 compat_sparc32_rmdir(p, v, retval) 1898 struct proc *p; 1899 void *v; 1900 register_t *retval; 1901 { 1902 struct compat_sparc32_rmdir_args /* { 1903 syscallarg(const sparc32_charp) path; 1904 } */ *uap = v; 1905 struct sys_rmdir_args ua; 1906 1907 SPARC32TOP_UAP(path, const char); 1908 return (sys_rmdir(p, &ua, retval)); 1909 } 1910 1911 int 1912 compat_sparc32_utimes(p, v, retval) 1913 struct proc *p; 1914 void *v; 1915 register_t *retval; 1916 { 1917 struct compat_sparc32_utimes_args /* { 1918 syscallarg(const sparc32_charp) path; 1919 syscallarg(const sparc32_timevalp_t) tptr; 1920 } */ *uap = v; 1921 struct sys_utimes_args ua; 1922 struct timeval tv; 1923 struct sparc32_timeval *tv32p; 1924 1925 SPARC32TOP_UAP(path, const char); 1926 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr); 1927 if (tv32p) { 1928 SCARG(&ua, tptr) = &tv; 1929 sparc32_to_timeval(tv32p, &tv); 1930 } else 1931 SCARG(&ua, tptr) = NULL; 1932 1933 return (sys_utimes(p, &ua, retval)); 1934 } 1935 1936 int 1937 compat_sparc32_adjtime(p, v, retval) 1938 struct proc *p; 1939 void *v; 1940 register_t *retval; 1941 { 1942 struct compat_sparc32_adjtime_args /* { 1943 syscallarg(const sparc32_timevalp_t) delta; 1944 syscallarg(sparc32_timevalp_t) olddelta; 1945 } */ *uap = v; 1946 struct sys_adjtime_args ua; 1947 struct timeval tv, otv; 1948 struct sparc32_timeval *tv32p, *otv32p; 1949 int error; 1950 1951 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, delta); 1952 otv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, olddelta); 1953 1954 if (tv32p) { 1955 SCARG(&ua, delta) = &tv; 1956 sparc32_to_timeval(tv32p, &tv); 1957 } else 1958 SCARG(&ua, delta) = NULL; 1959 if (otv32p) 1960 SCARG(&ua, olddelta) = &otv; 1961 else 1962 SCARG(&ua, olddelta) = NULL; 1963 error = sys_adjtime(p, &ua, retval); 1964 if (error) 1965 return (error); 1966 1967 if (otv32p) 1968 sparc32_from_timeval(&otv, otv32p); 1969 return (0); 1970 } 1971 1972 int 1973 compat_sparc32_quotactl(p, v, retval) 1974 struct proc *p; 1975 void *v; 1976 register_t *retval; 1977 { 1978 struct compat_sparc32_quotactl_args /* { 1979 syscallarg(const sparc32_charp) path; 1980 syscallarg(int) cmd; 1981 syscallarg(int) uid; 1982 syscallarg(sparc32_caddr_t) arg; 1983 } */ *uap = v; 1984 struct sys_quotactl_args ua; 1985 1986 SPARC32TOP_UAP(path, const char); 1987 SPARC32TO64_UAP(cmd); 1988 SPARC32TO64_UAP(uid); 1989 SPARC32TOX64_UAP(arg, caddr_t); 1990 return (sys_quotactl(p, &ua, retval)); 1991 } 1992 1993 int 1994 compat_sparc32_nfssvc(p, v, retval) 1995 struct proc *p; 1996 void *v; 1997 register_t *retval; 1998 { 1999 struct compat_sparc32_nfssvc_args /* { 2000 syscallarg(int) flag; 2001 syscallarg(sparc32_voidp) argp; 2002 } */ *uap = v; 2003 struct sys_nfssvc_args ua; 2004 2005 SPARC32TO64_UAP(flag); 2006 SPARC32TOP_UAP(argp, void); 2007 return (sys_nfssvc(p, &ua, retval)); 2008 } 2009 2010 int 2011 compat_sparc32_statfs(p, v, retval) 2012 struct proc *p; 2013 void *v; 2014 register_t *retval; 2015 { 2016 struct compat_sparc32_statfs_args /* { 2017 syscallarg(const sparc32_charp) path; 2018 syscallarg(sparc32_statfsp_t) buf; 2019 } */ *uap = v; 2020 struct sys_statfs_args ua; 2021 struct statfs sb; 2022 struct sparc32_statfs *sb32p; 2023 caddr_t sg; 2024 int error; 2025 2026 SPARC32TOP_UAP(path, const char); 2027 sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf); 2028 if (sb32p) 2029 SCARG(&ua, buf) = &sb; 2030 else 2031 SCARG(&ua, buf) = NULL; 2032 sg = stackgap_init(p->p_emul); 2033 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 2034 error = sys_statfs(p, &ua, retval); 2035 if (error) 2036 return (error); 2037 2038 if (sb32p) 2039 sparc32_from_statfs(&sb, sb32p); 2040 return (0); 2041 } 2042 2043 int 2044 compat_sparc32_fstatfs(p, v, retval) 2045 struct proc *p; 2046 void *v; 2047 register_t *retval; 2048 { 2049 struct compat_sparc32_fstatfs_args /* { 2050 syscallarg(int) fd; 2051 syscallarg(sparc32_statfsp_t) buf; 2052 } */ *uap = v; 2053 struct sys_fstatfs_args ua; 2054 struct statfs sb; 2055 struct sparc32_statfs *sb32p; 2056 int error; 2057 2058 SPARC32TO64_UAP(fd); 2059 sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf); 2060 if (sb32p) 2061 SCARG(&ua, buf) = &sb; 2062 else 2063 SCARG(&ua, buf) = NULL; 2064 error = sys_fstatfs(p, &ua, retval); 2065 if (error) 2066 return (error); 2067 2068 if (sb32p) 2069 sparc32_from_statfs(&sb, sb32p); 2070 return (0); 2071 } 2072 2073 int 2074 compat_sparc32_getfh(p, v, retval) 2075 struct proc *p; 2076 void *v; 2077 register_t *retval; 2078 { 2079 struct compat_sparc32_getfh_args /* { 2080 syscallarg(const sparc32_charp) fname; 2081 syscallarg(sparc32_fhandlep_t) fhp; 2082 } */ *uap = v; 2083 struct sys_getfh_args ua; 2084 2085 SPARC32TOP_UAP(fname, const char); 2086 SPARC32TOP_UAP(fhp, struct fhandle); 2087 return (sys_getfh(p, &ua, retval)); 2088 } 2089 2090 int 2091 compat_sparc32_sysarch(p, v, retval) 2092 struct proc *p; 2093 void *v; 2094 register_t *retval; 2095 { 2096 struct compat_sparc32_sysarch_args /* { 2097 syscallarg(int) op; 2098 syscallarg(sparc32_voidp) parms; 2099 } */ *uap = v; 2100 struct sys_sysarch_args ua; 2101 2102 SPARC32TO64_UAP(op); 2103 SPARC32TOP_UAP(parms, void); 2104 return (sys_getfh(p, &ua, retval)); 2105 } 2106 2107 int 2108 compat_sparc32_pread(p, v, retval) 2109 struct proc *p; 2110 void *v; 2111 register_t *retval; 2112 { 2113 struct compat_sparc32_pread_args /* { 2114 syscallarg(int) fd; 2115 syscallarg(sparc32_voidp) buf; 2116 syscallarg(sparc32_size_t) nbyte; 2117 syscallarg(int) pad; 2118 syscallarg(off_t) offset; 2119 } */ *uap = v; 2120 struct sys_pread_args ua; 2121 ssize_t rt; 2122 int error; 2123 2124 SPARC32TO64_UAP(fd); 2125 SPARC32TOP_UAP(buf, void); 2126 SPARC32TOX_UAP(nbyte, size_t); 2127 SPARC32TO64_UAP(pad); 2128 SPARC32TO64_UAP(offset); 2129 error = sys_pread(p, &ua, (register_t *)&rt); 2130 *(sparc32_ssize_t *)retval = rt; 2131 return (error); 2132 } 2133 2134 int 2135 compat_sparc32_pwrite(p, v, retval) 2136 struct proc *p; 2137 void *v; 2138 register_t *retval; 2139 { 2140 struct compat_sparc32_pwrite_args /* { 2141 syscallarg(int) fd; 2142 syscallarg(const sparc32_voidp) buf; 2143 syscallarg(sparc32_size_t) nbyte; 2144 syscallarg(int) pad; 2145 syscallarg(off_t) offset; 2146 } */ *uap = v; 2147 struct sys_pwrite_args ua; 2148 ssize_t rt; 2149 int error; 2150 2151 SPARC32TO64_UAP(fd); 2152 SPARC32TOP_UAP(buf, void); 2153 SPARC32TOX_UAP(nbyte, size_t); 2154 SPARC32TO64_UAP(pad); 2155 SPARC32TO64_UAP(offset); 2156 error = sys_pwrite(p, &ua, (register_t *)&rt); 2157 *(sparc32_ssize_t *)retval = rt; 2158 return (error); 2159 } 2160 2161 int 2162 compat_sparc32_ntp_gettime(p, v, retval) 2163 struct proc *p; 2164 void *v; 2165 register_t *retval; 2166 { 2167 struct compat_sparc32_ntp_gettime_args /* { 2168 syscallarg(sparc32_ntptimevalp_t) ntvp; 2169 } */ *uap = v; 2170 struct sys_ntp_gettime_args ua; 2171 struct ntptimeval ntv; 2172 struct sparc32_ntptimeval *ntv32p; 2173 int error; 2174 2175 ntv32p = (struct sparc32_ntptimeval *)(u_long)SCARG(uap, ntvp); 2176 if (ntv32p) 2177 SCARG(&ua, ntvp) = &ntv; 2178 else 2179 SCARG(&ua, ntvp) = NULL; 2180 error = sys_ntp_gettime(p, &ua, retval); 2181 if (error) 2182 return (error); 2183 2184 if (ntv32p) { 2185 sparc32_from_timeval(&ntv, ntv32p); 2186 ntv32p->maxerror = (sparc32_long)ntv.maxerror; 2187 ntv32p->esterror = (sparc32_long)ntv.esterror; 2188 } 2189 return (0); 2190 } 2191 2192 int 2193 compat_sparc32_ntp_adjtime(p, v, retval) 2194 struct proc *p; 2195 void *v; 2196 register_t *retval; 2197 { 2198 struct compat_sparc32_ntp_adjtime_args /* { 2199 syscallarg(sparc32_timexp_t) tp; 2200 } */ *uap = v; 2201 struct sys_ntp_adjtime_args ua; 2202 struct timex tx; 2203 struct sparc32_timex *tx32p; 2204 int error; 2205 2206 tx32p = (struct sparc32_timex *)(u_long)SCARG(uap, tp); 2207 if (tx32p) { 2208 SCARG(&ua, tp) = &tx; 2209 sparc32_to_timex(tx32p, &tx); 2210 } else 2211 SCARG(&ua, tp) = NULL; 2212 error = sys_ntp_adjtime(p, &ua, retval); 2213 if (error) 2214 return (error); 2215 2216 if (tx32p) 2217 sparc32_from_timeval(&tx, tx32p); 2218 return (0); 2219 } 2220 2221 int 2222 compat_sparc32_lfs_bmapv(p, v, retval) 2223 struct proc *p; 2224 void *v; 2225 register_t *retval; 2226 { 2227 struct compat_sparc32_lfs_bmapv_args /* { 2228 syscallarg(sparc32_fsid_tp_t) fsidp; 2229 syscallarg(sparc32_block_infop_t) blkiov; 2230 syscallarg(int) blkcnt; 2231 } */ *uap = v; 2232 #if 0 2233 struct sys_lfs_bmapv_args ua; 2234 2235 SPARC32TOP_UAP(fdidp, struct fsid); 2236 SPARC32TO64_UAP(blkcnt); 2237 /* XXX finish me */ 2238 #else 2239 2240 return (ENOSYS); /* XXX */ 2241 #endif 2242 } 2243 2244 int 2245 compat_sparc32_lfs_markv(p, v, retval) 2246 struct proc *p; 2247 void *v; 2248 register_t *retval; 2249 { 2250 struct compat_sparc32_lfs_markv_args /* { 2251 syscallarg(sparc32_fsid_tp_t) fsidp; 2252 syscallarg(sparc32_block_infop_t) blkiov; 2253 syscallarg(int) blkcnt; 2254 } */ *uap = v; 2255 2256 return (ENOSYS); /* XXX */ 2257 } 2258 2259 int 2260 compat_sparc32_lfs_segclean(p, v, retval) 2261 struct proc *p; 2262 void *v; 2263 register_t *retval; 2264 { 2265 struct compat_sparc32_lfs_segclean_args /* { 2266 syscallarg(sparc32_fsid_tp_t) fsidp; 2267 syscallarg(sparc32_u_long) segment; 2268 } */ *uap = v; 2269 return (ENOSYS); /* XXX */ 2270 } 2271 2272 int 2273 compat_sparc32_lfs_segwait(p, v, retval) 2274 struct proc *p; 2275 void *v; 2276 register_t *retval; 2277 { 2278 struct compat_sparc32_lfs_segwait_args /* { 2279 syscallarg(sparc32_fsid_tp_t) fsidp; 2280 syscallarg(sparc32_timevalp_t) tv; 2281 } */ *uap = v; 2282 return (ENOSYS); /* XXX */ 2283 } 2284 2285 int 2286 compat_sparc32_pathconf(p, v, retval) 2287 struct proc *p; 2288 void *v; 2289 register_t *retval; 2290 { 2291 struct compat_sparc32_pathconf_args /* { 2292 syscallarg(int) fd; 2293 syscallarg(int) name; 2294 } */ *uap = v; 2295 struct sys_pathconf_args ua; 2296 long rt; 2297 int error; 2298 2299 SPARC32TOP_UAP(path, const char); 2300 SPARC32TO64_UAP(name); 2301 error = sys_pathconf(p, &ua, (register_t *)&rt); 2302 *(sparc32_long *)retval = (sparc32_long)rt; 2303 return (error); 2304 } 2305 2306 int 2307 compat_sparc32_fpathconf(p, v, retval) 2308 struct proc *p; 2309 void *v; 2310 register_t *retval; 2311 { 2312 struct compat_sparc32_fpathconf_args /* { 2313 syscallarg(int) fd; 2314 syscallarg(int) name; 2315 } */ *uap = v; 2316 struct sys_fpathconf_args ua; 2317 long rt; 2318 int error; 2319 2320 SPARC32TO64_UAP(fd); 2321 SPARC32TO64_UAP(name); 2322 error = sys_fpathconf(p, &ua, (register_t *)&rt); 2323 *(sparc32_long *)retval = (sparc32_long)rt; 2324 return (error); 2325 } 2326 2327 int 2328 compat_sparc32_getrlimit(p, v, retval) 2329 struct proc *p; 2330 void *v; 2331 register_t *retval; 2332 { 2333 struct compat_sparc32_getrlimit_args /* { 2334 syscallarg(int) which; 2335 syscallarg(sparc32_rlimitp_t) rlp; 2336 } */ *uap = v; 2337 struct sys_getrlimit_args ua; 2338 2339 SPARC32TO64_UAP(which); 2340 SPARC32TOP_UAP(rlp, struct rlimit); 2341 return (sys_getrlimit(p, &ua, retval)); 2342 } 2343 2344 int 2345 compat_sparc32_setrlimit(p, v, retval) 2346 struct proc *p; 2347 void *v; 2348 register_t *retval; 2349 { 2350 struct compat_sparc32_setrlimit_args /* { 2351 syscallarg(int) which; 2352 syscallarg(const sparc32_rlimitp_t) rlp; 2353 } */ *uap = v; 2354 struct sys_setrlimit_args ua; 2355 2356 SPARC32TO64_UAP(which); 2357 SPARC32TOP_UAP(rlp, struct rlimit); 2358 return (sys_setrlimit(p, &ua, retval)); 2359 } 2360 2361 int 2362 compat_sparc32_mmap(p, v, retval) 2363 struct proc *p; 2364 void *v; 2365 register_t *retval; 2366 { 2367 struct compat_sparc32_mmap_args /* { 2368 syscallarg(sparc32_voidp) addr; 2369 syscallarg(sparc32_size_t) len; 2370 syscallarg(int) prot; 2371 syscallarg(int) flags; 2372 syscallarg(int) fd; 2373 syscallarg(sparc32_long) pad; 2374 syscallarg(off_t) pos; 2375 } */ *uap = v; 2376 struct sys_mmap_args ua; 2377 void *rt; 2378 int error; 2379 2380 SPARC32TOP_UAP(addr, void); 2381 SPARC32TOX_UAP(len, size_t); 2382 SPARC32TO64_UAP(prot); 2383 SPARC32TO64_UAP(flags); 2384 SPARC32TO64_UAP(fd); 2385 SPARC32TOX_UAP(pad, long); 2386 SPARC32TOX_UAP(pos, off_t); 2387 error = sys_mmap(p, &ua, (register_t *)&rt); 2388 if ((long)rt > (long)UINT_MAX) 2389 printf("compat_sparc32_mmap: retval out of range: 0x%qx", 2390 rt); 2391 *retval = (sparc32_voidp)(u_long)rt; 2392 return (error); 2393 } 2394 2395 int 2396 compat_sparc32_truncate(p, v, retval) 2397 struct proc *p; 2398 void *v; 2399 register_t *retval; 2400 { 2401 struct compat_sparc32_truncate_args /* { 2402 syscallarg(const sparc32_charp) path; 2403 syscallarg(int) pad; 2404 syscallarg(off_t) length; 2405 } */ *uap = v; 2406 struct sys_truncate_args ua; 2407 2408 SPARC32TOP_UAP(path, const char); 2409 SPARC32TO64_UAP(pad); 2410 SPARC32TO64_UAP(length); 2411 return (sys_truncate(p, &ua, retval)); 2412 } 2413 2414 int 2415 compat_sparc32___sysctl(p, v, retval) 2416 struct proc *p; 2417 void *v; 2418 register_t *retval; 2419 { 2420 struct compat_sparc32___sysctl_args /* { 2421 syscallarg(sparc32_intp) name; 2422 syscallarg(u_int) namelen; 2423 syscallarg(sparc32_voidp) old; 2424 syscallarg(sparc32_size_tp) oldlenp; 2425 syscallarg(sparc32_voidp) new; 2426 syscallarg(sparc32_size_t) newlen; 2427 } */ *uap = v; 2428 struct sys___sysctl_args ua; 2429 2430 SPARC32TO64_UAP(namelen); 2431 SPARC32TOP_UAP(name, int); 2432 SPARC32TOP_UAP(old, void); 2433 SPARC32TOP_UAP(oldlenp, size_t); 2434 SPARC32TOP_UAP(new, void); 2435 SPARC32TOX_UAP(newlen, size_t); 2436 return (sys___sysctl(p, &ua, retval)); 2437 } 2438 2439 int 2440 compat_sparc32_mlock(p, v, retval) 2441 struct proc *p; 2442 void *v; 2443 register_t *retval; 2444 { 2445 struct compat_sparc32_mlock_args /* { 2446 syscallarg(const sparc32_voidp) addr; 2447 syscallarg(sparc32_size_t) len; 2448 } */ *uap = v; 2449 struct sys_mlock_args ua; 2450 2451 SPARC32TOP_UAP(addr, const void); 2452 SPARC32TO64_UAP(len); 2453 return (sys_mlock(p, &ua, retval)); 2454 } 2455 2456 int 2457 compat_sparc32_munlock(p, v, retval) 2458 struct proc *p; 2459 void *v; 2460 register_t *retval; 2461 { 2462 struct compat_sparc32_munlock_args /* { 2463 syscallarg(const sparc32_voidp) addr; 2464 syscallarg(sparc32_size_t) len; 2465 } */ *uap = v; 2466 struct sys_munlock_args ua; 2467 2468 SPARC32TOP_UAP(addr, const void); 2469 SPARC32TO64_UAP(len); 2470 return (sys_munlock(p, &ua, retval)); 2471 } 2472 2473 int 2474 compat_sparc32_undelete(p, v, retval) 2475 struct proc *p; 2476 void *v; 2477 register_t *retval; 2478 { 2479 struct compat_sparc32_undelete_args /* { 2480 syscallarg(const sparc32_charp) path; 2481 } */ *uap = v; 2482 struct sys_undelete_args ua; 2483 2484 SPARC32TOP_UAP(path, const char); 2485 return (sys_undelete(p, &ua, retval)); 2486 } 2487 2488 int 2489 compat_sparc32_futimes(p, v, retval) 2490 struct proc *p; 2491 void *v; 2492 register_t *retval; 2493 { 2494 struct compat_sparc32_futimes_args /* { 2495 syscallarg(int) fd; 2496 syscallarg(const sparc32_timevalp_t) tptr; 2497 } */ *uap = v; 2498 struct sys_futimes_args ua; 2499 struct timeval tv; 2500 struct sparc32_timeval *tv32p; 2501 2502 SPARC32TO64_UAP(fd); 2503 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr); 2504 if (tv32p) { 2505 SCARG(&ua, tptr) = &tv; 2506 sparc32_to_timeval(tv32p, &tv); 2507 } else 2508 SCARG(&ua, tptr) = NULL; 2509 return (sys_futimes(p, &ua, retval)); 2510 } 2511 2512 int 2513 compat_sparc32_reboot(p, v, retval) 2514 struct proc *p; 2515 void *v; 2516 register_t *retval; 2517 { 2518 struct compat_sparc32_reboot_args /* { 2519 syscallarg(int) opt; 2520 syscallarg(sparc32_charp) bootstr; 2521 } */ *uap = v; 2522 struct sys_reboot_args ua; 2523 2524 SPARC32TO64_UAP(opt); 2525 SPARC32TOP_UAP(bootstr, char); 2526 return (sys_reboot(p, &ua, retval)); 2527 } 2528 2529 int 2530 compat_sparc32_poll(p, v, retval) 2531 struct proc *p; 2532 void *v; 2533 register_t *retval; 2534 { 2535 struct compat_sparc32_poll_args /* { 2536 syscallarg(sparc32_pollfdp_t) fds; 2537 syscallarg(u_int) nfds; 2538 syscallarg(int) timeout; 2539 } */ *uap = v; 2540 struct sys_poll_args ua; 2541 2542 SPARC32TOP_UAP(fds, struct pollfd); 2543 SPARC32TO64_UAP(nfds); 2544 SPARC32TO64_UAP(timeout); 2545 return (sys_poll(p, &ua, retval)); 2546 } 2547 2548 int 2549 compat_sparc32___semctl(p, v, retval) 2550 struct proc *p; 2551 void *v; 2552 register_t *retval; 2553 { 2554 struct compat_sparc32___semctl_args /* { 2555 syscallarg(int) semid; 2556 syscallarg(int) semnum; 2557 syscallarg(int) cmd; 2558 syscallarg(sparc32_semunu_t) arg; 2559 } */ *uap = v; 2560 struct sys___semctl_args ua; 2561 struct semid_ds ds, *dsp = &ds; 2562 union sparc32_semun *sem32p; 2563 int error; 2564 2565 SPARC32TO64_UAP(semid); 2566 SPARC32TO64_UAP(semnum); 2567 SPARC32TO64_UAP(cmd); 2568 sem32p = (union sparc32_semun *)(u_long)SCARG(uap, arg); 2569 if (sem32p) { 2570 SCARG(&ua, arg)->buf = dsp; 2571 switch (SCARG(uap, cmd)) { 2572 case IPC_SET: 2573 sparc32_to_semid_ds(sem32p->buf, &ds); 2574 break; 2575 case SETVAL: 2576 SCARG(&ua, arg)->val = sem32p->val; 2577 break; 2578 case SETALL: 2579 SCARG(&ua, arg)->array = (u_short *)(u_long)sem32p->array; 2580 break; 2581 } 2582 } else 2583 SCARG(&ua, arg) = NULL; 2584 2585 error = sys___semctl(p, &ua, retval); 2586 if (error) 2587 return (error); 2588 2589 if (sem32p) { 2590 switch (SCARG(uap, cmd)) { 2591 case IPC_STAT: 2592 sparc32_from_semid_ds(&ds, sem32p->buf); 2593 break; 2594 } 2595 } 2596 return (0); 2597 } 2598 2599 int 2600 compat_sparc32_semget(p, v, retval) 2601 struct proc *p; 2602 void *v; 2603 register_t *retval; 2604 { 2605 struct compat_sparc32_semget_args /* { 2606 syscallarg(sparc32_key_t) key; 2607 syscallarg(int) nsems; 2608 syscallarg(int) semflg; 2609 } */ *uap = v; 2610 struct sys_semget_args ua; 2611 2612 SPARC32TOX_UAP(key, key_t); 2613 SPARC32TO64_UAP(nsems); 2614 SPARC32TO64_UAP(semflg); 2615 return (sys_semget(p, &ua, retval)); 2616 } 2617 2618 int 2619 compat_sparc32_semop(p, v, retval) 2620 struct proc *p; 2621 void *v; 2622 register_t *retval; 2623 { 2624 struct compat_sparc32_semop_args /* { 2625 syscallarg(int) semid; 2626 syscallarg(sparc32_sembufp_t) sops; 2627 syscallarg(sparc32_size_t) nsops; 2628 } */ *uap = v; 2629 struct sys_semop_args ua; 2630 2631 SPARC32TO64_UAP(semid); 2632 SPARC32TOP_UAP(sops, struct sembuf); 2633 SPARC32TOX_UAP(nsops, size_t); 2634 return (sys_semop(p, &ua, retval)); 2635 } 2636 2637 int 2638 compat_sparc32_msgctl(p, v, retval) 2639 struct proc *p; 2640 void *v; 2641 register_t *retval; 2642 { 2643 struct compat_sparc32_msgctl_args /* { 2644 syscallarg(int) msqid; 2645 syscallarg(int) cmd; 2646 syscallarg(sparc32_msqid_dsp_t) buf; 2647 } */ *uap = v; 2648 struct sys_msgctl_args ua; 2649 struct msqid_ds ds; 2650 struct sparc32_msqid_ds *ds32p; 2651 int error; 2652 2653 SPARC32TO64_UAP(msqid); 2654 SPARC32TO64_UAP(cmd); 2655 ds32p = (struct sparc32_msqid_ds *)(u_long)SCARG(uap, buf); 2656 if (ds32p) { 2657 SCARG(&ua, buf) = NULL; 2658 sparc32_to_msqid_ds(ds32p, &ds); 2659 } else 2660 SCARG(&ua, buf) = NULL; 2661 error = sys_msgctl(p, &ua, retval); 2662 if (error) 2663 return (error); 2664 2665 if (ds32p) 2666 sparc32_from_msqid_ds(&ds, ds32p); 2667 return (0); 2668 } 2669 2670 int 2671 compat_sparc32_msgget(p, v, retval) 2672 struct proc *p; 2673 void *v; 2674 register_t *retval; 2675 { 2676 struct compat_sparc32_msgget_args /* { 2677 syscallarg(sparc32_key_t) key; 2678 syscallarg(int) msgflg; 2679 } */ *uap = v; 2680 struct sys_msgget_args ua; 2681 2682 SPARC32TOX_UAP(key, key_t); 2683 SPARC32TO64_UAP(msgflg); 2684 return (sys_msgget(p, &ua, retval)); 2685 } 2686 2687 int 2688 compat_sparc32_msgsnd(p, v, retval) 2689 struct proc *p; 2690 void *v; 2691 register_t *retval; 2692 { 2693 struct compat_sparc32_msgsnd_args /* { 2694 syscallarg(int) msqid; 2695 syscallarg(const sparc32_voidp) msgp; 2696 syscallarg(sparc32_size_t) msgsz; 2697 syscallarg(int) msgflg; 2698 } */ *uap = v; 2699 struct sys_msgsnd_args ua; 2700 2701 SPARC32TO64_UAP(msqid); 2702 SPARC32TOP_UAP(msgp, void); 2703 SPARC32TOX_UAP(msgsz, size_t); 2704 SPARC32TO64_UAP(msgflg); 2705 return (sys_msgsnd(p, &ua, retval)); 2706 } 2707 2708 int 2709 compat_sparc32_msgrcv(p, v, retval) 2710 struct proc *p; 2711 void *v; 2712 register_t *retval; 2713 { 2714 struct compat_sparc32_msgrcv_args /* { 2715 syscallarg(int) msqid; 2716 syscallarg(sparc32_voidp) msgp; 2717 syscallarg(sparc32_size_t) msgsz; 2718 syscallarg(sparc32_long) msgtyp; 2719 syscallarg(int) msgflg; 2720 } */ *uap = v; 2721 struct sys_msgrcv_args ua; 2722 ssize_t rt; 2723 int error; 2724 2725 SPARC32TO64_UAP(msqid); 2726 SPARC32TOP_UAP(msgp, void); 2727 SPARC32TOX_UAP(msgsz, size_t); 2728 SPARC32TOX_UAP(msgtyp, long); 2729 SPARC32TO64_UAP(msgflg); 2730 error = sys_msgrcv(p, &ua, (register_t *)&rt); 2731 *(sparc32_ssize_t *)retval = rt; 2732 return (error); 2733 } 2734 2735 int 2736 compat_sparc32_shmat(p, v, retval) 2737 struct proc *p; 2738 void *v; 2739 register_t *retval; 2740 { 2741 struct compat_sparc32_shmat_args /* { 2742 syscallarg(int) shmid; 2743 syscallarg(const sparc32_voidp) shmaddr; 2744 syscallarg(int) shmflg; 2745 } */ *uap = v; 2746 struct sys_shmat_args ua; 2747 void *rt; 2748 int error; 2749 2750 SPARC32TO64_UAP(shmid); 2751 SPARC32TOP_UAP(shmaddr, void); 2752 SPARC32TO64_UAP(shmflg); 2753 error = sys_shmat(p, &ua, (register_t *)&rt); 2754 *retval = (sparc32_voidp)(u_long)rt; 2755 return (error); 2756 } 2757 2758 int 2759 compat_sparc32_shmctl(p, v, retval) 2760 struct proc *p; 2761 void *v; 2762 register_t *retval; 2763 { 2764 struct compat_sparc32_shmctl_args /* { 2765 syscallarg(int) shmid; 2766 syscallarg(int) cmd; 2767 syscallarg(sparc32_shmid_dsp_t) buf; 2768 } */ *uap = v; 2769 struct sys_shmctl_args ua; 2770 struct shmid_ds ds; 2771 struct sparc32_shmid_ds *ds32p; 2772 int error; 2773 2774 SPARC32TO64_UAP(shmid); 2775 SPARC32TO64_UAP(cmd); 2776 ds32p = (struct sparc32_shmid_ds *)(u_long)SCARG(uap, buf); 2777 if (ds32p) { 2778 SCARG(&ua, buf) = NULL; 2779 sparc32_to_shmid_ds(ds32p, &ds); 2780 } else 2781 SCARG(&ua, buf) = NULL; 2782 error = sys_shmctl(p, &ua, retval); 2783 if (error) 2784 return (error); 2785 2786 if (ds32p) 2787 sparc32_from_shmid_ds(&ds, ds32p); 2788 return (0); 2789 } 2790 2791 int 2792 compat_sparc32_shmdt(p, v, retval) 2793 struct proc *p; 2794 void *v; 2795 register_t *retval; 2796 { 2797 struct compat_sparc32_shmdt_args /* { 2798 syscallarg(const sparc32_voidp) shmaddr; 2799 } */ *uap = v; 2800 struct sys_shmdt_args ua; 2801 2802 SPARC32TOP_UAP(shmaddr, const char); 2803 return (sys_shmdt(p, &ua, retval)); 2804 } 2805 2806 int 2807 compat_sparc32_shmget(p, v, retval) 2808 struct proc *p; 2809 void *v; 2810 register_t *retval; 2811 { 2812 struct compat_sparc32_shmget_args /* { 2813 syscallarg(sparc32_key_t) key; 2814 syscallarg(sparc32_size_t) size; 2815 syscallarg(int) shmflg; 2816 } */ *uap = v; 2817 struct sys_shmget_args ua; 2818 2819 SPARC32TOX_UAP(key, key_t) 2820 SPARC32TOX_UAP(size, size_t) 2821 SPARC32TO64_UAP(shmflg); 2822 return (sys_shmget(p, &ua, retval)); 2823 } 2824 2825 int 2826 compat_sparc32_clock_gettime(p, v, retval) 2827 struct proc *p; 2828 void *v; 2829 register_t *retval; 2830 { 2831 struct compat_sparc32_clock_gettime_args /* { 2832 syscallarg(sparc32_clockid_t) clock_id; 2833 syscallarg(sparc32_timespecp_t) tp; 2834 } */ *uap = v; 2835 struct sys_clock_gettime_args ua; 2836 struct timespec ts; 2837 struct sparc32_timespec *ts32p; 2838 int error; 2839 2840 SPARC32TO64_UAP(clock_id); 2841 ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp); 2842 if (ts32p) 2843 SCARG(&ua, tp) = &ts; 2844 else 2845 SCARG(&ua, tp) = NULL; 2846 error = sys_clock_gettime(p, &ua, retval); 2847 if (error) 2848 return (error); 2849 2850 if (ts32p) 2851 sparc32_from_timespec(&ts, ts32p); 2852 return (0); 2853 } 2854 2855 int 2856 compat_sparc32_clock_settime(p, v, retval) 2857 struct proc *p; 2858 void *v; 2859 register_t *retval; 2860 { 2861 struct compat_sparc32_clock_settime_args /* { 2862 syscallarg(sparc32_clockid_t) clock_id; 2863 syscallarg(const sparc32_timespecp_t) tp; 2864 } */ *uap = v; 2865 struct sys_clock_settime_args ua; 2866 struct timespec ts; 2867 struct sparc32_timespec *ts32p; 2868 2869 SPARC32TO64_UAP(clock_id); 2870 ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp); 2871 if (ts32p) { 2872 SCARG(&ua, tp) = &ts; 2873 sparc32_to_timespec(ts32p, &ts); 2874 } else 2875 SCARG(&ua, tp) = NULL; 2876 return (sys_clock_settime(p, &ua, retval)); 2877 } 2878 2879 int 2880 compat_sparc32_clock_getres(p, v, retval) 2881 struct proc *p; 2882 void *v; 2883 register_t *retval; 2884 { 2885 struct compat_sparc32_clock_getres_args /* { 2886 syscallarg(sparc32_clockid_t) clock_id; 2887 syscallarg(sparc32_timespecp_t) tp; 2888 } */ *uap = v; 2889 struct sys_clock_getres_args ua; 2890 struct timespec ts; 2891 struct sparc32_timespec *ts32p; 2892 int error; 2893 2894 SPARC32TO64_UAP(clock_id); 2895 ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp); 2896 if (ts32p) 2897 SCARG(&ua, tp) = &ts; 2898 else 2899 SCARG(&ua, tp) = NULL; 2900 error = sys_clock_getres(p, &ua, retval); 2901 if (error) 2902 return (error); 2903 2904 if (ts32p) 2905 sparc32_from_timespec(&ts, ts32p); 2906 return (0); 2907 } 2908 2909 int 2910 compat_sparc32_nanosleep(p, v, retval) 2911 struct proc *p; 2912 void *v; 2913 register_t *retval; 2914 { 2915 struct compat_sparc32_nanosleep_args /* { 2916 syscallarg(const sparc32_timespecp_t) rqtp; 2917 syscallarg(sparc32_timespecp_t) rmtp; 2918 } */ *uap = v; 2919 struct sys_nanosleep_args ua; 2920 struct timespec qts, mts; 2921 struct sparc32_timespec *qts32p, *mts32p; 2922 int error; 2923 2924 qts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, rqtp); 2925 mts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, rmtp); 2926 if (qts32p) { 2927 SCARG(&ua, rqtp) = &qts; 2928 sparc32_to_timespec(qts32p, &qts); 2929 } else 2930 SCARG(&ua, rqtp) = NULL; 2931 if (mts32p) { 2932 SCARG(&ua, rmtp) = &mts; 2933 } else 2934 SCARG(&ua, rmtp) = NULL; 2935 error = sys_nanosleep(p, &ua, retval); 2936 if (error) 2937 return (error); 2938 2939 if (mts32p) 2940 sparc32_from_timespec(&mts, mts32p); 2941 return (0); 2942 } 2943 2944 int 2945 compat_sparc32___posix_rename(p, v, retval) 2946 struct proc *p; 2947 void *v; 2948 register_t *retval; 2949 { 2950 struct compat_sparc32___posix_rename_args /* { 2951 syscallarg(const sparc32_charp) from; 2952 syscallarg(const sparc32_charp) to; 2953 } */ *uap = v; 2954 struct sys___posix_rename_args ua; 2955 2956 SPARC32TOP_UAP(from, const char) 2957 SPARC32TOP_UAP(to, const char) 2958 return (sys___posix_rename(p, &ua, retval)); 2959 } 2960 2961 int 2962 compat_sparc32_swapctl(p, v, retval) 2963 struct proc *p; 2964 void *v; 2965 register_t *retval; 2966 { 2967 struct compat_sparc32_swapctl_args /* { 2968 syscallarg(int) cmd; 2969 syscallarg(const sparc32_voidp) arg; 2970 syscallarg(int) misc; 2971 } */ *uap = v; 2972 struct sys_swapctl_args ua; 2973 2974 SPARC32TO64_UAP(cmd); 2975 SPARC32TOP_UAP(arg, const void); 2976 SPARC32TO64_UAP(misc); 2977 return (sys_swapctl(p, &ua, retval)); 2978 } 2979 2980 int 2981 compat_sparc32_getdents(p, v, retval) 2982 struct proc *p; 2983 void *v; 2984 register_t *retval; 2985 { 2986 struct compat_sparc32_getdents_args /* { 2987 syscallarg(int) fd; 2988 syscallarg(sparc32_charp) buf; 2989 syscallarg(sparc32_size_t) count; 2990 } */ *uap = v; 2991 struct sys_getdents_args ua; 2992 2993 SPARC32TO64_UAP(fd); 2994 SPARC32TOP_UAP(buf, char); 2995 SPARC32TOX_UAP(count, size_t); 2996 return (sys_getdents(p, &ua, retval)); 2997 } 2998 2999 int 3000 compat_sparc32_minherit(p, v, retval) 3001 struct proc *p; 3002 void *v; 3003 register_t *retval; 3004 { 3005 struct compat_sparc32_minherit_args /* { 3006 syscallarg(sparc32_voidp) addr; 3007 syscallarg(sparc32_size_t) len; 3008 syscallarg(int) inherit; 3009 } */ *uap = v; 3010 struct sys_minherit_args ua; 3011 3012 SPARC32TOP_UAP(addr, void); 3013 SPARC32TOX_UAP(len, size_t); 3014 SPARC32TO64_UAP(inherit); 3015 return (sys_minherit(p, &ua, retval)); 3016 } 3017 3018 int 3019 compat_sparc32_lchmod(p, v, retval) 3020 struct proc *p; 3021 void *v; 3022 register_t *retval; 3023 { 3024 struct compat_sparc32_lchmod_args /* { 3025 syscallarg(const sparc32_charp) path; 3026 syscallarg(mode_t) mode; 3027 } */ *uap = v; 3028 struct sys_lchmod_args ua; 3029 3030 SPARC32TOP_UAP(path, const char); 3031 SPARC32TO64_UAP(mode); 3032 return (sys_lchmod(p, &ua, retval)); 3033 } 3034 3035 int 3036 compat_sparc32_lchown(p, v, retval) 3037 struct proc *p; 3038 void *v; 3039 register_t *retval; 3040 { 3041 struct compat_sparc32_lchown_args /* { 3042 syscallarg(const sparc32_charp) path; 3043 syscallarg(uid_t) uid; 3044 syscallarg(gid_t) gid; 3045 } */ *uap = v; 3046 struct sys_lchown_args ua; 3047 3048 SPARC32TOP_UAP(path, const char); 3049 SPARC32TO64_UAP(uid); 3050 SPARC32TO64_UAP(gid); 3051 return (sys_lchown(p, &ua, retval)); 3052 } 3053 3054 int 3055 compat_sparc32_lutimes(p, v, retval) 3056 struct proc *p; 3057 void *v; 3058 register_t *retval; 3059 { 3060 struct compat_sparc32_lutimes_args /* { 3061 syscallarg(const sparc32_charp) path; 3062 syscallarg(const sparc32_timevalp_t) tptr; 3063 } */ *uap = v; 3064 struct sys_lutimes_args ua; 3065 struct timeval tv; 3066 struct sparc32_timeval *tv32p; 3067 3068 SPARC32TOP_UAP(path, const char); 3069 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr); 3070 if (tv32p) { 3071 SCARG(&ua, tptr) = &tv; 3072 sparc32_to_timeval(tv32p, &tv); 3073 } 3074 SCARG(&ua, tptr) = NULL; 3075 return (sys_lutimes(p, &ua, retval)); 3076 } 3077 3078 int 3079 compat_sparc32___msync13(p, v, retval) 3080 struct proc *p; 3081 void *v; 3082 register_t *retval; 3083 { 3084 struct compat_sparc32___msync13_args /* { 3085 syscallarg(sparc32_voidp) addr; 3086 syscallarg(sparc32_size_t) len; 3087 syscallarg(int) flags; 3088 } */ *uap = v; 3089 struct sys___msync13_args ua; 3090 3091 SPARC32TOP_UAP(addr, void); 3092 SPARC32TOX_UAP(len, size_t); 3093 SPARC32TO64_UAP(flags); 3094 return (sys___msync13(p, &ua, retval)); 3095 } 3096 3097 int 3098 compat_sparc32___stat13(p, v, retval) 3099 struct proc *p; 3100 void *v; 3101 register_t *retval; 3102 { 3103 struct compat_sparc32___stat13_args /* { 3104 syscallarg(const sparc32_charp) path; 3105 syscallarg(sparc32_statp_t) ub; 3106 } */ *uap = v; 3107 struct sys___stat13_args ua; 3108 struct stat sb; 3109 struct sparc32_stat *sb32p; 3110 caddr_t sg; 3111 int error; 3112 3113 SPARC32TOP_UAP(path, const char); 3114 sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, ub); 3115 if (sb32p) 3116 SCARG(&ua, ub) = &sb; 3117 else 3118 SCARG(&ua, ub) = NULL; 3119 sg = stackgap_init(p->p_emul); 3120 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 3121 3122 error = sys___stat13(p, &ua, retval); 3123 if (error) 3124 return (error); 3125 3126 if (sb32p) 3127 sparc32_from___stat13(&sb, sb32p); 3128 return (0); 3129 } 3130 3131 int 3132 compat_sparc32___fstat13(p, v, retval) 3133 struct proc *p; 3134 void *v; 3135 register_t *retval; 3136 { 3137 struct compat_sparc32___fstat13_args /* { 3138 syscallarg(int) fd; 3139 syscallarg(sparc32_statp_t) sb; 3140 } */ *uap = v; 3141 struct sys___fstat13_args ua; 3142 struct stat sb; 3143 struct sparc32_stat *sb32p; 3144 int error; 3145 3146 SPARC32TO64_UAP(fd); 3147 sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, sb); 3148 if (sb32p) 3149 SCARG(&ua, sb) = &sb; 3150 else 3151 SCARG(&ua, sb) = NULL; 3152 error = sys___fstat13(p, &ua, retval); 3153 if (error) 3154 return (error); 3155 3156 if (sb32p) 3157 sparc32_from___stat13(&sb, sb32p); 3158 return (0); 3159 } 3160 3161 int 3162 compat_sparc32___lstat13(p, v, retval) 3163 struct proc *p; 3164 void *v; 3165 register_t *retval; 3166 { 3167 struct compat_sparc32___lstat13_args /* { 3168 syscallarg(const sparc32_charp) path; 3169 syscallarg(sparc32_statp_t) ub; 3170 } */ *uap = v; 3171 3172 struct sys___lstat13_args ua; 3173 struct stat sb; 3174 struct sparc32_stat *sb32p; 3175 caddr_t sg; 3176 int error; 3177 3178 SPARC32TOP_UAP(path, const char); 3179 sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, ub); 3180 if (sb32p) 3181 SCARG(&ua, ub) = &sb; 3182 else 3183 SCARG(&ua, ub) = NULL; 3184 sg = stackgap_init(p->p_emul); 3185 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 3186 error = sys___lstat13(p, &ua, retval); 3187 if (error) 3188 return (error); 3189 3190 if (sb32p) 3191 sparc32_from___stat13(&sb, sb32p); 3192 return (0); 3193 } 3194 3195 int 3196 compat_sparc32___sigaltstack14(p, v, retval) 3197 struct proc *p; 3198 void *v; 3199 register_t *retval; 3200 { 3201 struct compat_sparc32___sigaltstack14_args /* { 3202 syscallarg(const sparc32_sigaltstackp_t) nss; 3203 syscallarg(sparc32_sigaltstackp_t) oss; 3204 } */ *uap = v; 3205 struct sys___sigaltstack14_args ua; 3206 struct sparc32_sigaltstack *nss32, *oss32; 3207 struct sigaltstack nss, oss; 3208 int error; 3209 3210 nss32 = (struct sparc32_sigaltstack *)(u_long)SCARG(uap, nss); 3211 oss32 = (struct sparc32_sigaltstack *)(u_long)SCARG(uap, oss); 3212 if (nss32) { 3213 SCARG(&ua, nss) = &nss; 3214 nss.ss_sp = (void *)(u_long)nss32->ss_sp; 3215 nss.ss_size = (size_t)nss32->ss_size; 3216 nss.ss_flags = nss32->ss_flags; 3217 } else 3218 SCARG(&ua, nss) = NULL; 3219 if (oss32) 3220 SCARG(&ua, oss) = &oss; 3221 else 3222 SCARG(&ua, oss) = NULL; 3223 3224 error = sys___sigaltstack14(p, &ua, retval); 3225 if (error) 3226 return (error); 3227 3228 if (oss32) { 3229 oss32->ss_sp = (sparc32_voidp)(u_long)oss.ss_sp; 3230 oss32->ss_size = (sparc32_size_t)oss.ss_size; 3231 oss32->ss_flags = oss.ss_flags; 3232 } 3233 return (0); 3234 } 3235 3236 int 3237 compat_sparc32___posix_chown(p, v, retval) 3238 struct proc *p; 3239 void *v; 3240 register_t *retval; 3241 { 3242 struct compat_sparc32___posix_chown_args /* { 3243 syscallarg(const sparc32_charp) path; 3244 syscallarg(uid_t) uid; 3245 syscallarg(gid_t) gid; 3246 } */ *uap = v; 3247 struct sys___posix_chown_args ua; 3248 3249 SPARC32TOP_UAP(path, const char); 3250 SPARC32TO64_UAP(uid); 3251 SPARC32TO64_UAP(gid); 3252 return (sys___posix_chown(p, &ua, retval)); 3253 } 3254 3255 int 3256 compat_sparc32___posix_lchown(p, v, retval) 3257 struct proc *p; 3258 void *v; 3259 register_t *retval; 3260 { 3261 struct compat_sparc32___posix_lchown_args /* { 3262 syscallarg(const sparc32_charp) path; 3263 syscallarg(uid_t) uid; 3264 syscallarg(gid_t) gid; 3265 } */ *uap = v; 3266 struct sys___posix_lchown_args ua; 3267 3268 SPARC32TOP_UAP(path, const char); 3269 SPARC32TO64_UAP(uid); 3270 SPARC32TO64_UAP(gid); 3271 return (sys___posix_lchown(p, &ua, retval)); 3272 } 3273 3274 int 3275 compat_sparc32_preadv(p, v, retval) 3276 struct proc *p; 3277 void *v; 3278 register_t *retval; 3279 { 3280 struct compat_sparc32_preadv_args /* { 3281 syscallarg(int) fd; 3282 syscallarg(const sparc32_iovecp_t) iovp; 3283 syscallarg(int) iovcnt; 3284 syscallarg(int) pad; 3285 syscallarg(off_t) offset; 3286 } */ *uap = v; 3287 struct sys_preadv_args ua; 3288 struct iovec *iov; 3289 ssize_t rt; 3290 int error; 3291 3292 SPARC32TO64_UAP(fd); 3293 SPARC32TO64_UAP(iovcnt); 3294 SPARC32TO64_UAP(pad); 3295 SPARC32TO64_UAP(offset); 3296 MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt), 3297 M_TEMP, M_WAITOK); 3298 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov, 3299 SCARG(uap, iovcnt)); 3300 SCARG(&ua, iovp) = iov; 3301 3302 error = sys_preadv(p, &ua, (register_t *)&rt); 3303 FREE(iov, M_TEMP); 3304 *(sparc32_ssize_t *)retval = rt; 3305 return (error); 3306 } 3307 3308 int 3309 compat_sparc32_pwritev(p, v, retval) 3310 struct proc *p; 3311 void *v; 3312 register_t *retval; 3313 { 3314 struct compat_sparc32_pwritev_args /* { 3315 syscallarg(int) fd; 3316 syscallarg(const sparc32_iovecp_t) iovp; 3317 syscallarg(int) iovcnt; 3318 syscallarg(int) pad; 3319 syscallarg(off_t) offset; 3320 } */ *uap = v; 3321 struct sys_pwritev_args ua; 3322 struct iovec *iov; 3323 ssize_t rt; 3324 int error; 3325 3326 SPARC32TO64_UAP(fd); 3327 SPARC32TO64_UAP(iovcnt); 3328 SPARC32TO64_UAP(pad); 3329 SPARC32TO64_UAP(offset); 3330 MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt), 3331 M_TEMP, M_WAITOK); 3332 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov, 3333 SCARG(uap, iovcnt)); 3334 SCARG(&ua, iovp) = iov; 3335 3336 error = sys_pwritev(p, &ua, (register_t *)&rt); 3337 FREE(iov, M_TEMP); 3338 *(sparc32_ssize_t *)retval = rt; 3339 return (error); 3340 } 3341
Indexes created Sun Sep 21 20:09:37 GMT 2025