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