netbsd32_netbsd.c revision 1.6
1 /* $NetBSD: netbsd32_netbsd.c,v 1.6 1998/10/01 14:27:57 eeh Exp $ */ 2 3 /* 4 * Copyright (c) 1998 Matthew R. Green 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include "opt_ktrace.h" 32 #include "opt_ntp.h" 33 #include "fs_lfs.h" 34 #include "fs_nfs.h" 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/ipc.h> 40 #include <sys/msg.h> 41 #include <sys/sem.h> 42 #include <sys/shm.h> 43 #include <sys/malloc.h> 44 #include <sys/mount.h> 45 #include <sys/socket.h> 46 #include <sys/sockio.h> 47 #include <sys/socketvar.h> 48 #include <sys/mbuf.h> 49 #include <sys/stat.h> 50 #include <sys/time.h> 51 #include <sys/timex.h> 52 #include <sys/signalvar.h> 53 #include <sys/wait.h> 54 #include <sys/ptrace.h> 55 #include <sys/ktrace.h> 56 #include <sys/trace.h> 57 #include <sys/resourcevar.h> 58 #include <sys/pool.h> 59 #include <sys/vnode.h> 60 #include <sys/file.h> 61 #include <sys/filedesc.h> 62 #include <sys/namei.h> 63 64 #include <vm/vm.h> 65 #include <sys/syscallargs.h> 66 #include <sys/proc.h> 67 #include <sys/sysctl.h> 68 69 #include <net/if.h> 70 71 #include <compat/sparc32/sparc32.h> 72 #include <compat/sparc32/sparc32_syscallargs.h> 73 74 #include <machine/frame.h> 75 76 static __inline void sparc32_from_timeval __P((struct timeval *, struct sparc32_timeval *)); 77 static __inline void sparc32_to_timeval __P((struct sparc32_timeval *, struct timeval *)); 78 static __inline void sparc32_from_itimerval __P((struct itimerval *, struct sparc32_itimerval *)); 79 static __inline void sparc32_to_itimerval __P((struct sparc32_itimerval *, struct itimerval *)); 80 static __inline void sparc32_to_timespec __P((struct sparc32_timespec *, struct timespec *)); 81 static __inline void sparc32_from_timespec __P((struct timespec *, struct sparc32_timespec *)); 82 static __inline void sparc32_from_rusage __P((struct rusage *, struct sparc32_rusage *)); 83 static __inline void sparc32_to_rusage __P((struct sparc32_rusage *, struct rusage *)); 84 static __inline int sparc32_to_iovecin __P((struct sparc32_iovec *, struct iovec *, int)); 85 static __inline void sparc32_to_msghdr __P((struct sparc32_msghdr *, struct msghdr *)); 86 static __inline void sparc32_from_msghdr __P((struct sparc32_msghdr *, struct msghdr *)); 87 static __inline void sparc32_from_statfs __P((struct statfs *, struct sparc32_statfs *)); 88 static __inline void sparc32_from_timex __P((struct timex *, struct sparc32_timex *)); 89 static __inline void sparc32_to_timex __P((struct sparc32_timex *, struct timex *)); 90 static __inline void sparc32_from___stat13 __P((struct stat *, struct sparc32_stat *)); 91 static __inline void sparc32_to_ipc_perm __P((struct sparc32_ipc_perm *, struct ipc_perm *)); 92 static __inline void sparc32_from_ipc_perm __P((struct ipc_perm *, struct sparc32_ipc_perm *)); 93 static __inline void sparc32_to_msg __P((struct sparc32_msg *, struct msg *)); 94 static __inline void sparc32_from_msg __P((struct msg *, struct sparc32_msg *)); 95 static __inline void sparc32_to_msqid_ds __P((struct sparc32_msqid_ds *, struct msqid_ds *)); 96 static __inline void sparc32_from_msqid_ds __P((struct msqid_ds *, struct sparc32_msqid_ds *)); 97 static __inline void sparc32_to_shmid_ds __P((struct sparc32_shmid_ds *, struct shmid_ds *)); 98 static __inline void sparc32_from_shmid_ds __P((struct shmid_ds *, struct sparc32_shmid_ds *)); 99 static __inline void sparc32_to_semid_ds __P((struct sparc32_semid_ds *, struct semid_ds *)); 100 static __inline void sparc32_from_semid_ds __P((struct semid_ds *, struct sparc32_semid_ds *)); 101 102 103 static int recvit32 __P((struct proc *, int, struct sparc32_msghdr *, struct iovec *, caddr_t, 104 register_t *)); 105 static int dofilereadv32 __P((struct proc *, int, struct file *, struct sparc32_iovec *, 106 int, off_t *, int, register_t *)); 107 static int dofilewritev32 __P((struct proc *, int, struct file *, struct sparc32_iovec *, 108 int, off_t *, int, register_t *)); 109 static int change_utimes32 __P((struct vnode *, struct timeval *, struct proc *)); 110 111 /* converters for structures that we need */ 112 static __inline void 113 sparc32_from_timeval(tv, tv32) 114 struct timeval *tv; 115 struct sparc32_timeval *tv32; 116 { 117 118 tv32->tv_sec = (sparc32_long)tv->tv_sec; 119 tv32->tv_usec = (sparc32_long)tv->tv_usec; 120 } 121 122 static __inline void 123 sparc32_to_timeval(tv32, tv) 124 struct sparc32_timeval *tv32; 125 struct timeval *tv; 126 { 127 128 tv->tv_sec = (long)tv32->tv_sec; 129 tv->tv_usec = (long)tv32->tv_usec; 130 } 131 132 static __inline void 133 sparc32_from_itimerval(itv, itv32) 134 struct itimerval *itv; 135 struct sparc32_itimerval *itv32; 136 { 137 138 sparc32_from_timeval(&itv->it_interval, 139 &itv32->it_interval); 140 sparc32_from_timeval(&itv->it_value, 141 &itv32->it_value); 142 } 143 144 static __inline void 145 sparc32_to_itimerval(itv32, itv) 146 struct sparc32_itimerval *itv32; 147 struct itimerval *itv; 148 { 149 150 sparc32_to_timeval(&itv32->it_interval, &itv->it_interval); 151 sparc32_to_timeval(&itv32->it_value, &itv->it_value); 152 } 153 154 static __inline void 155 sparc32_to_timespec(s32p, p) 156 struct sparc32_timespec *s32p; 157 struct timespec *p; 158 { 159 160 p->tv_sec = s32p->tv_sec; 161 p->tv_nsec = (long)s32p->tv_nsec; 162 } 163 164 static __inline void 165 sparc32_from_timespec(p, s32p) 166 struct timespec *p; 167 struct sparc32_timespec *s32p; 168 { 169 170 s32p->tv_sec = p->tv_sec; 171 s32p->tv_nsec = (sparc32_long)p->tv_nsec; 172 } 173 174 static __inline void 175 sparc32_from_rusage(rup, ru32p) 176 struct rusage *rup; 177 struct sparc32_rusage *ru32p; 178 { 179 180 sparc32_from_timeval(&rup->ru_utime, &ru32p->ru_utime); 181 sparc32_from_timeval(&rup->ru_stime, &ru32p->ru_stime); 182 #define C(var) ru32p->var = (sparc32_long)rup->var 183 C(ru_maxrss); 184 C(ru_ixrss); 185 C(ru_idrss); 186 C(ru_isrss); 187 C(ru_minflt); 188 C(ru_majflt); 189 C(ru_nswap); 190 C(ru_inblock); 191 C(ru_oublock); 192 C(ru_msgsnd); 193 C(ru_msgrcv); 194 C(ru_nsignals); 195 C(ru_nvcsw); 196 C(ru_nivcsw); 197 #undef C 198 } 199 200 static __inline void 201 sparc32_to_rusage(ru32p, rup) 202 struct sparc32_rusage *ru32p; 203 struct rusage *rup; 204 { 205 206 sparc32_to_timeval(&ru32p->ru_utime, &rup->ru_utime); 207 sparc32_to_timeval(&ru32p->ru_stime, &rup->ru_stime); 208 #define C(var) rup->var = (long)ru32p->var 209 C(ru_maxrss); 210 C(ru_ixrss); 211 C(ru_idrss); 212 C(ru_isrss); 213 C(ru_minflt); 214 C(ru_majflt); 215 C(ru_nswap); 216 C(ru_inblock); 217 C(ru_oublock); 218 C(ru_msgsnd); 219 C(ru_msgrcv); 220 C(ru_nsignals); 221 C(ru_nvcsw); 222 C(ru_nivcsw); 223 #undef C 224 } 225 226 static __inline int 227 sparc32_to_iovecin(iov32p, iovp, len) 228 struct sparc32_iovec *iov32p; 229 struct iovec *iovp; 230 int len; 231 { 232 int i, error=0; 233 u_int32_t iov_base; 234 u_int32_t iov_len; 235 /* 236 * We could allocate an iov32p, do a copyin, and translate 237 * each field and then free it all up, or we could copyin 238 * each field separately. I'm doing the latter to reduce 239 * the number of MALLOC()s. 240 */ 241 printf("converting iovec at %p len %lx to %p\n", iov32p, len, iovp); 242 for (i = 0; i < len; i++, iovp++, iov32p++) { 243 if ((error = copyin((caddr_t)&iov32p->iov_base, &iov_base, sizeof(iov_base)))) 244 return (error); 245 if ((error = copyin((caddr_t)&iov32p->iov_len, &iov_len, sizeof(iov_len)))) 246 return (error); 247 iovp->iov_base = (void *)(u_long)iov_base; 248 iovp->iov_len = (size_t)iov_len; 249 printf("iovec slot %d base %p len %lx\n", i, iovp->iov_base, iovp->iov_len); 250 } 251 } 252 253 /* msg_iov must be done separately */ 254 static __inline void 255 sparc32_to_msghdr(mhp32, mhp) 256 struct sparc32_msghdr *mhp32; 257 struct msghdr *mhp; 258 { 259 260 mhp->msg_name = (caddr_t)(u_long)mhp32->msg_name; 261 mhp->msg_namelen = mhp32->msg_namelen; 262 mhp->msg_iovlen = (size_t)mhp32->msg_iovlen; 263 mhp->msg_control = (caddr_t)(u_long)mhp32->msg_control; 264 mhp->msg_controllen = mhp32->msg_controllen; 265 mhp->msg_flags = mhp32->msg_flags; 266 } 267 268 /* msg_iov must be done separately */ 269 static __inline void 270 sparc32_from_msghdr(mhp32, mhp) 271 struct sparc32_msghdr *mhp32; 272 struct msghdr *mhp; 273 { 274 275 mhp32->msg_name = mhp32->msg_name; 276 mhp32->msg_namelen = mhp32->msg_namelen; 277 mhp32->msg_iovlen = mhp32->msg_iovlen; 278 mhp32->msg_control = mhp32->msg_control; 279 mhp32->msg_controllen = mhp->msg_controllen; 280 mhp32->msg_flags = mhp->msg_flags; 281 } 282 283 static __inline void 284 sparc32_from_statfs(sbp, sb32p) 285 struct statfs *sbp; 286 struct sparc32_statfs *sb32p; 287 { 288 289 sb32p->f_type = sbp->f_type; 290 sb32p->f_flags = sbp->f_flags; 291 sb32p->f_bsize = (sparc32_long)sbp->f_bsize; 292 sb32p->f_iosize = (sparc32_long)sbp->f_iosize; 293 sb32p->f_blocks = (sparc32_long)sbp->f_blocks; 294 sb32p->f_bfree = (sparc32_long)sbp->f_bfree; 295 sb32p->f_bavail = (sparc32_long)sbp->f_bavail; 296 sb32p->f_files = (sparc32_long)sbp->f_files; 297 sb32p->f_ffree = (sparc32_long)sbp->f_ffree; 298 sb32p->f_fsid = sbp->f_fsid; 299 sb32p->f_owner = sbp->f_owner; 300 sb32p->f_spare[0] = 0; 301 sb32p->f_spare[1] = 0; 302 sb32p->f_spare[2] = 0; 303 sb32p->f_spare[3] = 0; 304 #if 1 305 /* May as well do the whole batch in one go */ 306 memcpy(sb32p->f_fstypename, sbp->f_fstypename, MFSNAMELEN+MNAMELEN+MNAMELEN); 307 #else 308 /* If we want to be careful */ 309 memcpy(sb32p->f_fstypename, sbp->f_fstypename, MFSNAMELEN); 310 memcpy(sb32p->f_mntonname, sbp->f_mntonname, MNAMELEN); 311 memcpy(sb32p->f_mntfromname, sbp->f_mntfromname, MNAMELEN); 312 #endif 313 } 314 315 static __inline void 316 sparc32_from_timex(txp, tx32p) 317 struct timex *txp; 318 struct sparc32_timex *tx32p; 319 { 320 321 tx32p->modes = txp->modes; 322 tx32p->offset = (sparc32_long)txp->offset; 323 tx32p->freq = (sparc32_long)txp->freq; 324 tx32p->maxerror = (sparc32_long)txp->maxerror; 325 tx32p->esterror = (sparc32_long)txp->esterror; 326 tx32p->status = txp->status; 327 tx32p->constant = (sparc32_long)txp->constant; 328 tx32p->precision = (sparc32_long)txp->precision; 329 tx32p->tolerance = (sparc32_long)txp->tolerance; 330 tx32p->ppsfreq = (sparc32_long)txp->ppsfreq; 331 tx32p->jitter = (sparc32_long)txp->jitter; 332 tx32p->shift = txp->shift; 333 tx32p->stabil = (sparc32_long)txp->stabil; 334 tx32p->jitcnt = (sparc32_long)txp->jitcnt; 335 tx32p->calcnt = (sparc32_long)txp->calcnt; 336 tx32p->errcnt = (sparc32_long)txp->errcnt; 337 tx32p->stbcnt = (sparc32_long)txp->stbcnt; 338 } 339 340 static __inline void 341 sparc32_to_timex(tx32p, txp) 342 struct sparc32_timex *tx32p; 343 struct timex *txp; 344 { 345 346 txp->modes = tx32p->modes; 347 txp->offset = (long)tx32p->offset; 348 txp->freq = (long)tx32p->freq; 349 txp->maxerror = (long)tx32p->maxerror; 350 txp->esterror = (long)tx32p->esterror; 351 txp->status = tx32p->status; 352 txp->constant = (long)tx32p->constant; 353 txp->precision = (long)tx32p->precision; 354 txp->tolerance = (long)tx32p->tolerance; 355 txp->ppsfreq = (long)tx32p->ppsfreq; 356 txp->jitter = (long)tx32p->jitter; 357 txp->shift = tx32p->shift; 358 txp->stabil = (long)tx32p->stabil; 359 txp->jitcnt = (long)tx32p->jitcnt; 360 txp->calcnt = (long)tx32p->calcnt; 361 txp->errcnt = (long)tx32p->errcnt; 362 txp->stbcnt = (long)tx32p->stbcnt; 363 } 364 365 static __inline void 366 sparc32_from___stat13(sbp, sb32p) 367 struct stat *sbp; 368 struct sparc32_stat *sb32p; 369 { 370 sb32p->st_dev = sbp->st_dev; 371 sb32p->st_ino = sbp->st_ino; 372 sb32p->st_mode = sbp->st_mode; 373 sb32p->st_nlink = sbp->st_nlink; 374 sb32p->st_uid = sbp->st_uid; 375 sb32p->st_gid = sbp->st_gid; 376 sb32p->st_rdev = sbp->st_rdev; 377 if (sbp->st_size < (quad_t)1 << 32) 378 sb32p->st_size = sbp->st_size; 379 else 380 sb32p->st_size = -2; 381 sb32p->st_atimespec.tv_sec = sbp->st_atimespec.tv_sec; 382 sb32p->st_atimespec.tv_nsec = (sparc32_long)sbp->st_atimespec.tv_nsec; 383 sb32p->st_mtimespec.tv_sec = sbp->st_mtimespec.tv_sec; 384 sb32p->st_mtimespec.tv_nsec = (sparc32_long)sbp->st_mtimespec.tv_nsec; 385 sb32p->st_ctimespec.tv_sec = sbp->st_ctimespec.tv_sec; 386 sb32p->st_ctimespec.tv_nsec = (sparc32_long)sbp->st_ctimespec.tv_nsec; 387 sb32p->st_blksize = sbp->st_blksize; 388 sb32p->st_blocks = sbp->st_blocks; 389 sb32p->st_flags = sbp->st_flags; 390 sb32p->st_gen = sbp->st_gen; 391 } 392 393 static __inline void 394 sparc32_to_ipc_perm(ip32p, ipp) 395 struct sparc32_ipc_perm *ip32p; 396 struct ipc_perm *ipp; 397 { 398 399 ipp->cuid = ip32p->cuid; 400 ipp->cgid = ip32p->cgid; 401 ipp->uid = ip32p->uid; 402 ipp->gid = ip32p->gid; 403 ipp->mode = ip32p->mode; 404 ipp->seq = ip32p->seq; 405 ipp->key = (key_t)ip32p->key; 406 } 407 408 static __inline void 409 sparc32_from_ipc_perm(ipp, ip32p) 410 struct ipc_perm *ipp; 411 struct sparc32_ipc_perm *ip32p; 412 { 413 414 ip32p->cuid = ipp->cuid; 415 ip32p->cgid = ipp->cgid; 416 ip32p->uid = ipp->uid; 417 ip32p->gid = ipp->gid; 418 ip32p->mode = ipp->mode; 419 ip32p->seq = ipp->seq; 420 ip32p->key = (sparc32_key_t)ipp->key; 421 } 422 423 static __inline void 424 sparc32_to_msg(m32p, mp) 425 struct sparc32_msg *m32p; 426 struct msg *mp; 427 { 428 429 mp->msg_next = (struct msg *)(u_long)m32p->msg_next; 430 mp->msg_type = (long)m32p->msg_type; 431 mp->msg_ts = m32p->msg_ts; 432 mp->msg_spot = m32p->msg_spot; 433 } 434 435 static __inline void 436 sparc32_from_msg(mp, m32p) 437 struct msg *mp; 438 struct sparc32_msg *m32p; 439 { 440 441 m32p->msg_next = (sparc32_msgp_t)(u_long)mp->msg_next; 442 m32p->msg_type = (sparc32_long)mp->msg_type; 443 m32p->msg_ts = mp->msg_ts; 444 m32p->msg_spot = mp->msg_spot; 445 } 446 447 static __inline void 448 sparc32_to_msqid_ds(ds32p, dsp) 449 struct sparc32_msqid_ds *ds32p; 450 struct msqid_ds *dsp; 451 { 452 453 sparc32_to_ipc_perm(&ds32p->msg_perm, &dsp->msg_perm); 454 sparc32_to_msg((struct sparc32_msg *)(u_long)ds32p->msg_first, dsp->msg_first); 455 sparc32_to_msg((struct sparc32_msg *)(u_long)ds32p->msg_last, dsp->msg_last); 456 dsp->msg_cbytes = (u_long)ds32p->msg_cbytes; 457 dsp->msg_qnum = (u_long)ds32p->msg_qnum; 458 dsp->msg_qbytes = (u_long)ds32p->msg_qbytes; 459 dsp->msg_lspid = ds32p->msg_lspid; 460 dsp->msg_lrpid = ds32p->msg_lrpid; 461 dsp->msg_rtime = (time_t)ds32p->msg_rtime; 462 dsp->msg_stime = (time_t)ds32p->msg_stime; 463 dsp->msg_ctime = (time_t)ds32p->msg_ctime; 464 } 465 466 static __inline void 467 sparc32_from_msqid_ds(dsp, ds32p) 468 struct msqid_ds *dsp; 469 struct sparc32_msqid_ds *ds32p; 470 { 471 472 sparc32_from_ipc_perm(&dsp->msg_perm, &ds32p->msg_perm); 473 sparc32_from_msg(dsp->msg_first, (struct sparc32_msg *)(u_long)ds32p->msg_first); 474 sparc32_from_msg(dsp->msg_last, (struct sparc32_msg *)(u_long)ds32p->msg_last); 475 ds32p->msg_cbytes = (sparc32_u_long)dsp->msg_cbytes; 476 ds32p->msg_qnum = (sparc32_u_long)dsp->msg_qnum; 477 ds32p->msg_qbytes = (sparc32_u_long)dsp->msg_qbytes; 478 ds32p->msg_lspid = dsp->msg_lspid; 479 ds32p->msg_lrpid = dsp->msg_lrpid; 480 ds32p->msg_rtime = dsp->msg_rtime; 481 ds32p->msg_stime = dsp->msg_stime; 482 ds32p->msg_ctime = dsp->msg_ctime; 483 } 484 485 static __inline void 486 sparc32_to_shmid_ds(ds32p, dsp) 487 struct sparc32_shmid_ds *ds32p; 488 struct shmid_ds *dsp; 489 { 490 491 sparc32_to_ipc_perm(&ds32p->shm_perm, &dsp->shm_perm); 492 dsp->shm_segsz = ds32p->shm_segsz; 493 dsp->shm_lpid = ds32p->shm_lpid; 494 dsp->shm_cpid = ds32p->shm_cpid; 495 dsp->shm_nattch = ds32p->shm_nattch; 496 dsp->shm_atime = (long)ds32p->shm_atime; 497 dsp->shm_dtime = (long)ds32p->shm_dtime; 498 dsp->shm_ctime = (long)ds32p->shm_ctime; 499 dsp->shm_internal = (void *)(u_long)ds32p->shm_internal; 500 } 501 502 static __inline void 503 sparc32_from_shmid_ds(dsp, ds32p) 504 struct shmid_ds *dsp; 505 struct sparc32_shmid_ds *ds32p; 506 { 507 508 sparc32_from_ipc_perm(&dsp->shm_perm, &ds32p->shm_perm); 509 ds32p->shm_segsz = dsp->shm_segsz; 510 ds32p->shm_lpid = dsp->shm_lpid; 511 ds32p->shm_cpid = dsp->shm_cpid; 512 ds32p->shm_nattch = dsp->shm_nattch; 513 ds32p->shm_atime = (sparc32_long)dsp->shm_atime; 514 ds32p->shm_dtime = (sparc32_long)dsp->shm_dtime; 515 ds32p->shm_ctime = (sparc32_long)dsp->shm_ctime; 516 ds32p->shm_internal = (sparc32_voidp)(u_long)dsp->shm_internal; 517 } 518 519 static __inline void 520 sparc32_to_semid_ds(s32dsp, dsp) 521 struct sparc32_semid_ds *s32dsp; 522 struct semid_ds *dsp; 523 { 524 525 sparc32_from_ipc_perm(&dsp->sem_perm, &s32dsp->sem_perm); 526 dsp->sem_base = (struct sem *)(u_long)s32dsp->sem_base; 527 dsp->sem_nsems = s32dsp->sem_nsems; 528 dsp->sem_otime = s32dsp->sem_otime; 529 dsp->sem_ctime = s32dsp->sem_ctime; 530 } 531 532 static __inline void 533 sparc32_from_semid_ds(dsp, s32dsp) 534 struct semid_ds *dsp; 535 struct sparc32_semid_ds *s32dsp; 536 { 537 538 sparc32_to_ipc_perm(&s32dsp->sem_perm, &dsp->sem_perm); 539 s32dsp->sem_base = (sparc32_semp_t)(u_long)dsp->sem_base; 540 s32dsp->sem_nsems = dsp->sem_nsems; 541 s32dsp->sem_otime = dsp->sem_otime; 542 s32dsp->sem_ctime = dsp->sem_ctime; 543 } 544 545 /* 546 * below are all the standard NetBSD system calls, in the 32bit 547 * environment, witht he necessary conversions to 64bit before 548 * calling the real syscall. 549 */ 550 551 552 int 553 compat_sparc32_exit(p, v, retval) 554 struct proc *p; 555 void *v; 556 register_t *retval; 557 { 558 struct compat_sparc32_exit_args /* { 559 syscallarg(int) rval; 560 } */ *uap = v; 561 struct sys_exit_args ua; 562 563 SPARC32TO64_UAP(rval); 564 sys_exit(p, &ua, retval); 565 } 566 567 int 568 compat_sparc32_read(p, v, retval) 569 struct proc *p; 570 void *v; 571 register_t *retval; 572 { 573 struct compat_sparc32_read_args /* { 574 syscallarg(int) fd; 575 syscallarg(sparc32_voidp) buf; 576 syscallarg(sparc32_size_t) nbyte; 577 } */ *uap = v; 578 struct sys_read_args ua; 579 580 SPARC32TO64_UAP(fd); 581 SPARC32TOP_UAP(buf, void *); 582 SPARC32TOX_UAP(nbyte, size_t); 583 return sys_read(p, &ua, retval); 584 } 585 586 int 587 compat_sparc32_write(p, v, retval) 588 struct proc *p; 589 void *v; 590 register_t *retval; 591 { 592 struct compat_sparc32_write_args /* { 593 syscallarg(int) fd; 594 syscallarg(const sparc32_voidp) buf; 595 syscallarg(sparc32_size_t) nbyte; 596 } */ *uap = v; 597 struct sys_write_args ua; 598 599 SPARC32TO64_UAP(fd); 600 SPARC32TOP_UAP(buf, void *); 601 SPARC32TOX_UAP(nbyte, size_t); 602 return sys_write(p, &ua, retval); 603 } 604 605 int 606 compat_sparc32_close(p, v, retval) 607 struct proc *p; 608 void *v; 609 register_t *retval; 610 { 611 struct compat_sparc32_close_args /* { 612 syscallarg(int) fd; 613 } */ *uap = v; 614 struct sys_close_args ua; 615 616 SPARC32TO64_UAP(fd); 617 return sys_write(p, &ua, retval); 618 } 619 620 int 621 compat_sparc32_open(p, v, retval) 622 struct proc *p; 623 void *v; 624 register_t *retval; 625 { 626 struct compat_sparc32_open_args /* { 627 syscallarg(const sparc32_charp) path; 628 syscallarg(int) flags; 629 syscallarg(mode_t) mode; 630 } */ *uap = v; 631 struct sys_open_args ua; 632 caddr_t sg; 633 634 SPARC32TOP_UAP(path, const char); 635 SPARC32TO64_UAP(flags); 636 SPARC32TO64_UAP(mode); 637 sg = stackgap_init(p->p_emul); 638 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 639 640 return (sys_open(p, &ua, retval)); 641 } 642 643 int 644 compat_sparc32_wait4(q, v, retval) 645 struct proc *q; 646 void *v; 647 register_t *retval; 648 { 649 struct compat_sparc32_wait4_args /* { 650 syscallarg(int) pid; 651 syscallarg(sparc32_intp) status; 652 syscallarg(int) options; 653 syscallarg(sparc32_rusagep_t) rusage; 654 } */ *uap = v; 655 struct sparc32_rusage ru32; 656 register int nfound; 657 register struct proc *p, *t; 658 int status, error; 659 660 if (SCARG(uap, pid) == 0) 661 SCARG(uap, pid) = -q->p_pgid; 662 if (SCARG(uap, options) &~ (WUNTRACED|WNOHANG)) 663 return (EINVAL); 664 665 loop: 666 nfound = 0; 667 for (p = q->p_children.lh_first; p != 0; p = p->p_sibling.le_next) { 668 if (SCARG(uap, pid) != WAIT_ANY && 669 p->p_pid != SCARG(uap, pid) && 670 p->p_pgid != -SCARG(uap, pid)) 671 continue; 672 nfound++; 673 if (p->p_stat == SZOMB) { 674 retval[0] = p->p_pid; 675 676 if (SCARG(uap, status)) { 677 status = p->p_xstat; /* convert to int */ 678 error = copyout((caddr_t)&status, 679 (caddr_t)(u_long)SCARG(uap, status), 680 sizeof(status)); 681 if (error) 682 return (error); 683 } 684 if (SCARG(uap, rusage)) { 685 sparc32_from_rusage(p->p_ru, &ru32); 686 if ((error = copyout((caddr_t)&ru32, 687 (caddr_t)(u_long)SCARG(uap, rusage), 688 sizeof(struct sparc32_rusage)))) 689 return (error); 690 } 691 /* 692 * If we got the child via ptrace(2) or procfs, and 693 * the parent is different (meaning the process was 694 * attached, rather than run as a child), then we need 695 * to give it back to the old parent, and send the 696 * parent a SIGCHLD. The rest of the cleanup will be 697 * done when the old parent waits on the child. 698 */ 699 if ((p->p_flag & P_TRACED) && 700 p->p_oppid != p->p_pptr->p_pid) { 701 t = pfind(p->p_oppid); 702 proc_reparent(p, t ? t : initproc); 703 p->p_oppid = 0; 704 p->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE); 705 psignal(p->p_pptr, SIGCHLD); 706 wakeup((caddr_t)p->p_pptr); 707 return (0); 708 } 709 p->p_xstat = 0; 710 ruadd(&q->p_stats->p_cru, p->p_ru); 711 pool_put(&rusage_pool, p->p_ru); 712 713 /* 714 * Finally finished with old proc entry. 715 * Unlink it from its process group and free it. 716 */ 717 leavepgrp(p); 718 719 LIST_REMOVE(p, p_list); /* off zombproc */ 720 721 LIST_REMOVE(p, p_sibling); 722 723 /* 724 * Decrement the count of procs running with this uid. 725 */ 726 (void)chgproccnt(p->p_cred->p_ruid, -1); 727 728 /* 729 * Free up credentials. 730 */ 731 if (--p->p_cred->p_refcnt == 0) { 732 crfree(p->p_cred->pc_ucred); 733 pool_put(&pcred_pool, p->p_cred); 734 } 735 736 /* 737 * Release reference to text vnode 738 */ 739 if (p->p_textvp) 740 vrele(p->p_textvp); 741 742 /* 743 * Give machine-dependent layer a chance 744 * to free anything that cpu_exit couldn't 745 * release while still running in process context. 746 */ 747 cpu_wait(p); 748 pool_put(&proc_pool, p); 749 nprocs--; 750 return (0); 751 } 752 if (p->p_stat == SSTOP && (p->p_flag & P_WAITED) == 0 && 753 (p->p_flag & P_TRACED || SCARG(uap, options) & WUNTRACED)) { 754 p->p_flag |= P_WAITED; 755 retval[0] = p->p_pid; 756 757 if (SCARG(uap, status)) { 758 status = W_STOPCODE(p->p_xstat); 759 error = copyout((caddr_t)&status, 760 (caddr_t)(u_long)SCARG(uap, status), 761 sizeof(status)); 762 } else 763 error = 0; 764 return (error); 765 } 766 } 767 if (nfound == 0) 768 return (ECHILD); 769 if (SCARG(uap, options) & WNOHANG) { 770 retval[0] = 0; 771 return (0); 772 } 773 if ((error = tsleep((caddr_t)q, PWAIT | PCATCH, "wait", 0)) != 0) 774 return (error); 775 goto loop; 776 } 777 778 int 779 compat_sparc32_link(p, v, retval) 780 struct proc *p; 781 void *v; 782 register_t *retval; 783 { 784 struct compat_sparc32_link_args /* { 785 syscallarg(const sparc32_charp) path; 786 syscallarg(const sparc32_charp) link; 787 } */ *uap = v; 788 struct sys_link_args ua; 789 790 SPARC32TOP_UAP(path, const char); 791 SPARC32TOP_UAP(link, const char); 792 return (sys_link(p, &ua, retval)); 793 } 794 795 int 796 compat_sparc32_unlink(p, v, retval) 797 struct proc *p; 798 void *v; 799 register_t *retval; 800 { 801 struct compat_sparc32_unlink_args /* { 802 syscallarg(const sparc32_charp) path; 803 } */ *uap = v; 804 struct sys_unlink_args ua; 805 806 SPARC32TOP_UAP(path, const char); 807 808 return (sys_unlink(p, &ua, retval)); 809 } 810 811 int 812 compat_sparc32_chdir(p, v, retval) 813 struct proc *p; 814 void *v; 815 register_t *retval; 816 { 817 struct compat_sparc32_chdir_args /* { 818 syscallarg(const sparc32_charp) path; 819 } */ *uap = v; 820 struct sys_chdir_args ua; 821 822 SPARC32TOP_UAP(path, const char); 823 824 return (sys_chdir(p, &ua, retval)); 825 } 826 827 int 828 compat_sparc32_fchdir(p, v, retval) 829 struct proc *p; 830 void *v; 831 register_t *retval; 832 { 833 struct compat_sparc32_fchdir_args /* { 834 syscallarg(int) fd; 835 } */ *uap = v; 836 struct sys_fchdir_args ua; 837 838 SPARC32TO64_UAP(fd); 839 840 return (sys_fchdir(p, &ua, retval)); 841 } 842 843 int 844 compat_sparc32_mknod(p, v, retval) 845 struct proc *p; 846 void *v; 847 register_t *retval; 848 { 849 struct compat_sparc32_mknod_args /* { 850 syscallarg(const sparc32_charp) path; 851 syscallarg(mode_t) mode; 852 syscallarg(dev_t) dev; 853 } */ *uap = v; 854 struct sys_mknod_args ua; 855 856 SPARC32TOP_UAP(path, const char); 857 SPARC32TO64_UAP(dev); 858 SPARC32TO64_UAP(mode); 859 860 return (sys_mknod(p, &ua, retval)); 861 } 862 863 int 864 compat_sparc32_chmod(p, v, retval) 865 struct proc *p; 866 void *v; 867 register_t *retval; 868 { 869 struct compat_sparc32_chmod_args /* { 870 syscallarg(const sparc32_charp) path; 871 syscallarg(mode_t) mode; 872 } */ *uap = v; 873 struct sys_chmod_args ua; 874 875 SPARC32TOP_UAP(path, const char); 876 SPARC32TO64_UAP(mode); 877 878 return (sys_chmod(p, &ua, retval)); 879 } 880 881 int 882 compat_sparc32_chown(p, v, retval) 883 struct proc *p; 884 void *v; 885 register_t *retval; 886 { 887 struct compat_sparc32_chown_args /* { 888 syscallarg(const sparc32_charp) path; 889 syscallarg(uid_t) uid; 890 syscallarg(gid_t) gid; 891 } */ *uap = v; 892 struct sys_chown_args ua; 893 894 SPARC32TOP_UAP(path, const char); 895 SPARC32TO64_UAP(uid); 896 SPARC32TO64_UAP(gid); 897 898 return (sys_chown(p, &ua, retval)); 899 } 900 901 int 902 compat_sparc32_break(p, v, retval) 903 struct proc *p; 904 void *v; 905 register_t *retval; 906 { 907 struct compat_sparc32_break_args /* { 908 syscallarg(sparc32_charp) nsize; 909 } */ *uap = v; 910 struct sys_obreak_args ua; 911 912 SCARG(&ua, nsize) = (char *)(u_long)SCARG(uap, nsize); 913 SPARC32TOP_UAP(nsize, char); 914 return (sys_obreak(p, &ua, retval)); 915 } 916 917 int 918 compat_sparc32_getfsstat(p, v, retval) 919 struct proc *p; 920 void *v; 921 register_t *retval; 922 { 923 struct compat_sparc32_getfsstat_args /* { 924 syscallarg(sparc32_statfsp_t) buf; 925 syscallarg(sparc32_long) bufsize; 926 syscallarg(int) flags; 927 } */ *uap = v; 928 struct sys_getfsstat_args ua; 929 struct statfs sb; 930 struct sparc32_statfs *sb32p; 931 int error; 932 933 sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf); 934 if (sb32p) 935 SCARG(&ua, buf) = &sb; 936 else 937 SCARG(&ua, buf) = NULL; 938 SPARC32TOX_UAP(bufsize, long); 939 SPARC32TO64_UAP(flags); 940 error = sys_getfsstat(p, &ua, retval); 941 if (error) 942 return (error); 943 944 if (sb32p) { 945 struct sparc32_statfs sb32; 946 sparc32_from_statfs(&sb, &sb32); 947 if (copyout(&sb32, sb32p, sizeof(sb32))) 948 return EFAULT; 949 } 950 return (0); 951 } 952 953 int 954 compat_sparc32_mount(p, v, retval) 955 struct proc *p; 956 void *v; 957 register_t *retval; 958 { 959 struct compat_sparc32_mount_args /* { 960 syscallarg(const sparc32_charp) type; 961 syscallarg(const sparc32_charp) path; 962 syscallarg(int) flags; 963 syscallarg(sparc32_voidp) data; 964 } */ *uap = v; 965 struct sys_mount_args ua; 966 967 SPARC32TOP_UAP(type, const char); 968 SPARC32TOP_UAP(path, const char); 969 SPARC32TO64_UAP(flags); 970 SPARC32TOP_UAP(data, void); 971 return (sys_mount(p, &ua, retval)); 972 } 973 974 int 975 compat_sparc32_unmount(p, v, retval) 976 struct proc *p; 977 void *v; 978 register_t *retval; 979 { 980 struct compat_sparc32_unmount_args /* { 981 syscallarg(const sparc32_charp) path; 982 syscallarg(int) flags; 983 } */ *uap = v; 984 struct sys_unmount_args ua; 985 986 SPARC32TOP_UAP(path, const char); 987 SPARC32TO64_UAP(flags); 988 return (sys_unmount(p, &ua, retval)); 989 } 990 991 int 992 compat_sparc32_setuid(p, v, retval) 993 struct proc *p; 994 void *v; 995 register_t *retval; 996 { 997 struct compat_sparc32_setuid_args /* { 998 syscallarg(uid_t) uid; 999 } */ *uap = v; 1000 struct sys_setuid_args ua; 1001 1002 SPARC32TO64_UAP(uid); 1003 return (sys_setuid(p, &ua, retval)); 1004 } 1005 1006 int 1007 compat_sparc32_ptrace(p, v, retval) 1008 struct proc *p; 1009 void *v; 1010 register_t *retval; 1011 { 1012 struct compat_sparc32_ptrace_args /* { 1013 syscallarg(int) req; 1014 syscallarg(pid_t) pid; 1015 syscallarg(sparc32_caddr_t) addr; 1016 syscallarg(int) data; 1017 } */ *uap = v; 1018 struct sys_ptrace_args ua; 1019 1020 SPARC32TO64_UAP(req); 1021 SPARC32TO64_UAP(pid); 1022 SPARC32TOX64_UAP(addr, caddr_t); 1023 SPARC32TO64_UAP(data); 1024 return (sys_ptrace(p, &ua, retval)); 1025 } 1026 1027 int 1028 compat_sparc32_recvmsg(p, v, retval) 1029 struct proc *p; 1030 void *v; 1031 register_t *retval; 1032 { 1033 struct compat_sparc32_recvmsg_args /* { 1034 syscallarg(int) s; 1035 syscallarg(sparc32_msghdrp_t) msg; 1036 syscallarg(int) flags; 1037 } */ *uap = v; 1038 struct sparc32_msghdr msg; 1039 struct iovec aiov[UIO_SMALLIOV], *uiov, *iov; 1040 register int error; 1041 1042 error = copyin((caddr_t)(u_long)SCARG(uap, msg), (caddr_t)&msg, 1043 sizeof(msg)); 1044 /* sparc32_msghdr needs the iov pre-allocated */ 1045 if (error) 1046 return (error); 1047 if ((u_int)msg.msg_iovlen > UIO_SMALLIOV) { 1048 if ((u_int)msg.msg_iovlen > IOV_MAX) 1049 return (EMSGSIZE); 1050 MALLOC(iov, struct iovec *, 1051 sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV, 1052 M_WAITOK); 1053 } else if ((u_int)msg.msg_iovlen > 0) 1054 iov = aiov; 1055 else 1056 return (EMSGSIZE); 1057 #ifdef COMPAT_OLDSOCK 1058 msg.msg_flags = SCARG(uap, flags) &~ MSG_COMPAT; 1059 #else 1060 msg.msg_flags = SCARG(uap, flags); 1061 #endif 1062 uiov = (struct iovec *)(u_long)msg.msg_iov; 1063 error = sparc32_to_iovecin((struct sparc32_iovec *)uiov, 1064 iov, msg.msg_iovlen); 1065 if (error) 1066 goto done; 1067 if ((error = recvit32(p, SCARG(uap, s), &msg, iov, (caddr_t)0, retval)) == 0) { 1068 error = copyout((caddr_t)&msg, (caddr_t)(u_long)SCARG(uap, msg), 1069 sizeof(msg)); 1070 } 1071 done: 1072 if (iov != aiov) 1073 FREE(iov, M_IOV); 1074 return (error); 1075 } 1076 1077 int 1078 recvit32(p, s, mp, iov, namelenp, retsize) 1079 struct proc *p; 1080 int s; 1081 struct sparc32_msghdr *mp; 1082 struct iovec *iov; 1083 caddr_t namelenp; 1084 register_t *retsize; 1085 { 1086 struct file *fp; 1087 struct uio auio; 1088 register int i; 1089 int len, error; 1090 struct mbuf *from = 0, *control = 0; 1091 struct socket *so; 1092 #ifdef KTRACE 1093 struct iovec *ktriov = NULL; 1094 #endif 1095 1096 if ((error = getsock(p->p_fd, s, &fp)) != 0) 1097 return (error); 1098 auio.uio_iov = (struct iovec *)(u_long)mp->msg_iov; 1099 auio.uio_iovcnt = mp->msg_iovlen; 1100 auio.uio_segflg = UIO_USERSPACE; 1101 auio.uio_rw = UIO_READ; 1102 auio.uio_procp = p; 1103 auio.uio_offset = 0; /* XXX */ 1104 auio.uio_resid = 0; 1105 for (i = 0; i < mp->msg_iovlen; i++, iov++) { 1106 #if 0 1107 /* cannot happen iov_len is unsigned */ 1108 if (iov->iov_len < 0) 1109 return (EINVAL); 1110 #endif 1111 /* 1112 * Reads return ssize_t because -1 is returned on error. 1113 * Therefore we must restrict the length to SSIZE_MAX to 1114 * avoid garbage return values. 1115 */ 1116 auio.uio_resid += iov->iov_len; 1117 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) 1118 return (EINVAL); 1119 } 1120 #ifdef KTRACE 1121 if (KTRPOINT(p, KTR_GENIO)) { 1122 int iovlen = auio.uio_iovcnt * sizeof(struct iovec); 1123 1124 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 1125 memcpy((caddr_t)ktriov, (caddr_t)auio.uio_iov, iovlen); 1126 } 1127 #endif 1128 len = auio.uio_resid; 1129 so = (struct socket *)fp->f_data; 1130 error = (*so->so_receive)(so, &from, &auio, NULL, 1131 mp->msg_control ? &control : NULL, &mp->msg_flags); 1132 if (error) { 1133 if (auio.uio_resid != len && (error == ERESTART || 1134 error == EINTR || error == EWOULDBLOCK)) 1135 error = 0; 1136 } 1137 #ifdef KTRACE 1138 if (ktriov != NULL) { 1139 if (error == 0) 1140 ktrgenio(p->p_tracep, s, UIO_READ, 1141 ktriov, len - auio.uio_resid, error); 1142 FREE(ktriov, M_TEMP); 1143 } 1144 #endif 1145 if (error) 1146 goto out; 1147 *retsize = len - auio.uio_resid; 1148 if (mp->msg_name) { 1149 len = mp->msg_namelen; 1150 if (len <= 0 || from == 0) 1151 len = 0; 1152 else { 1153 #ifdef COMPAT_OLDSOCK 1154 if (mp->msg_flags & MSG_COMPAT) 1155 mtod(from, struct osockaddr *)->sa_family = 1156 mtod(from, struct sockaddr *)->sa_family; 1157 #endif 1158 if (len > from->m_len) 1159 len = from->m_len; 1160 /* else if len < from->m_len ??? */ 1161 error = copyout(mtod(from, caddr_t), 1162 (caddr_t)(u_long)mp->msg_name, (unsigned)len); 1163 if (error) 1164 goto out; 1165 } 1166 mp->msg_namelen = len; 1167 if (namelenp && 1168 (error = copyout((caddr_t)&len, namelenp, sizeof(int)))) { 1169 #ifdef COMPAT_OLDSOCK 1170 if (mp->msg_flags & MSG_COMPAT) 1171 error = 0; /* old recvfrom didn't check */ 1172 else 1173 #endif 1174 goto out; 1175 } 1176 } 1177 if (mp->msg_control) { 1178 #ifdef COMPAT_OLDSOCK 1179 /* 1180 * We assume that old recvmsg calls won't receive access 1181 * rights and other control info, esp. as control info 1182 * is always optional and those options didn't exist in 4.3. 1183 * If we receive rights, trim the cmsghdr; anything else 1184 * is tossed. 1185 */ 1186 if (control && mp->msg_flags & MSG_COMPAT) { 1187 if (mtod(control, struct cmsghdr *)->cmsg_level != 1188 SOL_SOCKET || 1189 mtod(control, struct cmsghdr *)->cmsg_type != 1190 SCM_RIGHTS) { 1191 mp->msg_controllen = 0; 1192 goto out; 1193 } 1194 control->m_len -= sizeof(struct cmsghdr); 1195 control->m_data += sizeof(struct cmsghdr); 1196 } 1197 #endif 1198 len = mp->msg_controllen; 1199 if (len <= 0 || control == 0) 1200 len = 0; 1201 else { 1202 struct mbuf *m = control; 1203 caddr_t p = (caddr_t)(u_long)mp->msg_control; 1204 1205 do { 1206 i = m->m_len; 1207 if (len < i) { 1208 mp->msg_flags |= MSG_CTRUNC; 1209 i = len; 1210 } 1211 error = copyout(mtod(m, caddr_t), p, 1212 (unsigned)i); 1213 if (m->m_next) 1214 i = ALIGN(i); 1215 p += i; 1216 len -= i; 1217 if (error != 0 || len <= 0) 1218 break; 1219 } while ((m = m->m_next) != NULL); 1220 len = p - (caddr_t)(u_long)mp->msg_control; 1221 } 1222 mp->msg_controllen = len; 1223 } 1224 out: 1225 if (from) 1226 m_freem(from); 1227 if (control) 1228 m_freem(control); 1229 return (error); 1230 } 1231 1232 1233 int 1234 compat_sparc32_sendmsg(p, v, retval) 1235 struct proc *p; 1236 void *v; 1237 register_t *retval; 1238 { 1239 struct compat_sparc32_sendmsg_args /* { 1240 syscallarg(int) s; 1241 syscallarg(const sparc32_msghdrp_t) msg; 1242 syscallarg(int) flags; 1243 } */ *uap = v; 1244 struct msghdr msg; 1245 struct sparc32_msghdr msg32; 1246 struct iovec aiov[UIO_SMALLIOV], *iov; 1247 int error; 1248 1249 error = copyin((caddr_t)(u_long)SCARG(uap, msg), 1250 (caddr_t)&msg32, sizeof(msg32)); 1251 if (error) 1252 return (error); 1253 sparc32_to_msghdr(&msg32, &msg); 1254 if ((u_int)msg.msg_iovlen > UIO_SMALLIOV) { 1255 if ((u_int)msg.msg_iovlen > IOV_MAX) 1256 return (EMSGSIZE); 1257 MALLOC(iov, struct iovec *, 1258 sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV, 1259 M_WAITOK); 1260 } else if ((u_int)msg.msg_iovlen > 0) 1261 iov = aiov; 1262 else 1263 return (EMSGSIZE); 1264 error = sparc32_to_iovecin((struct sparc32_iovec *)msg.msg_iov, 1265 iov, msg.msg_iovlen); 1266 if (error) 1267 goto done; 1268 msg.msg_iov = iov; 1269 #ifdef COMPAT_OLDSOCK 1270 msg.msg_flags = 0; 1271 #endif 1272 /* Luckily we can use this directly */ 1273 error = sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval); 1274 done: 1275 if (iov != aiov) 1276 FREE(iov, M_IOV); 1277 return (error); 1278 } 1279 1280 int 1281 compat_sparc32_recvfrom(p, v, retval) 1282 struct proc *p; 1283 void *v; 1284 register_t *retval; 1285 { 1286 struct compat_sparc32_recvfrom_args /* { 1287 syscallarg(int) s; 1288 syscallarg(sparc32_voidp) buf; 1289 syscallarg(sparc32_size_t) len; 1290 syscallarg(int) flags; 1291 syscallarg(sparc32_sockaddrp_t) from; 1292 syscallarg(sparc32_intp) fromlenaddr; 1293 } */ *uap = v; 1294 struct sparc32_msghdr msg; 1295 struct iovec aiov; 1296 int error; 1297 1298 if (SCARG(uap, fromlenaddr)) { 1299 error = copyin((caddr_t)(u_long)SCARG(uap, fromlenaddr), 1300 (caddr_t)&msg.msg_namelen, 1301 sizeof(msg.msg_namelen)); 1302 if (error) 1303 return (error); 1304 } else 1305 msg.msg_namelen = 0; 1306 msg.msg_name = SCARG(uap, from); 1307 msg.msg_iov = NULL; /* We can't store a real pointer here */ 1308 msg.msg_iovlen = 1; 1309 aiov.iov_base = (caddr_t)(u_long)SCARG(uap, buf); 1310 aiov.iov_len = (u_long)SCARG(uap, len); 1311 msg.msg_control = 0; 1312 msg.msg_flags = SCARG(uap, flags); 1313 return (recvit32(p, SCARG(uap, s), &msg, &aiov, 1314 (caddr_t)(u_long)SCARG(uap, fromlenaddr), retval)); 1315 } 1316 1317 int 1318 compat_sparc32_sendto(p, v, retval) 1319 struct proc *p; 1320 void *v; 1321 register_t *retval; 1322 { 1323 struct compat_sparc32_sendto_args /* { 1324 syscallarg(int) s; 1325 syscallarg(const sparc32_voidp) buf; 1326 syscallarg(sparc32_size_t) len; 1327 syscallarg(int) flags; 1328 syscallarg(const sparc32_sockaddrp_t) to; 1329 syscallarg(int) tolen; 1330 } */ *uap = v; 1331 struct msghdr msg; 1332 struct iovec aiov; 1333 1334 msg.msg_name = (caddr_t)(u_long)SCARG(uap, to); /* XXX kills const */ 1335 msg.msg_namelen = SCARG(uap, tolen); 1336 msg.msg_iov = &aiov; 1337 msg.msg_iovlen = 1; 1338 msg.msg_control = 0; 1339 #ifdef COMPAT_OLDSOCK 1340 msg.msg_flags = 0; 1341 #endif 1342 aiov.iov_base = (char *)(u_long)SCARG(uap, buf); /* XXX kills const */ 1343 aiov.iov_len = SCARG(uap, len); 1344 return (sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval)); 1345 } 1346 1347 int 1348 compat_sparc32_accept(p, v, retval) 1349 struct proc *p; 1350 void *v; 1351 register_t *retval; 1352 { 1353 struct compat_sparc32_accept_args /* { 1354 syscallarg(int) s; 1355 syscallarg(sparc32_sockaddrp_t) name; 1356 syscallarg(sparc32_intp) anamelen; 1357 } */ *uap = v; 1358 struct sys_accept_args ua; 1359 1360 SPARC32TO64_UAP(s); 1361 SPARC32TOP_UAP(name, struct sockaddr); 1362 SPARC32TOP_UAP(anamelen, int); 1363 return (sys_accept(p, &ua, retval)); 1364 } 1365 1366 int 1367 compat_sparc32_getpeername(p, v, retval) 1368 struct proc *p; 1369 void *v; 1370 register_t *retval; 1371 { 1372 struct compat_sparc32_getpeername_args /* { 1373 syscallarg(int) fdes; 1374 syscallarg(sparc32_sockaddrp_t) asa; 1375 syscallarg(sparc32_intp) alen; 1376 } */ *uap = v; 1377 struct sys_getpeername_args ua; 1378 1379 SPARC32TO64_UAP(fdes); 1380 SPARC32TOP_UAP(asa, struct sockaddr); 1381 SPARC32TOP_UAP(alen, int); 1382 /* NB: do the protocol specific sockaddrs need to be converted? */ 1383 return (sys_getpeername(p, &ua, retval)); 1384 } 1385 1386 int 1387 compat_sparc32_getsockname(p, v, retval) 1388 struct proc *p; 1389 void *v; 1390 register_t *retval; 1391 { 1392 struct compat_sparc32_getsockname_args /* { 1393 syscallarg(int) fdes; 1394 syscallarg(sparc32_sockaddrp_t) asa; 1395 syscallarg(sparc32_intp) alen; 1396 } */ *uap = v; 1397 struct sys_getsockname_args ua; 1398 1399 SPARC32TO64_UAP(fdes); 1400 SPARC32TOP_UAP(asa, struct sockaddr); 1401 SPARC32TOP_UAP(alen, int); 1402 return (sys_getsockname(p, &ua, retval)); 1403 } 1404 1405 int 1406 compat_sparc32_access(p, v, retval) 1407 struct proc *p; 1408 void *v; 1409 register_t *retval; 1410 { 1411 struct compat_sparc32_access_args /* { 1412 syscallarg(const sparc32_charp) path; 1413 syscallarg(int) flags; 1414 } */ *uap = v; 1415 struct sys_access_args ua; 1416 caddr_t sg; 1417 1418 SPARC32TOP_UAP(path, const char); 1419 SPARC32TO64_UAP(flags); 1420 sg = stackgap_init(p->p_emul); 1421 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 1422 1423 return (sys_access(p, &ua, retval)); 1424 } 1425 1426 int 1427 compat_sparc32_chflags(p, v, retval) 1428 struct proc *p; 1429 void *v; 1430 register_t *retval; 1431 { 1432 struct compat_sparc32_chflags_args /* { 1433 syscallarg(const sparc32_charp) path; 1434 syscallarg(sparc32_u_long) flags; 1435 } */ *uap = v; 1436 struct sys_chflags_args ua; 1437 1438 SPARC32TOP_UAP(path, const char); 1439 SPARC32TO64_UAP(flags); 1440 1441 return (sys_chflags(p, &ua, retval)); 1442 } 1443 1444 int 1445 compat_sparc32_fchflags(p, v, retval) 1446 struct proc *p; 1447 void *v; 1448 register_t *retval; 1449 { 1450 struct compat_sparc32_fchflags_args /* { 1451 syscallarg(int) fd; 1452 syscallarg(sparc32_u_long) flags; 1453 } */ *uap = v; 1454 struct sys_fchflags_args ua; 1455 1456 SPARC32TO64_UAP(fd); 1457 SPARC32TO64_UAP(flags); 1458 1459 return (sys_fchflags(p, &ua, retval)); 1460 } 1461 1462 int 1463 compat_sparc32_kill(p, v, retval) 1464 struct proc *p; 1465 void *v; 1466 register_t *retval; 1467 { 1468 struct compat_sparc32_kill_args /* { 1469 syscallarg(int) pid; 1470 syscallarg(int) signum; 1471 } */ *uap = v; 1472 struct sys_kill_args ua; 1473 1474 SPARC32TO64_UAP(pid); 1475 SPARC32TO64_UAP(signum); 1476 1477 return (sys_kill(p, &ua, retval)); 1478 } 1479 1480 int 1481 compat_sparc32_dup(p, v, retval) 1482 struct proc *p; 1483 void *v; 1484 register_t *retval; 1485 { 1486 struct compat_sparc32_dup_args /* { 1487 syscallarg(int) fd; 1488 } */ *uap = v; 1489 struct sys_dup_args ua; 1490 1491 SPARC32TO64_UAP(fd); 1492 1493 return (sys_dup(p, &ua, retval)); 1494 } 1495 1496 int 1497 compat_sparc32_profil(p, v, retval) 1498 struct proc *p; 1499 void *v; 1500 register_t *retval; 1501 { 1502 struct compat_sparc32_profil_args /* { 1503 syscallarg(sparc32_caddr_t) samples; 1504 syscallarg(sparc32_size_t) size; 1505 syscallarg(sparc32_u_long) offset; 1506 syscallarg(u_int) scale; 1507 } */ *uap = v; 1508 struct sys_profil_args ua; 1509 1510 SPARC32TOX64_UAP(samples, caddr_t); 1511 SPARC32TOX_UAP(size, size_t); 1512 SPARC32TOX_UAP(offset, u_long); 1513 SPARC32TO64_UAP(scale); 1514 return (sys_profil(p, &ua, retval)); 1515 } 1516 1517 int 1518 compat_sparc32_ktrace(p, v, retval) 1519 struct proc *p; 1520 void *v; 1521 register_t *retval; 1522 { 1523 struct compat_sparc32_ktrace_args /* { 1524 syscallarg(const sparc32_charp) fname; 1525 syscallarg(int) ops; 1526 syscallarg(int) facs; 1527 syscallarg(int) pid; 1528 } */ *uap = v; 1529 struct sys_ktrace_args ua; 1530 1531 SPARC32TOP_UAP(fname, const char); 1532 SPARC32TO64_UAP(ops); 1533 SPARC32TO64_UAP(facs); 1534 SPARC32TO64_UAP(pid); 1535 return (sys_ktrace(p, &ua, retval)); 1536 } 1537 1538 int 1539 compat_sparc32_sigaction(p, v, retval) 1540 struct proc *p; 1541 void *v; 1542 register_t *retval; 1543 { 1544 struct compat_sparc32_sigaction_args /* { 1545 syscallarg(int) signum; 1546 syscallarg(const sparc32_sigactionp_t) nsa; 1547 syscallarg(sparc32_sigactionp_t) osa; 1548 } */ *uap = v; 1549 struct sigaction nsa, osa; 1550 struct sparc32_sigaction *sa32p, sa32; 1551 int error; 1552 1553 if (SCARG(uap, nsa)) { 1554 sa32p = (struct sparc32_sigaction *)(u_long)SCARG(uap, nsa); 1555 if (copyin(sa32p, &sa32, sizeof(sa32))) 1556 return EFAULT; 1557 nsa.sa_handler = (void *)(u_long)sa32.sa_handler; 1558 nsa.sa_mask = sa32.sa_mask; 1559 nsa.sa_flags = sa32.sa_flags; 1560 } 1561 error = sigaction1(p, SCARG(uap, signum), 1562 SCARG(uap, nsa) ? &nsa : 0, 1563 SCARG(uap, osa) ? &osa : 0); 1564 1565 if (error) 1566 return (error); 1567 1568 if (SCARG(uap, osa)) { 1569 sa32.sa_handler = (sparc32_sigactionp_t)(u_long)osa.sa_handler; 1570 sa32.sa_mask = osa.sa_mask; 1571 sa32.sa_flags = osa.sa_flags; 1572 sa32p = (struct sparc32_sigaction *)(u_long)SCARG(uap, osa); 1573 if (copyout(&sa32, sa32p, sizeof(sa32))) 1574 return EFAULT; 1575 } 1576 1577 return (0); 1578 } 1579 1580 int 1581 compat_sparc32___getlogin(p, v, retval) 1582 struct proc *p; 1583 void *v; 1584 register_t *retval; 1585 { 1586 struct compat_sparc32___getlogin_args /* { 1587 syscallarg(sparc32_charp) namebuf; 1588 syscallarg(u_int) namelen; 1589 } */ *uap = v; 1590 struct sys___getlogin_args ua; 1591 1592 SPARC32TOP_UAP(namebuf, char); 1593 SPARC32TO64_UAP(namelen); 1594 return (sys___getlogin(p, &ua, retval)); 1595 } 1596 1597 int 1598 compat_sparc32_setlogin(p, v, retval) 1599 struct proc *p; 1600 void *v; 1601 register_t *retval; 1602 { 1603 struct compat_sparc32_setlogin_args /* { 1604 syscallarg(const sparc32_charp) namebuf; 1605 } */ *uap = v; 1606 struct sys_setlogin_args ua; 1607 1608 SPARC32TOP_UAP(namebuf, char); 1609 return (sys_setlogin(p, &ua, retval)); 1610 } 1611 1612 int 1613 compat_sparc32_acct(p, v, retval) 1614 struct proc *p; 1615 void *v; 1616 register_t *retval; 1617 { 1618 struct compat_sparc32_acct_args /* { 1619 syscallarg(const sparc32_charp) path; 1620 } */ *uap = v; 1621 struct sys_acct_args ua; 1622 1623 SPARC32TOP_UAP(path, const char); 1624 return (sys_acct(p, &ua, retval)); 1625 } 1626 1627 int 1628 compat_sparc32_revoke(p, v, retval) 1629 struct proc *p; 1630 void *v; 1631 register_t *retval; 1632 { 1633 struct compat_sparc32_revoke_args /* { 1634 syscallarg(const sparc32_charp) path; 1635 } */ *uap = v; 1636 struct sys_revoke_args ua; 1637 caddr_t sg; 1638 1639 SPARC32TOP_UAP(path, const char); 1640 sg = stackgap_init(p->p_emul); 1641 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 1642 1643 return (sys_revoke(p, &ua, retval)); 1644 } 1645 1646 int 1647 compat_sparc32_symlink(p, v, retval) 1648 struct proc *p; 1649 void *v; 1650 register_t *retval; 1651 { 1652 struct compat_sparc32_symlink_args /* { 1653 syscallarg(const sparc32_charp) path; 1654 syscallarg(const sparc32_charp) link; 1655 } */ *uap = v; 1656 struct sys_symlink_args ua; 1657 1658 SPARC32TOP_UAP(path, const char); 1659 SPARC32TOP_UAP(link, const char); 1660 1661 return (sys_symlink(p, &ua, retval)); 1662 } 1663 1664 int 1665 compat_sparc32_readlink(p, v, retval) 1666 struct proc *p; 1667 void *v; 1668 register_t *retval; 1669 { 1670 struct compat_sparc32_readlink_args /* { 1671 syscallarg(const sparc32_charp) path; 1672 syscallarg(sparc32_charp) buf; 1673 syscallarg(sparc32_size_t) count; 1674 } */ *uap = v; 1675 struct sys_readlink_args ua; 1676 caddr_t sg; 1677 1678 SPARC32TOP_UAP(path, const char); 1679 SPARC32TOP_UAP(buf, char); 1680 SPARC32TOX_UAP(count, size_t); 1681 sg = stackgap_init(p->p_emul); 1682 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 1683 1684 return (sys_readlink(p, &ua, retval)); 1685 } 1686 1687 int 1688 compat_sparc32_execve(p, v, retval) 1689 struct proc *p; 1690 void *v; 1691 register_t *retval; 1692 { 1693 struct compat_sparc32_execve_args /* { 1694 syscallarg(const sparc32_charp) path; 1695 syscallarg(sparc32_charpp) argp; 1696 syscallarg(sparc32_charpp) envp; 1697 } */ *uap = v; 1698 struct sys_execve_args ua; 1699 caddr_t sg; 1700 1701 SPARC32TOP_UAP(path, const char); 1702 SPARC32TOP_UAP(argp, char *); 1703 SPARC32TOP_UAP(envp, char *); 1704 sg = stackgap_init(p->p_emul); 1705 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 1706 1707 return (sys_execve(p, &ua, retval)); 1708 } 1709 1710 int 1711 compat_sparc32_umask(p, v, retval) 1712 struct proc *p; 1713 void *v; 1714 register_t *retval; 1715 { 1716 struct compat_sparc32_umask_args /* { 1717 syscallarg(mode_t) newmask; 1718 } */ *uap = v; 1719 struct sys_umask_args ua; 1720 1721 SPARC32TO64_UAP(newmask); 1722 return (sys_umask(p, &ua, retval)); 1723 } 1724 1725 int 1726 compat_sparc32_chroot(p, v, retval) 1727 struct proc *p; 1728 void *v; 1729 register_t *retval; 1730 { 1731 struct compat_sparc32_chroot_args /* { 1732 syscallarg(const sparc32_charp) path; 1733 } */ *uap = v; 1734 struct sys_chroot_args ua; 1735 1736 SPARC32TOP_UAP(path, const char); 1737 return (sys_chroot(p, &ua, retval)); 1738 } 1739 1740 int 1741 compat_sparc32_sbrk(p, v, retval) 1742 struct proc *p; 1743 void *v; 1744 register_t *retval; 1745 { 1746 struct compat_sparc32_sbrk_args /* { 1747 syscallarg(int) incr; 1748 } */ *uap = v; 1749 struct sys_sbrk_args ua; 1750 1751 SPARC32TO64_UAP(incr); 1752 return (sys_sbrk(p, &ua, retval)); 1753 } 1754 1755 int 1756 compat_sparc32_sstk(p, v, retval) 1757 struct proc *p; 1758 void *v; 1759 register_t *retval; 1760 { 1761 struct compat_sparc32_sstk_args /* { 1762 syscallarg(int) incr; 1763 } */ *uap = v; 1764 struct sys_sstk_args ua; 1765 1766 SPARC32TO64_UAP(incr); 1767 return (sys_sstk(p, &ua, retval)); 1768 } 1769 1770 int 1771 compat_sparc32_munmap(p, v, retval) 1772 struct proc *p; 1773 void *v; 1774 register_t *retval; 1775 { 1776 struct compat_sparc32_munmap_args /* { 1777 syscallarg(sparc32_voidp) addr; 1778 syscallarg(sparc32_size_t) len; 1779 } */ *uap = v; 1780 struct sys_munmap_args ua; 1781 1782 SPARC32TOP_UAP(addr, void); 1783 SPARC32TOX_UAP(len, size_t); 1784 return (sys_munmap(p, &ua, retval)); 1785 } 1786 1787 int 1788 compat_sparc32_mprotect(p, v, retval) 1789 struct proc *p; 1790 void *v; 1791 register_t *retval; 1792 { 1793 struct compat_sparc32_mprotect_args /* { 1794 syscallarg(sparc32_voidp) addr; 1795 syscallarg(sparc32_size_t) len; 1796 syscallarg(int) prot; 1797 } */ *uap = v; 1798 struct sys_mprotect_args ua; 1799 1800 SPARC32TOP_UAP(addr, void); 1801 SPARC32TOX_UAP(len, size_t); 1802 SPARC32TO64_UAP(prot); 1803 return (sys_mprotect(p, &ua, retval)); 1804 } 1805 1806 int 1807 compat_sparc32_madvise(p, v, retval) 1808 struct proc *p; 1809 void *v; 1810 register_t *retval; 1811 { 1812 struct compat_sparc32_madvise_args /* { 1813 syscallarg(sparc32_voidp) addr; 1814 syscallarg(sparc32_size_t) len; 1815 syscallarg(int) behav; 1816 } */ *uap = v; 1817 struct sys_madvise_args ua; 1818 1819 SPARC32TOP_UAP(addr, void); 1820 SPARC32TOX_UAP(len, size_t); 1821 SPARC32TO64_UAP(behav); 1822 return (sys_madvise(p, &ua, retval)); 1823 } 1824 1825 int 1826 compat_sparc32_mincore(p, v, retval) 1827 struct proc *p; 1828 void *v; 1829 register_t *retval; 1830 { 1831 struct compat_sparc32_mincore_args /* { 1832 syscallarg(sparc32_caddr_t) addr; 1833 syscallarg(sparc32_size_t) len; 1834 syscallarg(sparc32_charp) vec; 1835 } */ *uap = v; 1836 struct sys_mincore_args ua; 1837 1838 SPARC32TOX64_UAP(addr, caddr_t); 1839 SPARC32TOX_UAP(len, size_t); 1840 SPARC32TOP_UAP(vec, char); 1841 return (sys_mincore(p, &ua, retval)); 1842 } 1843 1844 int 1845 compat_sparc32_getgroups(p, v, retval) 1846 struct proc *p; 1847 void *v; 1848 register_t *retval; 1849 { 1850 struct compat_sparc32_getgroups_args /* { 1851 syscallarg(int) gidsetsize; 1852 syscallarg(sparc32_gid_tp) gidset; 1853 } */ *uap = v; 1854 register struct pcred *pc = p->p_cred; 1855 register int ngrp; 1856 int error; 1857 1858 ngrp = SCARG(uap, gidsetsize); 1859 if (ngrp == 0) { 1860 *retval = pc->pc_ucred->cr_ngroups; 1861 return (0); 1862 } 1863 if (ngrp < pc->pc_ucred->cr_ngroups) 1864 return (EINVAL); 1865 ngrp = pc->pc_ucred->cr_ngroups; 1866 /* Should convert gid_t to sparc32_gid_t, but they're the same */ 1867 error = copyout((caddr_t)pc->pc_ucred->cr_groups, 1868 (caddr_t)(u_long)SCARG(uap, gidset), 1869 ngrp * sizeof(gid_t)); 1870 if (error) 1871 return (error); 1872 *retval = ngrp; 1873 return (0); 1874 } 1875 1876 int 1877 compat_sparc32_setgroups(p, v, retval) 1878 struct proc *p; 1879 void *v; 1880 register_t *retval; 1881 { 1882 struct compat_sparc32_setgroups_args /* { 1883 syscallarg(int) gidsetsize; 1884 syscallarg(const sparc32_gid_tp) gidset; 1885 } */ *uap = v; 1886 struct sys_setgroups_args ua; 1887 1888 SPARC32TO64_UAP(gidsetsize); 1889 SPARC32TOP_UAP(gidset, gid_t); 1890 return (sys_setgroups(p, &ua, retval)); 1891 } 1892 1893 int 1894 compat_sparc32_setpgid(p, v, retval) 1895 struct proc *p; 1896 void *v; 1897 register_t *retval; 1898 { 1899 struct compat_sparc32_setpgid_args /* { 1900 syscallarg(int) pid; 1901 syscallarg(int) pgid; 1902 } */ *uap = v; 1903 struct sys_setpgid_args ua; 1904 1905 SPARC32TO64_UAP(pid); 1906 SPARC32TO64_UAP(pgid); 1907 return (sys_setpgid(p, &ua, retval)); 1908 } 1909 1910 int 1911 compat_sparc32_setitimer(p, v, retval) 1912 struct proc *p; 1913 void *v; 1914 register_t *retval; 1915 { 1916 struct compat_sparc32_setitimer_args /* { 1917 syscallarg(int) which; 1918 syscallarg(const sparc32_itimervalp_t) itv; 1919 syscallarg(sparc32_itimervalp_t) oitv; 1920 } */ *uap = v; 1921 struct sparc32_itimerval s32it, *itvp; 1922 int which = SCARG(uap, which); 1923 struct compat_sparc32_getitimer_args getargs; 1924 struct itimerval aitv; 1925 int s, error; 1926 1927 if ((u_int)which > ITIMER_PROF) 1928 return (EINVAL); 1929 itvp = (struct sparc32_itimerval *)(u_long)SCARG(uap, itv); 1930 if (itvp && (error = copyin(itvp, &s32it, sizeof(s32it)))) 1931 return (error); 1932 sparc32_to_itimerval(&s32it, &aitv); 1933 if (SCARG(uap, oitv) != NULL) { 1934 SCARG(&getargs, which) = which; 1935 SCARG(&getargs, itv) = SCARG(uap, oitv); 1936 if ((error = compat_sparc32_getitimer(p, &getargs, retval)) != 0) 1937 return (error); 1938 } 1939 if (itvp == 0) 1940 return (0); 1941 if (itimerfix(&aitv.it_value) || itimerfix(&aitv.it_interval)) 1942 return (EINVAL); 1943 s = splclock(); 1944 if (which == ITIMER_REAL) { 1945 untimeout(realitexpire, p); 1946 if (timerisset(&aitv.it_value)) { 1947 timeradd(&aitv.it_value, &time, &aitv.it_value); 1948 timeout(realitexpire, p, hzto(&aitv.it_value)); 1949 } 1950 p->p_realtimer = aitv; 1951 } else 1952 p->p_stats->p_timer[which] = aitv; 1953 splx(s); 1954 return (0); 1955 } 1956 1957 int 1958 compat_sparc32_getitimer(p, v, retval) 1959 struct proc *p; 1960 void *v; 1961 register_t *retval; 1962 { 1963 struct compat_sparc32_getitimer_args /* { 1964 syscallarg(int) which; 1965 syscallarg(sparc32_itimervalp_t) itv; 1966 } */ *uap = v; 1967 int which = SCARG(uap, which); 1968 struct sparc32_itimerval s32it; 1969 struct itimerval aitv; 1970 int s; 1971 1972 if ((u_int)which > ITIMER_PROF) 1973 return (EINVAL); 1974 s = splclock(); 1975 if (which == ITIMER_REAL) { 1976 /* 1977 * Convert from absolute to relative time in .it_value 1978 * part of real time timer. If time for real time timer 1979 * has passed return 0, else return difference between 1980 * current time and time for the timer to go off. 1981 */ 1982 aitv = p->p_realtimer; 1983 if (timerisset(&aitv.it_value)) { 1984 if (timercmp(&aitv.it_value, &time, <)) 1985 timerclear(&aitv.it_value); 1986 else 1987 timersub(&aitv.it_value, &time, &aitv.it_value); 1988 } 1989 } else 1990 aitv = p->p_stats->p_timer[which]; 1991 splx(s); 1992 sparc32_from_itimerval(&aitv, &s32it); 1993 return (copyout(&s32it, (caddr_t)(u_long)SCARG(uap, itv), sizeof(s32it))); 1994 } 1995 1996 int 1997 compat_sparc32_fcntl(p, v, retval) 1998 struct proc *p; 1999 void *v; 2000 register_t *retval; 2001 { 2002 struct compat_sparc32_fcntl_args /* { 2003 syscallarg(int) fd; 2004 syscallarg(int) cmd; 2005 syscallarg(sparc32_voidp) arg; 2006 } */ *uap = v; 2007 struct sys_fcntl_args ua; 2008 2009 SPARC32TO64_UAP(fd); 2010 SPARC32TO64_UAP(cmd); 2011 SPARC32TOP_UAP(arg, void); 2012 /* XXXX we can do this 'cause flock doesn't change */ 2013 return (sys_fcntl(p, &ua, retval)); 2014 } 2015 2016 int 2017 compat_sparc32_dup2(p, v, retval) 2018 struct proc *p; 2019 void *v; 2020 register_t *retval; 2021 { 2022 struct compat_sparc32_dup2_args /* { 2023 syscallarg(int) from; 2024 syscallarg(int) to; 2025 } */ *uap = v; 2026 struct sys_dup2_args ua; 2027 2028 SPARC32TO64_UAP(from); 2029 SPARC32TO64_UAP(to); 2030 return (sys_dup2(p, &ua, retval)); 2031 } 2032 2033 int 2034 compat_sparc32_select(p, v, retval) 2035 struct proc *p; 2036 void *v; 2037 register_t *retval; 2038 { 2039 struct compat_sparc32_select_args /* { 2040 syscallarg(int) nd; 2041 syscallarg(sparc32_fd_setp_t) in; 2042 syscallarg(sparc32_fd_setp_t) ou; 2043 syscallarg(sparc32_fd_setp_t) ex; 2044 syscallarg(sparc32_timevalp_t) tv; 2045 } */ *uap = v; 2046 /* This one must be done in-line 'cause of the timeval */ 2047 struct sparc32_timeval tv32; 2048 caddr_t bits; 2049 char smallbits[howmany(FD_SETSIZE, NFDBITS) * sizeof(fd_mask) * 6]; 2050 struct timeval atv; 2051 int s, ncoll, error = 0, timo; 2052 size_t ni; 2053 extern int selwait, nselcoll; 2054 extern int selscan __P((struct proc *, fd_mask *, fd_mask *, int, register_t *)); 2055 2056 if (SCARG(uap, nd) < 0) 2057 return (EINVAL); 2058 if (SCARG(uap, nd) > p->p_fd->fd_nfiles) { 2059 /* forgiving; slightly wrong */ 2060 SCARG(uap, nd) = p->p_fd->fd_nfiles; 2061 } 2062 ni = howmany(SCARG(uap, nd), NFDBITS) * sizeof(fd_mask); 2063 if (ni * 6 > sizeof(smallbits)) 2064 bits = malloc(ni * 6, M_TEMP, M_WAITOK); 2065 else 2066 bits = smallbits; 2067 2068 #define getbits(name, x) \ 2069 if (SCARG(uap, name)) { \ 2070 error = copyin((caddr_t)(u_long)SCARG(uap, name), bits + ni * x, ni); \ 2071 if (error) \ 2072 goto done; \ 2073 } else \ 2074 memset(bits + ni * x, 0, ni); 2075 getbits(in, 0); 2076 getbits(ou, 1); 2077 getbits(ex, 2); 2078 #undef getbits 2079 2080 if (SCARG(uap, tv)) { 2081 error = copyin((caddr_t)(u_long)SCARG(uap, tv), (caddr_t)&tv32, 2082 sizeof(tv32)); 2083 if (error) 2084 goto done; 2085 sparc32_to_timeval(&tv32, &atv); 2086 if (itimerfix(&atv)) { 2087 error = EINVAL; 2088 goto done; 2089 } 2090 s = splclock(); 2091 timeradd(&atv, &time, &atv); 2092 timo = hzto(&atv); 2093 /* 2094 * Avoid inadvertently sleeping forever. 2095 */ 2096 if (timo == 0) 2097 timo = 1; 2098 splx(s); 2099 } else 2100 timo = 0; 2101 retry: 2102 ncoll = nselcoll; 2103 p->p_flag |= P_SELECT; 2104 error = selscan(p, (fd_mask *)(bits + ni * 0), 2105 (fd_mask *)(bits + ni * 3), SCARG(uap, nd), retval); 2106 if (error || *retval) 2107 goto done; 2108 s = splhigh(); 2109 if (timo && timercmp(&time, &atv, >=)) { 2110 splx(s); 2111 goto done; 2112 } 2113 if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) { 2114 splx(s); 2115 goto retry; 2116 } 2117 p->p_flag &= ~P_SELECT; 2118 error = tsleep((caddr_t)&selwait, PSOCK | PCATCH, "select", timo); 2119 splx(s); 2120 if (error == 0) 2121 goto retry; 2122 done: 2123 p->p_flag &= ~P_SELECT; 2124 /* select is not restarted after signals... */ 2125 if (error == ERESTART) 2126 error = EINTR; 2127 if (error == EWOULDBLOCK) 2128 error = 0; 2129 if (error == 0) { 2130 #define putbits(name, x) \ 2131 if (SCARG(uap, name)) { \ 2132 error = copyout(bits + ni * x, (caddr_t)(u_long)SCARG(uap, name), ni); \ 2133 if (error) \ 2134 goto out; \ 2135 } 2136 putbits(in, 3); 2137 putbits(ou, 4); 2138 putbits(ex, 5); 2139 #undef putbits 2140 } 2141 out: 2142 if (ni * 6 > sizeof(smallbits)) 2143 free(bits, M_TEMP); 2144 return (error); 2145 } 2146 2147 int 2148 compat_sparc32_fsync(p, v, retval) 2149 struct proc *p; 2150 void *v; 2151 register_t *retval; 2152 { 2153 struct compat_sparc32_fsync_args /* { 2154 syscallarg(int) fd; 2155 } */ *uap = v; 2156 struct sys_fsync_args ua; 2157 2158 SPARC32TO64_UAP(fd); 2159 return (sys_fsync(p, &ua, retval)); 2160 } 2161 2162 int 2163 compat_sparc32_setpriority(p, v, retval) 2164 struct proc *p; 2165 void *v; 2166 register_t *retval; 2167 { 2168 struct compat_sparc32_setpriority_args /* { 2169 syscallarg(int) which; 2170 syscallarg(int) who; 2171 syscallarg(int) prio; 2172 } */ *uap = v; 2173 struct sys_setpriority_args ua; 2174 2175 SPARC32TO64_UAP(which); 2176 SPARC32TO64_UAP(who); 2177 SPARC32TO64_UAP(prio); 2178 return (sys_setpriority(p, &ua, retval)); 2179 } 2180 2181 int 2182 compat_sparc32_socket(p, v, retval) 2183 struct proc *p; 2184 void *v; 2185 register_t *retval; 2186 { 2187 struct compat_sparc32_socket_args /* { 2188 syscallarg(int) domain; 2189 syscallarg(int) type; 2190 syscallarg(int) protocol; 2191 } */ *uap = v; 2192 struct sys_socket_args ua; 2193 2194 SPARC32TO64_UAP(domain); 2195 SPARC32TO64_UAP(type); 2196 SPARC32TO64_UAP(protocol); 2197 return (sys_socket(p, &ua, retval)); 2198 } 2199 2200 int 2201 compat_sparc32_connect(p, v, retval) 2202 struct proc *p; 2203 void *v; 2204 register_t *retval; 2205 { 2206 struct compat_sparc32_connect_args /* { 2207 syscallarg(int) s; 2208 syscallarg(const sparc32_sockaddrp_t) name; 2209 syscallarg(int) namelen; 2210 } */ *uap = v; 2211 struct sys_connect_args ua; 2212 2213 SPARC32TO64_UAP(s); 2214 SPARC32TOP_UAP(name, struct sockaddr); 2215 SPARC32TO64_UAP(namelen); 2216 return (sys_connect(p, &ua, retval)); 2217 } 2218 2219 int 2220 compat_sparc32_getpriority(p, v, retval) 2221 struct proc *p; 2222 void *v; 2223 register_t *retval; 2224 { 2225 struct compat_sparc32_getpriority_args /* { 2226 syscallarg(int) which; 2227 syscallarg(int) who; 2228 } */ *uap = v; 2229 struct sys_getpriority_args ua; 2230 2231 SPARC32TO64_UAP(which); 2232 SPARC32TO64_UAP(who); 2233 return (sys_getpriority(p, &ua, retval)); 2234 } 2235 2236 #undef DEBUG 2237 int 2238 compat_sparc32_sigreturn(p, v, retval) 2239 struct proc *p; 2240 void *v; 2241 register_t *retval; 2242 { 2243 struct compat_sparc32_sigreturn_args /* { 2244 syscallarg(struct sparc32_sigcontext *) sigcntxp; 2245 } */ *uap = v; 2246 struct sparc32_sigcontext *scp; 2247 struct sparc32_sigcontext sc; 2248 register struct trapframe *tf; 2249 struct rwindow32 *rwstack, *kstack; 2250 sigset_t mask; 2251 2252 /* First ensure consistent stack state (see sendsig). */ 2253 write_user_windows(); 2254 if (rwindow_save(p)) { 2255 #ifdef DEBUG 2256 printf("sigreturn: rwindow_save(%p) failed, sending SIGILL\n", p); 2257 Debugger(); 2258 #endif 2259 sigexit(p, SIGILL); 2260 } 2261 #ifdef DEBUG 2262 if (sigdebug & SDB_FOLLOW) { 2263 printf("sigreturn: %s[%d], sigcntxp %p\n", 2264 p->p_comm, p->p_pid, SCARG(uap, sigcntxp)); 2265 if (sigdebug & SDB_DDB) Debugger(); 2266 } 2267 #endif 2268 scp = (struct sparc32_sigcontext *)(u_long)SCARG(uap, sigcntxp); 2269 if ((vaddr_t)scp & 3 || (copyin((caddr_t)scp, &sc, sizeof sc) != 0)) 2270 #ifdef DEBUG 2271 { 2272 printf("sigreturn: copyin failed\n"); 2273 Debugger(); 2274 return (EINVAL); 2275 } 2276 #else 2277 return (EINVAL); 2278 #endif 2279 tf = p->p_md.md_tf; 2280 /* 2281 * Only the icc bits in the psr are used, so it need not be 2282 * verified. pc and npc must be multiples of 4. This is all 2283 * that is required; if it holds, just do it. 2284 */ 2285 if (((sc.sc_pc | sc.sc_npc) & 3) != 0) 2286 #ifdef DEBUG 2287 { 2288 printf("sigreturn: pc %p or npc %p invalid\n", sc.sc_pc, sc.sc_npc); 2289 Debugger(); 2290 return (EINVAL); 2291 } 2292 #else 2293 return (EINVAL); 2294 #endif 2295 /* take only psr ICC field */ 2296 tf->tf_tstate = (int64_t)(tf->tf_tstate & ~TSTATE_CCR) | PSRCC_TO_TSTATE(sc.sc_psr); 2297 tf->tf_pc = (int64_t)sc.sc_pc; 2298 tf->tf_npc = (int64_t)sc.sc_npc; 2299 tf->tf_global[1] = (int64_t)sc.sc_g1; 2300 tf->tf_out[0] = (int64_t)sc.sc_o0; 2301 tf->tf_out[6] = (int64_t)sc.sc_sp; 2302 rwstack = (struct rwindow32 *)tf->tf_out[6]; 2303 kstack = (struct rwindow32 *)(((caddr_t)tf)-CCFSZ); 2304 #ifdef DEBUG 2305 if (sigdebug & SDB_FOLLOW) { 2306 printf("sys_sigreturn: return trapframe pc=%p sp=%p tstate=%x\n", 2307 (int)tf->tf_pc, (int)tf->tf_out[6], (int)tf->tf_tstate); 2308 if (sigdebug & SDB_DDB) Debugger(); 2309 } 2310 #endif 2311 if (scp->sc_onstack & SS_ONSTACK) 2312 p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK; 2313 else 2314 p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK; 2315 2316 /* Restore signal mask */ 2317 native_sigset13_to_sigset(&scp->sc_mask, &mask); 2318 (void) sigprocmask1(p, SIG_SETMASK, &mask, 0); 2319 return (EJUSTRETURN); 2320 } 2321 2322 2323 int 2324 compat_sparc32_bind(p, v, retval) 2325 struct proc *p; 2326 void *v; 2327 register_t *retval; 2328 { 2329 struct compat_sparc32_bind_args /* { 2330 syscallarg(int) s; 2331 syscallarg(const sparc32_sockaddrp_t) name; 2332 syscallarg(int) namelen; 2333 } */ *uap = v; 2334 struct sys_bind_args ua; 2335 2336 SPARC32TO64_UAP(s); 2337 SPARC32TOP_UAP(name, struct sockaddr); 2338 SPARC32TO64_UAP(namelen); 2339 return (sys_bind(p, &ua, retval)); 2340 } 2341 2342 int 2343 compat_sparc32_setsockopt(p, v, retval) 2344 struct proc *p; 2345 void *v; 2346 register_t *retval; 2347 { 2348 struct compat_sparc32_setsockopt_args /* { 2349 syscallarg(int) s; 2350 syscallarg(int) level; 2351 syscallarg(int) name; 2352 syscallarg(const sparc32_voidp) val; 2353 syscallarg(int) valsize; 2354 } */ *uap = v; 2355 struct sys_setsockopt_args ua; 2356 2357 SPARC32TO64_UAP(s); 2358 SPARC32TO64_UAP(level); 2359 SPARC32TO64_UAP(name); 2360 SPARC32TOP_UAP(val, void); 2361 SPARC32TO64_UAP(valsize); 2362 /* may be more efficient to do this inline. */ 2363 return (sys_setsockopt(p, &ua, retval)); 2364 } 2365 2366 int 2367 compat_sparc32_listen(p, v, retval) 2368 struct proc *p; 2369 void *v; 2370 register_t *retval; 2371 { 2372 struct compat_sparc32_listen_args /* { 2373 syscallarg(int) s; 2374 syscallarg(int) backlog; 2375 } */ *uap = v; 2376 struct sys_listen_args ua; 2377 2378 SPARC32TO64_UAP(s); 2379 SPARC32TO64_UAP(backlog); 2380 return (sys_listen(p, &ua, retval)); 2381 } 2382 2383 int 2384 compat_sparc32_vtrace(p, v, retval) 2385 struct proc *p; 2386 void *v; 2387 register_t *retval; 2388 { 2389 #ifdef TRACE 2390 struct compat_sparc32_vtrace_args /* { 2391 syscallarg(int) request; 2392 syscallarg(int) value; 2393 } */ *uap = v; 2394 struct sys_vtrace_args ua; 2395 2396 SPARC32TO64_UAP(request); 2397 SPARC32TO64_UAP(value); 2398 return (vtrace(p, &ua, retval)); 2399 #else 2400 return (ENOSYS); 2401 #endif 2402 } 2403 2404 int 2405 compat_sparc32_gettimeofday(p, v, retval) 2406 struct proc *p; 2407 void *v; 2408 register_t *retval; 2409 { 2410 struct compat_sparc32_gettimeofday_args /* { 2411 syscallarg(sparc32_timevalp_t) tp; 2412 syscallarg(sparc32_timezonep_t) tzp; 2413 } */ *uap = v; 2414 struct timeval atv; 2415 struct sparc32_timeval tv32; 2416 int error = 0; 2417 struct sparc32_timezone tzfake; 2418 2419 if (SCARG(uap, tp)) { 2420 microtime(&atv); 2421 sparc32_from_timeval(&atv, &tv32); 2422 error = copyout(&tv32, (caddr_t)(u_long)SCARG(uap, tp), sizeof(tv32)); 2423 if (error) 2424 return (error); 2425 } 2426 if (SCARG(uap, tzp)) { 2427 /* 2428 * NetBSD has no kernel notion of time zone, so we just 2429 * fake up a timezone struct and return it if demanded. 2430 */ 2431 tzfake.tz_minuteswest = 0; 2432 tzfake.tz_dsttime = 0; 2433 error = copyout(&tzfake, (caddr_t)(u_long)SCARG(uap, tzp), sizeof(tzfake)); 2434 } 2435 return (error); 2436 } 2437 2438 static int settime __P((struct timeval *)); 2439 /* This function is used by clock_settime and settimeofday */ 2440 static int 2441 settime(tv) 2442 struct timeval *tv; 2443 { 2444 struct timeval delta; 2445 int s; 2446 2447 /* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */ 2448 s = splclock(); 2449 timersub(tv, &time, &delta); 2450 if ((delta.tv_sec < 0 || delta.tv_usec < 0) && securelevel > 1) 2451 return (EPERM); 2452 #ifdef notyet 2453 if ((delta.tv_sec < 86400) && securelevel > 0) 2454 return (EPERM); 2455 #endif 2456 time = *tv; 2457 (void) splsoftclock(); 2458 timeradd(&boottime, &delta, &boottime); 2459 timeradd(&runtime, &delta, &runtime); 2460 # if defined(NFS) || defined(NFSSERVER) 2461 nqnfs_lease_updatetime(delta.tv_sec); 2462 # endif 2463 splx(s); 2464 resettodr(); 2465 return (0); 2466 } 2467 2468 2469 int 2470 compat_sparc32_settimeofday(p, v, retval) 2471 struct proc *p; 2472 void *v; 2473 register_t *retval; 2474 { 2475 struct compat_sparc32_settimeofday_args /* { 2476 syscallarg(const sparc32_timevalp_t) tv; 2477 syscallarg(const sparc32_timezonep_t) tzp; 2478 } */ *uap = v; 2479 struct sparc32_timeval atv32; 2480 struct timeval atv; 2481 struct sparc32_timezone atz; 2482 int error; 2483 2484 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 2485 return (error); 2486 /* Verify all parameters before changing time. */ 2487 if (SCARG(uap, tv) && (error = copyin((caddr_t)(u_long)SCARG(uap, tv), 2488 &atv32, sizeof(atv32)))) 2489 return (error); 2490 sparc32_to_timeval(&atv32, &atv); 2491 /* XXX since we don't use tz, probably no point in doing copyin. */ 2492 if (SCARG(uap, tzp) && (error = copyin((caddr_t)(u_long)SCARG(uap, tzp), 2493 &atz, sizeof(atz)))) 2494 return (error); 2495 if (SCARG(uap, tv)) 2496 if ((error = settime(&atv))) 2497 return (error); 2498 /* 2499 * NetBSD has no kernel notion of time zone, and only an 2500 * obsolete program would try to set it, so we log a warning. 2501 */ 2502 if (SCARG(uap, tzp)) 2503 printf("pid %d attempted to set the " 2504 "(obsolete) kernel time zone\n", p->p_pid); 2505 return (0); 2506 } 2507 2508 int 2509 compat_sparc32_fchown(p, v, retval) 2510 struct proc *p; 2511 void *v; 2512 register_t *retval; 2513 { 2514 struct compat_sparc32_fchown_args /* { 2515 syscallarg(int) fd; 2516 syscallarg(uid_t) uid; 2517 syscallarg(gid_t) gid; 2518 } */ *uap = v; 2519 struct sys_fchown_args ua; 2520 2521 SPARC32TO64_UAP(fd); 2522 SPARC32TO64_UAP(uid); 2523 SPARC32TO64_UAP(gid); 2524 return (sys_fchown(p, &ua, retval)); 2525 } 2526 2527 int 2528 compat_sparc32_fchmod(p, v, retval) 2529 struct proc *p; 2530 void *v; 2531 register_t *retval; 2532 { 2533 struct compat_sparc32_fchmod_args /* { 2534 syscallarg(int) fd; 2535 syscallarg(mode_t) mode; 2536 } */ *uap = v; 2537 struct sys_fchmod_args ua; 2538 2539 SPARC32TO64_UAP(fd); 2540 SPARC32TO64_UAP(mode); 2541 return (sys_fchmod(p, &ua, retval)); 2542 } 2543 2544 int 2545 compat_sparc32_setreuid(p, v, retval) 2546 struct proc *p; 2547 void *v; 2548 register_t *retval; 2549 { 2550 struct compat_sparc32_setreuid_args /* { 2551 syscallarg(uid_t) ruid; 2552 syscallarg(uid_t) euid; 2553 } */ *uap = v; 2554 struct sys_setreuid_args ua; 2555 2556 SPARC32TO64_UAP(ruid); 2557 SPARC32TO64_UAP(euid); 2558 return (sys_setreuid(p, &ua, retval)); 2559 } 2560 2561 int 2562 compat_sparc32_setregid(p, v, retval) 2563 struct proc *p; 2564 void *v; 2565 register_t *retval; 2566 { 2567 struct compat_sparc32_setregid_args /* { 2568 syscallarg(gid_t) rgid; 2569 syscallarg(gid_t) egid; 2570 } */ *uap = v; 2571 struct sys_setregid_args ua; 2572 2573 SPARC32TO64_UAP(rgid); 2574 SPARC32TO64_UAP(egid); 2575 return (sys_setregid(p, &ua, retval)); 2576 } 2577 2578 int 2579 compat_sparc32_getrusage(p, v, retval) 2580 struct proc *p; 2581 void *v; 2582 register_t *retval; 2583 { 2584 struct compat_sparc32_getrusage_args /* { 2585 syscallarg(int) who; 2586 syscallarg(sparc32_rusagep_t) rusage; 2587 } */ *uap = v; 2588 struct rusage *rup; 2589 struct sparc32_rusage ru; 2590 2591 switch (SCARG(uap, who)) { 2592 2593 case RUSAGE_SELF: 2594 rup = &p->p_stats->p_ru; 2595 calcru(p, &rup->ru_utime, &rup->ru_stime, NULL); 2596 break; 2597 2598 case RUSAGE_CHILDREN: 2599 rup = &p->p_stats->p_cru; 2600 break; 2601 2602 default: 2603 return (EINVAL); 2604 } 2605 sparc32_from_rusage(rup, &ru); 2606 return (copyout(&ru, (caddr_t)(u_long)SCARG(uap, rusage), sizeof(ru))); 2607 } 2608 2609 int 2610 compat_sparc32_getsockopt(p, v, retval) 2611 struct proc *p; 2612 void *v; 2613 register_t *retval; 2614 { 2615 struct compat_sparc32_getsockopt_args /* { 2616 syscallarg(int) s; 2617 syscallarg(int) level; 2618 syscallarg(int) name; 2619 syscallarg(sparc32_voidp) val; 2620 syscallarg(sparc32_intp) avalsize; 2621 } */ *uap = v; 2622 struct sys_getsockopt_args ua; 2623 2624 SPARC32TO64_UAP(s); 2625 SPARC32TO64_UAP(level); 2626 SPARC32TO64_UAP(name); 2627 SPARC32TOP_UAP(val, void); 2628 SPARC32TOP_UAP(avalsize, int); 2629 return (sys_getsockopt(p, &ua, retval)); 2630 } 2631 2632 int 2633 compat_sparc32_readv(p, v, retval) 2634 struct proc *p; 2635 void *v; 2636 register_t *retval; 2637 { 2638 struct compat_sparc32_readv_args /* { 2639 syscallarg(int) fd; 2640 syscallarg(const sparc32_iovecp_t) iovp; 2641 syscallarg(int) iovcnt; 2642 } */ *uap = v; 2643 int fd = SCARG(uap, fd); 2644 register struct file *fp; 2645 register struct filedesc *fdp = p->p_fd; 2646 2647 if ((u_int)fd >= fdp->fd_nfiles || 2648 (fp = fdp->fd_ofiles[fd]) == NULL || 2649 (fp->f_flag & FREAD) == 0) 2650 return (EBADF); 2651 2652 return (dofilereadv32(p, fd, fp, (struct sparc32_iovec *)(u_long)SCARG(uap, iovp), 2653 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval)); 2654 } 2655 2656 /* Damn thing copies in the iovec! */ 2657 int 2658 dofilereadv32(p, fd, fp, iovp, iovcnt, offset, flags, retval) 2659 struct proc *p; 2660 int fd; 2661 struct file *fp; 2662 struct sparc32_iovec *iovp; 2663 int iovcnt; 2664 off_t *offset; 2665 int flags; 2666 register_t *retval; 2667 { 2668 struct uio auio; 2669 register struct iovec *iov; 2670 struct iovec *needfree; 2671 struct iovec aiov[UIO_SMALLIOV]; 2672 long i, cnt, error = 0; 2673 u_int iovlen; 2674 #ifdef KTRACE 2675 struct iovec *ktriov = NULL; 2676 #endif 2677 2678 /* note: can't use iovlen until iovcnt is validated */ 2679 iovlen = iovcnt * sizeof(struct iovec); 2680 if ((u_int)iovcnt > UIO_SMALLIOV) { 2681 if ((u_int)iovcnt > IOV_MAX) 2682 return (EINVAL); 2683 MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK); 2684 needfree = iov; 2685 } else if ((u_int)iovcnt > 0) { 2686 iov = aiov; 2687 needfree = NULL; 2688 } else 2689 return (EINVAL); 2690 2691 auio.uio_iov = iov; 2692 auio.uio_iovcnt = iovcnt; 2693 auio.uio_rw = UIO_READ; 2694 auio.uio_segflg = UIO_USERSPACE; 2695 auio.uio_procp = p; 2696 error = sparc32_to_iovecin(iovp, iov, iovcnt); 2697 if (error) 2698 goto done; 2699 auio.uio_resid = 0; 2700 for (i = 0; i < iovcnt; i++) { 2701 auio.uio_resid += iov->iov_len; 2702 /* 2703 * Reads return ssize_t because -1 is returned on error. 2704 * Therefore we must restrict the length to SSIZE_MAX to 2705 * avoid garbage return values. 2706 */ 2707 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) { 2708 error = EINVAL; 2709 goto done; 2710 } 2711 iov++; 2712 } 2713 #ifdef KTRACE 2714 /* 2715 * if tracing, save a copy of iovec 2716 */ 2717 if (KTRPOINT(p, KTR_GENIO)) { 2718 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 2719 memcpy((caddr_t)ktriov, (caddr_t)auio.uio_iov, iovlen); 2720 } 2721 #endif 2722 cnt = auio.uio_resid; 2723 error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred, flags); 2724 if (error) 2725 if (auio.uio_resid != cnt && (error == ERESTART || 2726 error == EINTR || error == EWOULDBLOCK)) 2727 error = 0; 2728 cnt -= auio.uio_resid; 2729 #ifdef KTRACE 2730 if (KTRPOINT(p, KTR_GENIO)) 2731 if (error == 0) { 2732 ktrgenio(p->p_tracep, fd, UIO_READ, ktriov, cnt, 2733 error); 2734 FREE(ktriov, M_TEMP); 2735 } 2736 #endif 2737 *retval = cnt; 2738 done: 2739 if (needfree) 2740 FREE(needfree, M_IOV); 2741 return (error); 2742 } 2743 2744 2745 int 2746 compat_sparc32_writev(p, v, retval) 2747 struct proc *p; 2748 void *v; 2749 register_t *retval; 2750 { 2751 struct compat_sparc32_writev_args /* { 2752 syscallarg(int) fd; 2753 syscallarg(const sparc32_iovecp_t) iovp; 2754 syscallarg(int) iovcnt; 2755 } */ *uap = v; 2756 int fd = SCARG(uap, fd); 2757 register struct file *fp; 2758 register struct filedesc *fdp = p->p_fd; 2759 2760 if ((u_int)fd >= fdp->fd_nfiles || 2761 (fp = fdp->fd_ofiles[fd]) == NULL || 2762 (fp->f_flag & FWRITE) == 0) 2763 return (EBADF); 2764 2765 return (dofilewritev32(p, fd, fp, (struct sparc32_iovec *)(u_long)SCARG(uap, iovp), 2766 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval)); 2767 } 2768 2769 int 2770 dofilewritev32(p, fd, fp, iovp, iovcnt, offset, flags, retval) 2771 struct proc *p; 2772 int fd; 2773 struct file *fp; 2774 struct sparc32_iovec *iovp; 2775 int iovcnt; 2776 off_t *offset; 2777 int flags; 2778 register_t *retval; 2779 { 2780 struct uio auio; 2781 register struct iovec *iov; 2782 struct iovec *needfree; 2783 struct iovec aiov[UIO_SMALLIOV]; 2784 long i, cnt, error = 0; 2785 u_int iovlen; 2786 #ifdef KTRACE 2787 struct iovec *ktriov = NULL; 2788 #endif 2789 2790 /* note: can't use iovlen until iovcnt is validated */ 2791 iovlen = iovcnt * sizeof(struct iovec); 2792 if ((u_int)iovcnt > UIO_SMALLIOV) { 2793 if ((u_int)iovcnt > IOV_MAX) 2794 return (EINVAL); 2795 MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK); 2796 needfree = iov; 2797 } else if ((u_int)iovcnt > 0) { 2798 iov = aiov; 2799 needfree = NULL; 2800 } else 2801 return (EINVAL); 2802 2803 auio.uio_iov = iov; 2804 auio.uio_iovcnt = iovcnt; 2805 auio.uio_rw = UIO_WRITE; 2806 auio.uio_segflg = UIO_USERSPACE; 2807 auio.uio_procp = p; 2808 error = sparc32_to_iovecin(iovp, iov, iovcnt); 2809 if (error) 2810 goto done; 2811 auio.uio_resid = 0; 2812 for (i = 0; i < iovcnt; i++) { 2813 auio.uio_resid += iov->iov_len; 2814 /* 2815 * Writes return ssize_t because -1 is returned on error. 2816 * Therefore we must restrict the length to SSIZE_MAX to 2817 * avoid garbage return values. 2818 */ 2819 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) { 2820 error = EINVAL; 2821 goto done; 2822 } 2823 iov++; 2824 } 2825 #ifdef KTRACE 2826 /* 2827 * if tracing, save a copy of iovec 2828 */ 2829 if (KTRPOINT(p, KTR_GENIO)) { 2830 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 2831 memcpy((caddr_t)ktriov, (caddr_t)auio.uio_iov, iovlen); 2832 } 2833 #endif 2834 cnt = auio.uio_resid; 2835 error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred, flags); 2836 if (error) { 2837 if (auio.uio_resid != cnt && (error == ERESTART || 2838 error == EINTR || error == EWOULDBLOCK)) 2839 error = 0; 2840 if (error == EPIPE) 2841 psignal(p, SIGPIPE); 2842 } 2843 cnt -= auio.uio_resid; 2844 #ifdef KTRACE 2845 if (KTRPOINT(p, KTR_GENIO)) 2846 if (error == 0) { 2847 ktrgenio(p->p_tracep, fd, UIO_WRITE, ktriov, cnt, 2848 error); 2849 FREE(ktriov, M_TEMP); 2850 } 2851 #endif 2852 *retval = cnt; 2853 done: 2854 if (needfree) 2855 FREE(needfree, M_IOV); 2856 return (error); 2857 } 2858 2859 2860 int 2861 compat_sparc32_rename(p, v, retval) 2862 struct proc *p; 2863 void *v; 2864 register_t *retval; 2865 { 2866 struct compat_sparc32_rename_args /* { 2867 syscallarg(const sparc32_charp) from; 2868 syscallarg(const sparc32_charp) to; 2869 } */ *uap = v; 2870 struct sys_rename_args ua; 2871 2872 SPARC32TOP_UAP(from, const char *); 2873 SPARC32TOP_UAP(to, const char *) 2874 2875 return (sys_rename(p, &ua, retval)); 2876 } 2877 2878 int 2879 compat_sparc32_flock(p, v, retval) 2880 struct proc *p; 2881 void *v; 2882 register_t *retval; 2883 { 2884 struct compat_sparc32_flock_args /* { 2885 syscallarg(int) fd; 2886 syscallarg(int) how; 2887 } */ *uap = v; 2888 struct sys_flock_args ua; 2889 2890 SPARC32TO64_UAP(fd); 2891 SPARC32TO64_UAP(how) 2892 2893 return (sys_flock(p, &ua, retval)); 2894 } 2895 2896 int 2897 compat_sparc32_mkfifo(p, v, retval) 2898 struct proc *p; 2899 void *v; 2900 register_t *retval; 2901 { 2902 struct compat_sparc32_mkfifo_args /* { 2903 syscallarg(const sparc32_charp) path; 2904 syscallarg(mode_t) mode; 2905 } */ *uap = v; 2906 struct sys_mkfifo_args ua; 2907 2908 SPARC32TOP_UAP(path, const char) 2909 SPARC32TO64_UAP(mode); 2910 return (sys_mkfifo(p, &ua, retval)); 2911 } 2912 2913 int 2914 compat_sparc32_shutdown(p, v, retval) 2915 struct proc *p; 2916 void *v; 2917 register_t *retval; 2918 { 2919 struct compat_sparc32_shutdown_args /* { 2920 syscallarg(int) s; 2921 syscallarg(int) how; 2922 } */ *uap = v; 2923 struct sys_shutdown_args ua; 2924 2925 SPARC32TO64_UAP(s) 2926 SPARC32TO64_UAP(how); 2927 return (sys_shutdown(p, &ua, retval)); 2928 } 2929 2930 int 2931 compat_sparc32_socketpair(p, v, retval) 2932 struct proc *p; 2933 void *v; 2934 register_t *retval; 2935 { 2936 struct compat_sparc32_socketpair_args /* { 2937 syscallarg(int) domain; 2938 syscallarg(int) type; 2939 syscallarg(int) protocol; 2940 syscallarg(sparc32_intp) rsv; 2941 } */ *uap = v; 2942 struct sys_socketpair_args ua; 2943 2944 SPARC32TO64_UAP(domain); 2945 SPARC32TO64_UAP(type); 2946 SPARC32TO64_UAP(protocol); 2947 SPARC32TOP_UAP(rsv, int); 2948 /* Since we're just copying out two `int's we can do this */ 2949 return (sys_socketpair(p, &ua, retval)); 2950 } 2951 2952 int 2953 compat_sparc32_mkdir(p, v, retval) 2954 struct proc *p; 2955 void *v; 2956 register_t *retval; 2957 { 2958 struct compat_sparc32_mkdir_args /* { 2959 syscallarg(const sparc32_charp) path; 2960 syscallarg(mode_t) mode; 2961 } */ *uap = v; 2962 struct sys_mkdir_args ua; 2963 2964 SPARC32TOP_UAP(path, const char) 2965 SPARC32TO64_UAP(mode); 2966 return (sys_mkdir(p, &ua, retval)); 2967 } 2968 2969 int 2970 compat_sparc32_rmdir(p, v, retval) 2971 struct proc *p; 2972 void *v; 2973 register_t *retval; 2974 { 2975 struct compat_sparc32_rmdir_args /* { 2976 syscallarg(const sparc32_charp) path; 2977 } */ *uap = v; 2978 struct sys_rmdir_args ua; 2979 2980 SPARC32TOP_UAP(path, const char); 2981 return (sys_rmdir(p, &ua, retval)); 2982 } 2983 2984 int 2985 compat_sparc32_utimes(p, v, retval) 2986 struct proc *p; 2987 void *v; 2988 register_t *retval; 2989 { 2990 struct compat_sparc32_utimes_args /* { 2991 syscallarg(const sparc32_charp) path; 2992 syscallarg(const sparc32_timevalp_t) tptr; 2993 } */ *uap = v; 2994 int error; 2995 struct nameidata nd; 2996 2997 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, (char *)(u_long)SCARG(uap, path), p); 2998 if ((error = namei(&nd)) != 0) 2999 return (error); 3000 3001 error = change_utimes32(nd.ni_vp, (struct timeval *)(u_long)SCARG(uap, tptr), p); 3002 3003 vrele(nd.ni_vp); 3004 return (error); 3005 } 3006 3007 /* 3008 * Common routine to set access and modification times given a vnode. 3009 */ 3010 static int 3011 change_utimes32(vp, tptr, p) 3012 struct vnode *vp; 3013 struct timeval *tptr; 3014 struct proc *p; 3015 { 3016 struct sparc32_timeval tv32[2]; 3017 struct timeval tv[2]; 3018 struct vattr vattr; 3019 int error; 3020 3021 VATTR_NULL(&vattr); 3022 if (tptr == NULL) { 3023 microtime(&tv[0]); 3024 tv[1] = tv[0]; 3025 vattr.va_vaflags |= VA_UTIMES_NULL; 3026 } else { 3027 error = copyin(tptr, tv, sizeof(tv)); 3028 if (error) 3029 return (error); 3030 } 3031 sparc32_to_timeval(&tv32[0], &tv[0]); 3032 sparc32_to_timeval(&tv32[1], &tv[1]); 3033 VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); 3034 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 3035 vattr.va_atime.tv_sec = tv[0].tv_sec; 3036 vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000; 3037 vattr.va_mtime.tv_sec = tv[1].tv_sec; 3038 vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000; 3039 error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); 3040 VOP_UNLOCK(vp, 0); 3041 return (error); 3042 } 3043 3044 int 3045 compat_sparc32_adjtime(p, v, retval) 3046 struct proc *p; 3047 void *v; 3048 register_t *retval; 3049 { 3050 struct compat_sparc32_adjtime_args /* { 3051 syscallarg(const sparc32_timevalp_t) delta; 3052 syscallarg(sparc32_timevalp_t) olddelta; 3053 } */ *uap = v; 3054 struct sparc32_timeval atv; 3055 int32_t ndelta, ntickdelta, odelta; 3056 int s, error; 3057 extern long bigadj, timedelta; 3058 extern int tickdelta; 3059 3060 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 3061 return (error); 3062 3063 error = copyin((caddr_t)(u_long)SCARG(uap, delta), &atv, sizeof(struct timeval)); 3064 if (error) 3065 return (error); 3066 /* 3067 * Compute the total correction and the rate at which to apply it. 3068 * Round the adjustment down to a whole multiple of the per-tick 3069 * delta, so that after some number of incremental changes in 3070 * hardclock(), tickdelta will become zero, lest the correction 3071 * overshoot and start taking us away from the desired final time. 3072 */ 3073 ndelta = atv.tv_sec * 1000000 + atv.tv_usec; 3074 if (ndelta > bigadj) 3075 ntickdelta = 10 * tickadj; 3076 else 3077 ntickdelta = tickadj; 3078 if (ndelta % ntickdelta) 3079 ndelta = ndelta / ntickdelta * ntickdelta; 3080 3081 /* 3082 * To make hardclock()'s job easier, make the per-tick delta negative 3083 * if we want time to run slower; then hardclock can simply compute 3084 * tick + tickdelta, and subtract tickdelta from timedelta. 3085 */ 3086 if (ndelta < 0) 3087 ntickdelta = -ntickdelta; 3088 s = splclock(); 3089 odelta = timedelta; 3090 timedelta = ndelta; 3091 tickdelta = ntickdelta; 3092 splx(s); 3093 3094 if (SCARG(uap, olddelta)) { 3095 atv.tv_sec = odelta / 1000000; 3096 atv.tv_usec = odelta % 1000000; 3097 (void) copyout(&atv, (caddr_t)(u_long)SCARG(uap, olddelta), 3098 sizeof(struct timeval)); 3099 } 3100 return (0); 3101 } 3102 3103 int 3104 compat_sparc32_quotactl(p, v, retval) 3105 struct proc *p; 3106 void *v; 3107 register_t *retval; 3108 { 3109 struct compat_sparc32_quotactl_args /* { 3110 syscallarg(const sparc32_charp) path; 3111 syscallarg(int) cmd; 3112 syscallarg(int) uid; 3113 syscallarg(sparc32_caddr_t) arg; 3114 } */ *uap = v; 3115 struct sys_quotactl_args ua; 3116 3117 SPARC32TOP_UAP(path, const char); 3118 SPARC32TO64_UAP(cmd); 3119 SPARC32TO64_UAP(uid); 3120 SPARC32TOX64_UAP(arg, caddr_t); 3121 return (sys_quotactl(p, &ua, retval)); 3122 } 3123 3124 #if defined(NFS) || defined(NFSSERVER) 3125 int 3126 compat_sparc32_nfssvc(p, v, retval) 3127 struct proc *p; 3128 void *v; 3129 register_t *retval; 3130 { 3131 #if 0 3132 struct compat_sparc32_nfssvc_args /* { 3133 syscallarg(int) flag; 3134 syscallarg(sparc32_voidp) argp; 3135 } */ *uap = v; 3136 struct sys_nfssvc_args ua; 3137 3138 SPARC32TO64_UAP(flag); 3139 SPARC32TOP_UAP(argp, void); 3140 return (sys_nfssvc(p, &ua, retval)); 3141 #else 3142 /* Why would we want to support a 32-bit nfsd? */ 3143 return (ENOSYS); 3144 #endif 3145 } 3146 #endif 3147 3148 int 3149 compat_sparc32_statfs(p, v, retval) 3150 struct proc *p; 3151 void *v; 3152 register_t *retval; 3153 { 3154 struct compat_sparc32_statfs_args /* { 3155 syscallarg(const sparc32_charp) path; 3156 syscallarg(sparc32_statfsp_t) buf; 3157 } */ *uap = v; 3158 register struct mount *mp; 3159 register struct statfs *sp; 3160 struct sparc32_statfs s32; 3161 int error; 3162 struct nameidata nd; 3163 3164 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, (char *)(u_long)SCARG(uap, path), p); 3165 if ((error = namei(&nd)) != 0) 3166 return (error); 3167 mp = nd.ni_vp->v_mount; 3168 sp = &mp->mnt_stat; 3169 vrele(nd.ni_vp); 3170 if ((error = VFS_STATFS(mp, sp, p)) != 0) 3171 return (error); 3172 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 3173 sparc32_from_statfs(sp, &s32); 3174 return (copyout(&s32, (caddr_t)(u_long)SCARG(uap, buf), sizeof(s32))); 3175 } 3176 3177 int 3178 compat_sparc32_fstatfs(p, v, retval) 3179 struct proc *p; 3180 void *v; 3181 register_t *retval; 3182 { 3183 struct compat_sparc32_fstatfs_args /* { 3184 syscallarg(int) fd; 3185 syscallarg(sparc32_statfsp_t) buf; 3186 } */ *uap = v; 3187 struct file *fp; 3188 register struct mount *mp; 3189 register struct statfs *sp; 3190 struct sparc32_statfs s32; 3191 int error; 3192 3193 if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) 3194 return (error); 3195 mp = ((struct vnode *)fp->f_data)->v_mount; 3196 sp = &mp->mnt_stat; 3197 if ((error = VFS_STATFS(mp, sp, p)) != 0) 3198 return (error); 3199 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 3200 sparc32_from_statfs(sp, &s32); 3201 return (copyout(&s32, (caddr_t)(u_long)SCARG(uap, buf), sizeof(s32))); 3202 } 3203 3204 #if defined(NFS) || defined(NFSSERVER) 3205 int 3206 compat_sparc32_getfh(p, v, retval) 3207 struct proc *p; 3208 void *v; 3209 register_t *retval; 3210 { 3211 struct compat_sparc32_getfh_args /* { 3212 syscallarg(const sparc32_charp) fname; 3213 syscallarg(sparc32_fhandlep_t) fhp; 3214 } */ *uap = v; 3215 struct sys_getfh_args ua; 3216 3217 SPARC32TOP_UAP(fname, const char); 3218 SPARC32TOP_UAP(fhp, struct fhandle); 3219 /* Lucky for us a fhandlep_t doesn't change sizes */ 3220 return (sys_getfh(p, &ua, retval)); 3221 } 3222 #endif 3223 3224 int 3225 compat_sparc32_sysarch(p, v, retval) 3226 struct proc *p; 3227 void *v; 3228 register_t *retval; 3229 { 3230 struct compat_sparc32_sysarch_args /* { 3231 syscallarg(int) op; 3232 syscallarg(sparc32_voidp) parms; 3233 } */ *uap = v; 3234 3235 switch (SCARG(uap, op)) { 3236 default: 3237 printf("(sparc64) compat_sparc32_sysarch(%d)\n", SCARG(uap, op)); 3238 return EINVAL; 3239 } 3240 } 3241 3242 int 3243 compat_sparc32_pread(p, v, retval) 3244 struct proc *p; 3245 void *v; 3246 register_t *retval; 3247 { 3248 struct compat_sparc32_pread_args /* { 3249 syscallarg(int) fd; 3250 syscallarg(sparc32_voidp) buf; 3251 syscallarg(sparc32_size_t) nbyte; 3252 syscallarg(int) pad; 3253 syscallarg(off_t) offset; 3254 } */ *uap = v; 3255 struct sys_pread_args ua; 3256 ssize_t rt; 3257 int error; 3258 3259 SPARC32TO64_UAP(fd); 3260 SPARC32TOP_UAP(buf, void); 3261 SPARC32TOX_UAP(nbyte, size_t); 3262 SPARC32TO64_UAP(pad); 3263 SPARC32TO64_UAP(offset); 3264 error = sys_pread(p, &ua, (register_t *)&rt); 3265 *(sparc32_ssize_t *)retval = rt; 3266 return (error); 3267 } 3268 3269 int 3270 compat_sparc32_pwrite(p, v, retval) 3271 struct proc *p; 3272 void *v; 3273 register_t *retval; 3274 { 3275 struct compat_sparc32_pwrite_args /* { 3276 syscallarg(int) fd; 3277 syscallarg(const sparc32_voidp) buf; 3278 syscallarg(sparc32_size_t) nbyte; 3279 syscallarg(int) pad; 3280 syscallarg(off_t) offset; 3281 } */ *uap = v; 3282 struct sys_pwrite_args ua; 3283 ssize_t rt; 3284 int error; 3285 3286 SPARC32TO64_UAP(fd); 3287 SPARC32TOP_UAP(buf, void); 3288 SPARC32TOX_UAP(nbyte, size_t); 3289 SPARC32TO64_UAP(pad); 3290 SPARC32TO64_UAP(offset); 3291 error = sys_pwrite(p, &ua, (register_t *)&rt); 3292 *(sparc32_ssize_t *)retval = rt; 3293 return (error); 3294 } 3295 3296 #ifdef NTP 3297 int 3298 compat_sparc32_ntp_gettime(p, v, retval) 3299 struct proc *p; 3300 void *v; 3301 register_t *retval; 3302 { 3303 struct compat_sparc32_ntp_gettime_args /* { 3304 syscallarg(sparc32_ntptimevalp_t) ntvp; 3305 } */ *uap = v; 3306 struct sparc32_ntptimeval ntv32; 3307 struct timeval atv; 3308 struct ntptimeval ntv; 3309 int error = 0; 3310 int s; 3311 3312 /* The following are NTP variables */ 3313 extern long time_maxerror; 3314 extern long time_esterror; 3315 extern int time_status; 3316 extern int time_state; /* clock state */ 3317 extern int time_status; /* clock status bits */ 3318 3319 if (SCARG(uap, ntvp)) { 3320 s = splclock(); 3321 #ifdef EXT_CLOCK 3322 /* 3323 * The microtime() external clock routine returns a 3324 * status code. If less than zero, we declare an error 3325 * in the clock status word and return the kernel 3326 * (software) time variable. While there are other 3327 * places that call microtime(), this is the only place 3328 * that matters from an application point of view. 3329 */ 3330 if (microtime(&atv) < 0) { 3331 time_status |= STA_CLOCKERR; 3332 ntv.time = time; 3333 } else 3334 time_status &= ~STA_CLOCKERR; 3335 #else /* EXT_CLOCK */ 3336 microtime(&atv); 3337 #endif /* EXT_CLOCK */ 3338 ntv.time = atv; 3339 ntv.maxerror = time_maxerror; 3340 ntv.esterror = time_esterror; 3341 (void) splx(s); 3342 3343 sparc32_from_timeval(&ntv.time, &ntv32.time); 3344 ntv32.maxerror = (sparc32_long)ntv.maxerror; 3345 ntv32.esterror = (sparc32_long)ntv.esterror; 3346 error = copyout((caddr_t)&ntv32, (caddr_t)(u_long)SCARG(uap, ntvp), 3347 sizeof(ntv32)); 3348 } 3349 if (!error) { 3350 3351 /* 3352 * Status word error decode. If any of these conditions 3353 * occur, an error is returned, instead of the status 3354 * word. Most applications will care only about the fact 3355 * the system clock may not be trusted, not about the 3356 * details. 3357 * 3358 * Hardware or software error 3359 */ 3360 if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) || 3361 3362 /* 3363 * PPS signal lost when either time or frequency 3364 * synchronization requested 3365 */ 3366 (time_status & (STA_PPSFREQ | STA_PPSTIME) && 3367 !(time_status & STA_PPSSIGNAL)) || 3368 3369 /* 3370 * PPS jitter exceeded when time synchronization 3371 * requested 3372 */ 3373 (time_status & STA_PPSTIME && 3374 time_status & STA_PPSJITTER) || 3375 3376 /* 3377 * PPS wander exceeded or calibration error when 3378 * frequency synchronization requested 3379 */ 3380 (time_status & STA_PPSFREQ && 3381 time_status & (STA_PPSWANDER | STA_PPSERROR))) 3382 *retval = TIME_ERROR; 3383 else 3384 *retval = (register_t)time_state; 3385 } 3386 return(error); 3387 } 3388 3389 int 3390 compat_sparc32_ntp_adjtime(p, v, retval) 3391 struct proc *p; 3392 void *v; 3393 register_t *retval; 3394 { 3395 struct compat_sparc32_ntp_adjtime_args /* { 3396 syscallarg(sparc32_timexp_t) tp; 3397 } */ *uap = v; 3398 struct sparc32_timex ntv32; 3399 struct timex ntv; 3400 int error = 0; 3401 int modes; 3402 int s; 3403 extern long time_freq; /* frequency offset (scaled ppm) */ 3404 extern long time_maxerror; 3405 extern long time_esterror; 3406 extern int time_state; /* clock state */ 3407 extern int time_status; /* clock status bits */ 3408 extern long time_constant; /* pll time constant */ 3409 extern long time_offset; /* time offset (us) */ 3410 extern long time_tolerance; /* frequency tolerance (scaled ppm) */ 3411 extern long time_precision; /* clock precision (us) */ 3412 3413 if ((error = copyin((caddr_t)(u_long)SCARG(uap, tp), (caddr_t)&ntv32, 3414 sizeof(ntv32)))) 3415 return (error); 3416 sparc32_to_timex(&ntv32, &ntv); 3417 3418 /* 3419 * Update selected clock variables - only the superuser can 3420 * change anything. Note that there is no error checking here on 3421 * the assumption the superuser should know what it is doing. 3422 */ 3423 modes = ntv.modes; 3424 if (modes != 0 && (error = suser(p->p_ucred, &p->p_acflag))) 3425 return (error); 3426 3427 s = splclock(); 3428 if (modes & MOD_FREQUENCY) 3429 #ifdef PPS_SYNC 3430 time_freq = ntv.freq - pps_freq; 3431 #else /* PPS_SYNC */ 3432 time_freq = ntv.freq; 3433 #endif /* PPS_SYNC */ 3434 if (modes & MOD_MAXERROR) 3435 time_maxerror = ntv.maxerror; 3436 if (modes & MOD_ESTERROR) 3437 time_esterror = ntv.esterror; 3438 if (modes & MOD_STATUS) { 3439 time_status &= STA_RONLY; 3440 time_status |= ntv.status & ~STA_RONLY; 3441 } 3442 if (modes & MOD_TIMECONST) 3443 time_constant = ntv.constant; 3444 if (modes & MOD_OFFSET) 3445 hardupdate(ntv.offset); 3446 3447 /* 3448 * Retrieve all clock variables 3449 */ 3450 if (time_offset < 0) 3451 ntv.offset = -(-time_offset >> SHIFT_UPDATE); 3452 else 3453 ntv.offset = time_offset >> SHIFT_UPDATE; 3454 #ifdef PPS_SYNC 3455 ntv.freq = time_freq + pps_freq; 3456 #else /* PPS_SYNC */ 3457 ntv.freq = time_freq; 3458 #endif /* PPS_SYNC */ 3459 ntv.maxerror = time_maxerror; 3460 ntv.esterror = time_esterror; 3461 ntv.status = time_status; 3462 ntv.constant = time_constant; 3463 ntv.precision = time_precision; 3464 ntv.tolerance = time_tolerance; 3465 #ifdef PPS_SYNC 3466 ntv.shift = pps_shift; 3467 ntv.ppsfreq = pps_freq; 3468 ntv.jitter = pps_jitter >> PPS_AVG; 3469 ntv.stabil = pps_stabil; 3470 ntv.calcnt = pps_calcnt; 3471 ntv.errcnt = pps_errcnt; 3472 ntv.jitcnt = pps_jitcnt; 3473 ntv.stbcnt = pps_stbcnt; 3474 #endif /* PPS_SYNC */ 3475 (void)splx(s); 3476 3477 sparc32_from_timeval(&ntv, &ntv32); 3478 error = copyout((caddr_t)&ntv32, (caddr_t)SCARG(uap, tp), sizeof(ntv32)); 3479 if (!error) { 3480 3481 /* 3482 * Status word error decode. See comments in 3483 * ntp_gettime() routine. 3484 */ 3485 if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) || 3486 (time_status & (STA_PPSFREQ | STA_PPSTIME) && 3487 !(time_status & STA_PPSSIGNAL)) || 3488 (time_status & STA_PPSTIME && 3489 time_status & STA_PPSJITTER) || 3490 (time_status & STA_PPSFREQ && 3491 time_status & (STA_PPSWANDER | STA_PPSERROR))) 3492 *retval = TIME_ERROR; 3493 else 3494 *retval = (register_t)time_state; 3495 } 3496 return error; 3497 } 3498 #endif 3499 3500 int 3501 compat_sparc32_setgid(p, v, retval) 3502 struct proc *p; 3503 void *v; 3504 register_t *retval; 3505 { 3506 struct compat_sparc32_setgid_args /* { 3507 syscallarg(gid_t) gid; 3508 } */ *uap = v; 3509 struct sys_setgid_args ua; 3510 3511 SPARC32TO64_UAP(gid); 3512 return (sys_setgid(p, v, retval)); 3513 } 3514 3515 int 3516 compat_sparc32_setegid(p, v, retval) 3517 struct proc *p; 3518 void *v; 3519 register_t *retval; 3520 { 3521 struct compat_sparc32_setegid_args /* { 3522 syscallarg(gid_t) egid; 3523 } */ *uap = v; 3524 struct sys_setegid_args ua; 3525 3526 SPARC32TO64_UAP(egid); 3527 return (sys_setegid(p, v, retval)); 3528 } 3529 3530 int 3531 compat_sparc32_seteuid(p, v, retval) 3532 struct proc *p; 3533 void *v; 3534 register_t *retval; 3535 { 3536 struct compat_sparc32_seteuid_args /* { 3537 syscallarg(gid_t) euid; 3538 } */ *uap = v; 3539 struct sys_seteuid_args ua; 3540 3541 SPARC32TO64_UAP(euid); 3542 return (sys_seteuid(p, v, retval)); 3543 } 3544 3545 #ifdef LFS 3546 int 3547 compat_sparc32_lfs_bmapv(p, v, retval) 3548 struct proc *p; 3549 void *v; 3550 register_t *retval; 3551 { 3552 #if 0 3553 struct compat_sparc32_lfs_bmapv_args /* { 3554 syscallarg(sparc32_fsid_tp_t) fsidp; 3555 syscallarg(sparc32_block_infop_t) blkiov; 3556 syscallarg(int) blkcnt; 3557 } */ *uap = v; 3558 struct sys_lfs_bmapv_args ua; 3559 3560 SPARC32TOP_UAP(fdidp, struct fsid); 3561 SPARC32TO64_UAP(blkcnt); 3562 /* XXX finish me */ 3563 #else 3564 3565 return (ENOSYS); /* XXX */ 3566 #endif 3567 } 3568 3569 int 3570 compat_sparc32_lfs_markv(p, v, retval) 3571 struct proc *p; 3572 void *v; 3573 register_t *retval; 3574 { 3575 struct compat_sparc32_lfs_markv_args /* { 3576 syscallarg(sparc32_fsid_tp_t) fsidp; 3577 syscallarg(sparc32_block_infop_t) blkiov; 3578 syscallarg(int) blkcnt; 3579 } */ *uap = v; 3580 3581 return (ENOSYS); /* XXX */ 3582 } 3583 3584 int 3585 compat_sparc32_lfs_segclean(p, v, retval) 3586 struct proc *p; 3587 void *v; 3588 register_t *retval; 3589 { 3590 struct compat_sparc32_lfs_segclean_args /* { 3591 syscallarg(sparc32_fsid_tp_t) fsidp; 3592 syscallarg(sparc32_u_long) segment; 3593 } */ *uap = v; 3594 return (ENOSYS); /* XXX */ 3595 } 3596 3597 int 3598 compat_sparc32_lfs_segwait(p, v, retval) 3599 struct proc *p; 3600 void *v; 3601 register_t *retval; 3602 { 3603 struct compat_sparc32_lfs_segwait_args /* { 3604 syscallarg(sparc32_fsid_tp_t) fsidp; 3605 syscallarg(sparc32_timevalp_t) tv; 3606 } */ *uap = v; 3607 return (ENOSYS); /* XXX */ 3608 } 3609 #endif 3610 3611 int 3612 compat_sparc32_pathconf(p, v, retval) 3613 struct proc *p; 3614 void *v; 3615 register_t *retval; 3616 { 3617 struct compat_sparc32_pathconf_args /* { 3618 syscallarg(int) fd; 3619 syscallarg(int) name; 3620 } */ *uap = v; 3621 struct sys_pathconf_args ua; 3622 long rt; 3623 int error; 3624 3625 SPARC32TOP_UAP(path, const char); 3626 SPARC32TO64_UAP(name); 3627 error = sys_pathconf(p, &ua, (register_t *)&rt); 3628 *(sparc32_long *)retval = (sparc32_long)rt; 3629 return (error); 3630 } 3631 3632 int 3633 compat_sparc32_fpathconf(p, v, retval) 3634 struct proc *p; 3635 void *v; 3636 register_t *retval; 3637 { 3638 struct compat_sparc32_fpathconf_args /* { 3639 syscallarg(int) fd; 3640 syscallarg(int) name; 3641 } */ *uap = v; 3642 struct sys_fpathconf_args ua; 3643 long rt; 3644 int error; 3645 3646 SPARC32TO64_UAP(fd); 3647 SPARC32TO64_UAP(name); 3648 error = sys_fpathconf(p, &ua, (register_t *)&rt); 3649 *(sparc32_long *)retval = (sparc32_long)rt; 3650 return (error); 3651 } 3652 3653 int 3654 compat_sparc32_getrlimit(p, v, retval) 3655 struct proc *p; 3656 void *v; 3657 register_t *retval; 3658 { 3659 struct compat_sparc32_getrlimit_args /* { 3660 syscallarg(int) which; 3661 syscallarg(sparc32_rlimitp_t) rlp; 3662 } */ *uap = v; 3663 int which = SCARG(uap, which); 3664 3665 if ((u_int)which >= RLIM_NLIMITS) 3666 return (EINVAL); 3667 return (copyout(&p->p_rlimit[which], (caddr_t)(u_long)SCARG(uap, rlp), 3668 sizeof(struct rlimit))); 3669 } 3670 3671 int 3672 compat_sparc32_setrlimit(p, v, retval) 3673 struct proc *p; 3674 void *v; 3675 register_t *retval; 3676 { 3677 struct compat_sparc32_setrlimit_args /* { 3678 syscallarg(int) which; 3679 syscallarg(const sparc32_rlimitp_t) rlp; 3680 } */ *uap = v; 3681 int which = SCARG(uap, which); 3682 struct rlimit alim; 3683 int error; 3684 3685 error = copyin((caddr_t)(u_long)SCARG(uap, rlp), &alim, sizeof(struct rlimit)); 3686 if (error) 3687 return (error); 3688 return (dosetrlimit(p, which, &alim)); 3689 } 3690 3691 int 3692 compat_sparc32_mmap(p, v, retval) 3693 struct proc *p; 3694 void *v; 3695 register_t *retval; 3696 { 3697 struct compat_sparc32_mmap_args /* { 3698 syscallarg(sparc32_voidp) addr; 3699 syscallarg(sparc32_size_t) len; 3700 syscallarg(int) prot; 3701 syscallarg(int) flags; 3702 syscallarg(int) fd; 3703 syscallarg(sparc32_long) pad; 3704 syscallarg(off_t) pos; 3705 } */ *uap = v; 3706 struct sys_mmap_args ua; 3707 void *rt; 3708 int error; 3709 3710 SPARC32TOP_UAP(addr, void); 3711 SPARC32TOX_UAP(len, size_t); 3712 SPARC32TO64_UAP(prot); 3713 SPARC32TO64_UAP(flags); 3714 SPARC32TO64_UAP(fd); 3715 SPARC32TOX_UAP(pad, long); 3716 SPARC32TOX_UAP(pos, off_t); 3717 error = sys_mmap(p, &ua, (register_t *)&rt); 3718 if ((long)rt > (long)UINT_MAX) 3719 printf("compat_sparc32_mmap: retval out of range: 0x%qx", 3720 rt); 3721 *retval = (sparc32_voidp)(u_long)rt; 3722 return (error); 3723 } 3724 3725 int 3726 compat_sparc32_lseek(p, v, retval) 3727 struct proc *p; 3728 void *v; 3729 register_t *retval; 3730 { 3731 struct compat_sparc32_lseek_args /* { 3732 syscallarg(int) fd; 3733 syscallarg(int) pad; 3734 syscallarg(off_t) offset; 3735 syscallarg(int) whence; 3736 } */ *uap = v; 3737 struct sys_lseek_args ua; 3738 3739 SPARC32TO64_UAP(fd); 3740 SPARC32TO64_UAP(pad); 3741 SPARC32TO64_UAP(offset); 3742 SPARC32TO64_UAP(whence); 3743 return (sys_lseek(p, &ua, retval)); 3744 } 3745 3746 int 3747 compat_sparc32_truncate(p, v, retval) 3748 struct proc *p; 3749 void *v; 3750 register_t *retval; 3751 { 3752 struct compat_sparc32_truncate_args /* { 3753 syscallarg(const sparc32_charp) path; 3754 syscallarg(int) pad; 3755 syscallarg(off_t) length; 3756 } */ *uap = v; 3757 struct sys_truncate_args ua; 3758 3759 SPARC32TOP_UAP(path, const char); 3760 SPARC32TO64_UAP(pad); 3761 SPARC32TO64_UAP(length); 3762 return (sys_truncate(p, &ua, retval)); 3763 } 3764 3765 int 3766 compat_sparc32_ftruncate(p, v, retval) 3767 struct proc *p; 3768 void *v; 3769 register_t *retval; 3770 { 3771 struct compat_sparc32_ftruncate_args /* { 3772 syscallarg(int) fd; 3773 syscallarg(int) pad; 3774 syscallarg(off_t) length; 3775 } */ *uap = v; 3776 struct sys_ftruncate_args ua; 3777 3778 SPARC32TO64_UAP(fd); 3779 SPARC32TO64_UAP(pad); 3780 SPARC32TO64_UAP(length); 3781 return (sys_ftruncate(p, &ua, retval)); 3782 } 3783 3784 int 3785 compat_sparc32___sysctl(p, v, retval) 3786 struct proc *p; 3787 void *v; 3788 register_t *retval; 3789 { 3790 struct compat_sparc32___sysctl_args /* { 3791 syscallarg(sparc32_intp) name; 3792 syscallarg(u_int) namelen; 3793 syscallarg(sparc32_voidp) old; 3794 syscallarg(sparc32_size_tp) oldlenp; 3795 syscallarg(sparc32_voidp) new; 3796 syscallarg(sparc32_size_t) newlen; 3797 } */ *uap = v; 3798 int error, dolock = 1; 3799 sparc32_size_t savelen = 0; 3800 size_t oldlen = 0; 3801 sysctlfn *fn; 3802 int name[CTL_MAXNAME]; 3803 3804 /* 3805 * Some of these sysctl functions do their own copyin/copyout. 3806 * We need to disable or emulate the ones that need their 3807 * arguments converted. 3808 */ 3809 3810 if (SCARG(uap, new) != NULL && 3811 (error = suser(p->p_ucred, &p->p_acflag))) 3812 return (error); 3813 /* 3814 * all top-level sysctl names are non-terminal 3815 */ 3816 if (SCARG(uap, namelen) > CTL_MAXNAME || SCARG(uap, namelen) < 2) 3817 return (EINVAL); 3818 error = copyin((caddr_t)(u_long)SCARG(uap, name), &name, 3819 SCARG(uap, namelen) * sizeof(int)); 3820 if (error) 3821 return (error); 3822 3823 switch (name[0]) { 3824 case CTL_KERN: 3825 fn = kern_sysctl; 3826 if (name[2] != KERN_VNODE) /* XXX */ 3827 dolock = 0; 3828 break; 3829 case CTL_HW: 3830 fn = hw_sysctl; 3831 break; 3832 case CTL_VM: 3833 #if defined(UVM) 3834 fn = uvm_sysctl; 3835 #else 3836 fn = vm_sysctl; 3837 #endif 3838 break; 3839 case CTL_NET: 3840 fn = net_sysctl; 3841 break; 3842 case CTL_VFS: 3843 fn = vfs_sysctl; 3844 break; 3845 case CTL_MACHDEP: 3846 fn = cpu_sysctl; 3847 break; 3848 #ifdef DEBUG 3849 case CTL_DEBUG: 3850 fn = debug_sysctl; 3851 break; 3852 #endif 3853 #ifdef DDB 3854 case CTL_DDB: 3855 fn = ddb_sysctl; 3856 break; 3857 #endif 3858 default: 3859 return (EOPNOTSUPP); 3860 } 3861 3862 if (SCARG(uap, oldlenp) && 3863 (error = copyin((caddr_t)(u_long)SCARG(uap, oldlenp), &savelen, sizeof(savelen)))) 3864 return (error); 3865 if (SCARG(uap, old) != NULL) { 3866 #if defined(UVM) 3867 if (!uvm_useracc((caddr_t)(u_long)SCARG(uap, old), savelen, B_WRITE)) 3868 #else 3869 if (!useracc(SCARG(uap, old), savelen, B_WRITE)) 3870 #endif 3871 return (EFAULT); 3872 #if 0 /* XXXXXXXX */ 3873 while (memlock.sl_lock) { 3874 memlock.sl_want = 1; 3875 sleep((caddr_t)&memlock, PRIBIO+1); 3876 memlock.sl_locked++; 3877 } 3878 memlock.sl_lock = 1; 3879 #endif /* XXXXXXXX */ 3880 if (dolock) 3881 #if defined(UVM) 3882 uvm_vslock(p, SCARG(uap, old), savelen); 3883 #else 3884 vslock(p, SCARG(uap, old), savelen); 3885 #endif 3886 oldlen = savelen; 3887 } 3888 error = (*fn)(name + 1, SCARG(uap, namelen) - 1, SCARG(uap, old), 3889 &oldlen, SCARG(uap, new), SCARG(uap, newlen), p); 3890 if (SCARG(uap, old) != NULL) { 3891 if (dolock) 3892 #if defined(UVM) 3893 uvm_vsunlock(p, SCARG(uap, old), savelen); 3894 #else 3895 vsunlock(p, SCARG(uap, old), savelen); 3896 #endif 3897 #if 0 /* XXXXXXXXXXX */ 3898 memlock.sl_lock = 0; 3899 if (memlock.sl_want) { 3900 memlock.sl_want = 0; 3901 wakeup((caddr_t)&memlock); 3902 } 3903 #endif /* XXXXXXXXX */ 3904 } 3905 savelen = oldlen; 3906 if (error) 3907 return (error); 3908 if (SCARG(uap, oldlenp)) 3909 error = copyout(&savelen, (caddr_t)(u_long)SCARG(uap, oldlenp), sizeof(savelen)); 3910 return (error); 3911 } 3912 3913 int 3914 compat_sparc32_mlock(p, v, retval) 3915 struct proc *p; 3916 void *v; 3917 register_t *retval; 3918 { 3919 struct compat_sparc32_mlock_args /* { 3920 syscallarg(const sparc32_voidp) addr; 3921 syscallarg(sparc32_size_t) len; 3922 } */ *uap = v; 3923 struct sys_mlock_args ua; 3924 3925 SPARC32TOP_UAP(addr, const void); 3926 SPARC32TO64_UAP(len); 3927 return (sys_mlock(p, &ua, retval)); 3928 } 3929 3930 int 3931 compat_sparc32_munlock(p, v, retval) 3932 struct proc *p; 3933 void *v; 3934 register_t *retval; 3935 { 3936 struct compat_sparc32_munlock_args /* { 3937 syscallarg(const sparc32_voidp) addr; 3938 syscallarg(sparc32_size_t) len; 3939 } */ *uap = v; 3940 struct sys_munlock_args ua; 3941 3942 SPARC32TOP_UAP(addr, const void); 3943 SPARC32TO64_UAP(len); 3944 return (sys_munlock(p, &ua, retval)); 3945 } 3946 3947 int 3948 compat_sparc32_undelete(p, v, retval) 3949 struct proc *p; 3950 void *v; 3951 register_t *retval; 3952 { 3953 struct compat_sparc32_undelete_args /* { 3954 syscallarg(const sparc32_charp) path; 3955 } */ *uap = v; 3956 struct sys_undelete_args ua; 3957 3958 SPARC32TOP_UAP(path, const char); 3959 return (sys_undelete(p, &ua, retval)); 3960 } 3961 3962 int 3963 compat_sparc32_futimes(p, v, retval) 3964 struct proc *p; 3965 void *v; 3966 register_t *retval; 3967 { 3968 struct compat_sparc32_futimes_args /* { 3969 syscallarg(int) fd; 3970 syscallarg(const sparc32_timevalp_t) tptr; 3971 } */ *uap = v; 3972 int error; 3973 struct file *fp; 3974 3975 if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) 3976 return (error); 3977 3978 return (change_utimes32((struct vnode *)fp->f_data, 3979 (struct timeval *)(u_long)SCARG(uap, tptr), p)); 3980 } 3981 3982 int 3983 compat_sparc32_getpgid(p, v, retval) 3984 struct proc *p; 3985 void *v; 3986 register_t *retval; 3987 { 3988 struct compat_sparc32_getpgid_args /* { 3989 syscallarg(pid_t) pid; 3990 } */ *uap = v; 3991 struct sys_getpgid_args ua; 3992 3993 SPARC32TO64_UAP(pid); 3994 return (sys_getpgid(p, &ua, retval)); 3995 } 3996 3997 int 3998 compat_sparc32_reboot(p, v, retval) 3999 struct proc *p; 4000 void *v; 4001 register_t *retval; 4002 { 4003 struct compat_sparc32_reboot_args /* { 4004 syscallarg(int) opt; 4005 syscallarg(sparc32_charp) bootstr; 4006 } */ *uap = v; 4007 struct sys_reboot_args ua; 4008 4009 SPARC32TO64_UAP(opt); 4010 SPARC32TOP_UAP(bootstr, char); 4011 return (sys_reboot(p, &ua, retval)); 4012 } 4013 4014 int 4015 compat_sparc32_poll(p, v, retval) 4016 struct proc *p; 4017 void *v; 4018 register_t *retval; 4019 { 4020 struct compat_sparc32_poll_args /* { 4021 syscallarg(sparc32_pollfdp_t) fds; 4022 syscallarg(u_int) nfds; 4023 syscallarg(int) timeout; 4024 } */ *uap = v; 4025 struct sys_poll_args ua; 4026 4027 SPARC32TOP_UAP(fds, struct pollfd); 4028 SPARC32TO64_UAP(nfds); 4029 SPARC32TO64_UAP(timeout); 4030 return (sys_poll(p, &ua, retval)); 4031 } 4032 4033 /* 4034 * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 4035 * 4036 * This is BSD. We won't support System V IPC. 4037 * Too much work. 4038 * 4039 * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 4040 */ 4041 int 4042 compat_sparc32___semctl(p, v, retval) 4043 struct proc *p; 4044 void *v; 4045 register_t *retval; 4046 { 4047 #if 0 4048 struct compat_sparc32___semctl_args /* { 4049 syscallarg(int) semid; 4050 syscallarg(int) semnum; 4051 syscallarg(int) cmd; 4052 syscallarg(sparc32_semunu_t) arg; 4053 } */ *uap = v; 4054 union sparc32_semun sem32; 4055 int semid = SCARG(uap, semid); 4056 int semnum = SCARG(uap, semnum); 4057 int cmd = SCARG(uap, cmd); 4058 union sparc32_semun *arg = (void*)(u_long)SCARG(uap, arg); 4059 union sparc32_semun real_arg; 4060 struct ucred *cred = p->p_ucred; 4061 int i, rval, eval; 4062 struct sparc32_semid_ds sbuf; 4063 register struct semid_ds *semaptr; 4064 4065 semlock(p); 4066 4067 semid = IPCID_TO_IX(semid); 4068 if (semid < 0 || semid >= seminfo.semmsl) 4069 return(EINVAL); 4070 4071 semaptr = &sema[semid]; 4072 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || 4073 semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) 4074 return(EINVAL); 4075 4076 eval = 0; 4077 rval = 0; 4078 4079 switch (cmd) { 4080 case IPC_RMID: 4081 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_M)) != 0) 4082 return(eval); 4083 semaptr->sem_perm.cuid = cred->cr_uid; 4084 semaptr->sem_perm.uid = cred->cr_uid; 4085 semtot -= semaptr->sem_nsems; 4086 for (i = semaptr->sem_base - sem; i < semtot; i++) 4087 sem[i] = sem[i + semaptr->sem_nsems]; 4088 for (i = 0; i < seminfo.semmni; i++) { 4089 if ((sema[i].sem_perm.mode & SEM_ALLOC) && 4090 sema[i].sem_base > semaptr->sem_base) 4091 sema[i].sem_base -= semaptr->sem_nsems; 4092 } 4093 semaptr->sem_perm.mode = 0; 4094 semundo_clear(semid, -1); 4095 wakeup((caddr_t)semaptr); 4096 break; 4097 4098 case IPC_SET: 4099 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_M))) 4100 return(eval); 4101 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 4102 return(eval); 4103 if ((eval = copyin((caddr_t)(u_long)real_arg.buf, (caddr_t)&sbuf, 4104 sizeof(sbuf))) != 0) 4105 return(eval); 4106 semaptr->sem_perm.uid = sbuf.sem_perm.uid; 4107 semaptr->sem_perm.gid = sbuf.sem_perm.gid; 4108 semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) | 4109 (sbuf.sem_perm.mode & 0777); 4110 semaptr->sem_ctime = time.tv_sec; 4111 break; 4112 4113 case IPC_STAT: 4114 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 4115 return(eval); 4116 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 4117 return(eval); 4118 eval = copyout((caddr_t)semaptr, (caddr_t)(u_long)real_arg.buf, 4119 sizeof(struct semid_ds)); 4120 break; 4121 4122 case GETNCNT: 4123 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 4124 return(eval); 4125 if (semnum < 0 || semnum >= semaptr->sem_nsems) 4126 return(EINVAL); 4127 rval = semaptr->sem_base[semnum].semncnt; 4128 break; 4129 4130 case GETPID: 4131 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 4132 return(eval); 4133 if (semnum < 0 || semnum >= semaptr->sem_nsems) 4134 return(EINVAL); 4135 rval = semaptr->sem_base[semnum].sempid; 4136 break; 4137 4138 case GETVAL: 4139 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 4140 return(eval); 4141 if (semnum < 0 || semnum >= semaptr->sem_nsems) 4142 return(EINVAL); 4143 rval = semaptr->sem_base[semnum].semval; 4144 break; 4145 4146 case GETALL: 4147 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 4148 return(eval); 4149 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 4150 return(eval); 4151 for (i = 0; i < semaptr->sem_nsems; i++) { 4152 eval = copyout((caddr_t)&semaptr->sem_base[i].semval, 4153 &real_arg.array[i], sizeof(real_arg.array[0])); 4154 if (eval != 0) 4155 break; 4156 } 4157 break; 4158 4159 case GETZCNT: 4160 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 4161 return(eval); 4162 if (semnum < 0 || semnum >= semaptr->sem_nsems) 4163 return(EINVAL); 4164 rval = semaptr->sem_base[semnum].semzcnt; 4165 break; 4166 4167 case SETVAL: 4168 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) 4169 return(eval); 4170 if (semnum < 0 || semnum >= semaptr->sem_nsems) 4171 return(EINVAL); 4172 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 4173 return(eval); 4174 semaptr->sem_base[semnum].semval = real_arg.val; 4175 semundo_clear(semid, semnum); 4176 wakeup((caddr_t)semaptr); 4177 break; 4178 4179 case SETALL: 4180 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) 4181 return(eval); 4182 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 4183 return(eval); 4184 for (i = 0; i < semaptr->sem_nsems; i++) { 4185 eval = copyin(&real_arg.array[i], 4186 (caddr_t)&semaptr->sem_base[i].semval, 4187 sizeof(real_arg.array[0])); 4188 if (eval != 0) 4189 break; 4190 } 4191 semundo_clear(semid, -1); 4192 wakeup((caddr_t)semaptr); 4193 break; 4194 4195 default: 4196 return(EINVAL); 4197 } 4198 4199 if (eval == 0) 4200 *retval = rval; 4201 return(eval); 4202 #else 4203 return (ENOSYS); 4204 #endif 4205 } 4206 4207 int 4208 compat_sparc32_semget(p, v, retval) 4209 struct proc *p; 4210 void *v; 4211 register_t *retval; 4212 { 4213 struct compat_sparc32_semget_args /* { 4214 syscallarg(sparc32_key_t) key; 4215 syscallarg(int) nsems; 4216 syscallarg(int) semflg; 4217 } */ *uap = v; 4218 struct sys_semget_args ua; 4219 4220 SPARC32TOX_UAP(key, key_t); 4221 SPARC32TO64_UAP(nsems); 4222 SPARC32TO64_UAP(semflg); 4223 return (sys_semget(p, &ua, retval)); 4224 } 4225 4226 int 4227 compat_sparc32_semop(p, v, retval) 4228 struct proc *p; 4229 void *v; 4230 register_t *retval; 4231 { 4232 struct compat_sparc32_semop_args /* { 4233 syscallarg(int) semid; 4234 syscallarg(sparc32_sembufp_t) sops; 4235 syscallarg(sparc32_size_t) nsops; 4236 } */ *uap = v; 4237 struct sys_semop_args ua; 4238 4239 SPARC32TO64_UAP(semid); 4240 SPARC32TOP_UAP(sops, struct sembuf); 4241 SPARC32TOX_UAP(nsops, size_t); 4242 return (sys_semop(p, &ua, retval)); 4243 } 4244 4245 int 4246 compat_sparc32_semconfig(p, v, retval) 4247 struct proc *p; 4248 void *v; 4249 register_t *retval; 4250 { 4251 struct compat_sparc32_semconfig_args /* { 4252 syscallarg(int) flag; 4253 } */ *uap = v; 4254 struct sys_semconfig_args ua; 4255 4256 SPARC32TO64_UAP(flag); 4257 return (sys_semconfig(p, &ua, retval)); 4258 } 4259 4260 int 4261 compat_sparc32_msgctl(p, v, retval) 4262 struct proc *p; 4263 void *v; 4264 register_t *retval; 4265 { 4266 #if 0 4267 struct compat_sparc32_msgctl_args /* { 4268 syscallarg(int) msqid; 4269 syscallarg(int) cmd; 4270 syscallarg(sparc32_msqid_dsp_t) buf; 4271 } */ *uap = v; 4272 struct sys_msgctl_args ua; 4273 struct msqid_ds ds; 4274 struct sparc32_msqid_ds *ds32p; 4275 int error; 4276 4277 SPARC32TO64_UAP(msqid); 4278 SPARC32TO64_UAP(cmd); 4279 ds32p = (struct sparc32_msqid_ds *)(u_long)SCARG(uap, buf); 4280 if (ds32p) { 4281 SCARG(&ua, buf) = NULL; 4282 sparc32_to_msqid_ds(ds32p, &ds); 4283 } else 4284 SCARG(&ua, buf) = NULL; 4285 error = sys_msgctl(p, &ua, retval); 4286 if (error) 4287 return (error); 4288 4289 if (ds32p) 4290 sparc32_from_msqid_ds(&ds, ds32p); 4291 return (0); 4292 #else 4293 return (ENOSYS); 4294 #endif 4295 } 4296 4297 int 4298 compat_sparc32_msgget(p, v, retval) 4299 struct proc *p; 4300 void *v; 4301 register_t *retval; 4302 { 4303 #if 0 4304 struct compat_sparc32_msgget_args /* { 4305 syscallarg(sparc32_key_t) key; 4306 syscallarg(int) msgflg; 4307 } */ *uap = v; 4308 struct sys_msgget_args ua; 4309 4310 SPARC32TOX_UAP(key, key_t); 4311 SPARC32TO64_UAP(msgflg); 4312 return (sys_msgget(p, &ua, retval)); 4313 #else 4314 return (ENOSYS); 4315 #endif 4316 } 4317 4318 int 4319 compat_sparc32_msgsnd(p, v, retval) 4320 struct proc *p; 4321 void *v; 4322 register_t *retval; 4323 { 4324 #if 0 4325 struct compat_sparc32_msgsnd_args /* { 4326 syscallarg(int) msqid; 4327 syscallarg(const sparc32_voidp) msgp; 4328 syscallarg(sparc32_size_t) msgsz; 4329 syscallarg(int) msgflg; 4330 } */ *uap = v; 4331 struct sys_msgsnd_args ua; 4332 4333 SPARC32TO64_UAP(msqid); 4334 SPARC32TOP_UAP(msgp, void); 4335 SPARC32TOX_UAP(msgsz, size_t); 4336 SPARC32TO64_UAP(msgflg); 4337 return (sys_msgsnd(p, &ua, retval)); 4338 #else 4339 return (ENOSYS); 4340 #endif 4341 } 4342 4343 int 4344 compat_sparc32_msgrcv(p, v, retval) 4345 struct proc *p; 4346 void *v; 4347 register_t *retval; 4348 { 4349 #if 0 4350 struct compat_sparc32_msgrcv_args /* { 4351 syscallarg(int) msqid; 4352 syscallarg(sparc32_voidp) msgp; 4353 syscallarg(sparc32_size_t) msgsz; 4354 syscallarg(sparc32_long) msgtyp; 4355 syscallarg(int) msgflg; 4356 } */ *uap = v; 4357 struct sys_msgrcv_args ua; 4358 ssize_t rt; 4359 int error; 4360 4361 SPARC32TO64_UAP(msqid); 4362 SPARC32TOP_UAP(msgp, void); 4363 SPARC32TOX_UAP(msgsz, size_t); 4364 SPARC32TOX_UAP(msgtyp, long); 4365 SPARC32TO64_UAP(msgflg); 4366 error = sys_msgrcv(p, &ua, (register_t *)&rt); 4367 *(sparc32_ssize_t *)retval = rt; 4368 return (error); 4369 #else 4370 return (ENOSYS); 4371 #endif 4372 } 4373 4374 int 4375 compat_sparc32_shmat(p, v, retval) 4376 struct proc *p; 4377 void *v; 4378 register_t *retval; 4379 { 4380 #if 0 4381 struct compat_sparc32_shmat_args /* { 4382 syscallarg(int) shmid; 4383 syscallarg(const sparc32_voidp) shmaddr; 4384 syscallarg(int) shmflg; 4385 } */ *uap = v; 4386 struct sys_shmat_args ua; 4387 void *rt; 4388 int error; 4389 4390 SPARC32TO64_UAP(shmid); 4391 SPARC32TOP_UAP(shmaddr, void); 4392 SPARC32TO64_UAP(shmflg); 4393 error = sys_shmat(p, &ua, (register_t *)&rt); 4394 *retval = (sparc32_voidp)(u_long)rt; 4395 return (error); 4396 #else 4397 return (ENOSYS); 4398 #endif 4399 } 4400 4401 int 4402 compat_sparc32_shmctl(p, v, retval) 4403 struct proc *p; 4404 void *v; 4405 register_t *retval; 4406 { 4407 #if 0 4408 struct compat_sparc32_shmctl_args /* { 4409 syscallarg(int) shmid; 4410 syscallarg(int) cmd; 4411 syscallarg(sparc32_shmid_dsp_t) buf; 4412 } */ *uap = v; 4413 struct sys_shmctl_args ua; 4414 struct shmid_ds ds; 4415 struct sparc32_shmid_ds *ds32p; 4416 int error; 4417 4418 SPARC32TO64_UAP(shmid); 4419 SPARC32TO64_UAP(cmd); 4420 ds32p = (struct sparc32_shmid_ds *)(u_long)SCARG(uap, buf); 4421 if (ds32p) { 4422 SCARG(&ua, buf) = NULL; 4423 sparc32_to_shmid_ds(ds32p, &ds); 4424 } else 4425 SCARG(&ua, buf) = NULL; 4426 error = sys_shmctl(p, &ua, retval); 4427 if (error) 4428 return (error); 4429 4430 if (ds32p) 4431 sparc32_from_shmid_ds(&ds, ds32p); 4432 return (0); 4433 #else 4434 return (ENOSYS); 4435 #endif 4436 } 4437 4438 int 4439 compat_sparc32_shmdt(p, v, retval) 4440 struct proc *p; 4441 void *v; 4442 register_t *retval; 4443 { 4444 #if 0 4445 struct compat_sparc32_shmdt_args /* { 4446 syscallarg(const sparc32_voidp) shmaddr; 4447 } */ *uap = v; 4448 struct sys_shmdt_args ua; 4449 4450 SPARC32TOP_UAP(shmaddr, const char); 4451 return (sys_shmdt(p, &ua, retval)); 4452 #else 4453 return (ENOSYS); 4454 #endif 4455 } 4456 4457 int 4458 compat_sparc32_shmget(p, v, retval) 4459 struct proc *p; 4460 void *v; 4461 register_t *retval; 4462 { 4463 #if 0 4464 struct compat_sparc32_shmget_args /* { 4465 syscallarg(sparc32_key_t) key; 4466 syscallarg(sparc32_size_t) size; 4467 syscallarg(int) shmflg; 4468 } */ *uap = v; 4469 struct sys_shmget_args ua; 4470 4471 SPARC32TOX_UAP(key, key_t) 4472 SPARC32TOX_UAP(size, size_t) 4473 SPARC32TO64_UAP(shmflg); 4474 return (sys_shmget(p, &ua, retval)); 4475 #else 4476 return (ENOSYS); 4477 #endif 4478 } 4479 4480 int 4481 compat_sparc32_clock_gettime(p, v, retval) 4482 struct proc *p; 4483 void *v; 4484 register_t *retval; 4485 { 4486 struct compat_sparc32_clock_gettime_args /* { 4487 syscallarg(sparc32_clockid_t) clock_id; 4488 syscallarg(sparc32_timespecp_t) tp; 4489 } */ *uap = v; 4490 clockid_t clock_id; 4491 struct timeval atv; 4492 struct timespec ats; 4493 struct sparc32_timespec ts32; 4494 4495 clock_id = SCARG(uap, clock_id); 4496 if (clock_id != CLOCK_REALTIME) 4497 return (EINVAL); 4498 4499 microtime(&atv); 4500 TIMEVAL_TO_TIMESPEC(&atv,&ats); 4501 sparc32_from_timespec(&ats, &ts32); 4502 4503 return copyout(&ts32, (caddr_t)(u_long)SCARG(uap, tp), sizeof(ts32)); 4504 } 4505 4506 int 4507 compat_sparc32_clock_settime(p, v, retval) 4508 struct proc *p; 4509 void *v; 4510 register_t *retval; 4511 { 4512 struct compat_sparc32_clock_settime_args /* { 4513 syscallarg(sparc32_clockid_t) clock_id; 4514 syscallarg(const sparc32_timespecp_t) tp; 4515 } */ *uap = v; 4516 struct sparc32_timespec ts32; 4517 clockid_t clock_id; 4518 struct timeval atv; 4519 struct timespec ats; 4520 int error; 4521 4522 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 4523 return (error); 4524 4525 clock_id = SCARG(uap, clock_id); 4526 if (clock_id != CLOCK_REALTIME) 4527 return (EINVAL); 4528 4529 if ((error = copyin((caddr_t)(u_long)SCARG(uap, tp), &ts32, sizeof(ts32))) != 0) 4530 return (error); 4531 4532 sparc32_to_timespec(&ts32, &ats); 4533 TIMESPEC_TO_TIMEVAL(&atv,&ats); 4534 if ((error = settime(&atv))) 4535 return (error); 4536 4537 return 0; 4538 } 4539 4540 int 4541 compat_sparc32_clock_getres(p, v, retval) 4542 struct proc *p; 4543 void *v; 4544 register_t *retval; 4545 { 4546 struct compat_sparc32_clock_getres_args /* { 4547 syscallarg(sparc32_clockid_t) clock_id; 4548 syscallarg(sparc32_timespecp_t) tp; 4549 } */ *uap = v; 4550 struct sparc32_timespec ts32; 4551 clockid_t clock_id; 4552 struct timespec ts; 4553 int error = 0; 4554 4555 clock_id = SCARG(uap, clock_id); 4556 if (clock_id != CLOCK_REALTIME) 4557 return (EINVAL); 4558 4559 if (SCARG(uap, tp)) { 4560 ts.tv_sec = 0; 4561 ts.tv_nsec = 1000000000 / hz; 4562 4563 sparc32_from_timespec(&ts, &ts32); 4564 error = copyout(&ts, (caddr_t)(u_long)SCARG(uap, tp), sizeof(ts)); 4565 } 4566 4567 return error; 4568 } 4569 4570 int 4571 compat_sparc32_nanosleep(p, v, retval) 4572 struct proc *p; 4573 void *v; 4574 register_t *retval; 4575 { 4576 struct compat_sparc32_nanosleep_args /* { 4577 syscallarg(const sparc32_timespecp_t) rqtp; 4578 syscallarg(sparc32_timespecp_t) rmtp; 4579 } */ *uap = v; 4580 static int nanowait; 4581 struct sparc32_timespec ts32; 4582 struct timespec rqt; 4583 struct timespec rmt; 4584 struct timeval atv, utv; 4585 int error, s, timo; 4586 4587 error = copyin((caddr_t)(u_long)SCARG(uap, rqtp), (caddr_t)&ts32, 4588 sizeof(ts32)); 4589 if (error) 4590 return (error); 4591 4592 sparc32_to_timespec(&ts32, &rqt); 4593 TIMESPEC_TO_TIMEVAL(&atv,&rqt) 4594 if (itimerfix(&atv)) 4595 return (EINVAL); 4596 4597 s = splclock(); 4598 timeradd(&atv,&time,&atv); 4599 timo = hzto(&atv); 4600 /* 4601 * Avoid inadvertantly sleeping forever 4602 */ 4603 if (timo == 0) 4604 timo = 1; 4605 splx(s); 4606 4607 error = tsleep(&nanowait, PWAIT | PCATCH, "nanosleep", timo); 4608 if (error == ERESTART) 4609 error = EINTR; 4610 if (error == EWOULDBLOCK) 4611 error = 0; 4612 4613 if (SCARG(uap, rmtp)) { 4614 int error; 4615 4616 s = splclock(); 4617 utv = time; 4618 splx(s); 4619 4620 timersub(&atv, &utv, &utv); 4621 if (utv.tv_sec < 0) 4622 timerclear(&utv); 4623 4624 TIMEVAL_TO_TIMESPEC(&utv,&rmt); 4625 sparc32_from_timespec(&rmt, &ts32); 4626 error = copyout((caddr_t)&ts32, (caddr_t)(u_long)SCARG(uap,rmtp), 4627 sizeof(ts32)); 4628 if (error) 4629 return (error); 4630 } 4631 4632 return error; 4633 } 4634 4635 int 4636 compat_sparc32_fdatasync(p, v, retval) 4637 struct proc *p; 4638 void *v; 4639 register_t *retval; 4640 { 4641 struct compat_sparc32_fdatasync_args /* { 4642 syscallarg(int) fd; 4643 } */ *uap = v; 4644 struct sys_fdatasync_args ua; 4645 4646 SPARC32TO64_UAP(fd); 4647 4648 return (sys_fdatasync(p, &ua, retval)); 4649 } 4650 4651 int 4652 compat_sparc32___posix_rename(p, v, retval) 4653 struct proc *p; 4654 void *v; 4655 register_t *retval; 4656 { 4657 struct compat_sparc32___posix_rename_args /* { 4658 syscallarg(const sparc32_charp) from; 4659 syscallarg(const sparc32_charp) to; 4660 } */ *uap = v; 4661 struct sys___posix_rename_args ua; 4662 4663 SPARC32TOP_UAP(from, const char *); 4664 SPARC32TOP_UAP(to, const char *); 4665 4666 return (sys___posix_rename(p, &ua, retval)); 4667 } 4668 4669 int 4670 compat_sparc32_swapctl(p, v, retval) 4671 struct proc *p; 4672 void *v; 4673 register_t *retval; 4674 { 4675 struct compat_sparc32_swapctl_args /* { 4676 syscallarg(int) cmd; 4677 syscallarg(const sparc32_voidp) arg; 4678 syscallarg(int) misc; 4679 } */ *uap = v; 4680 struct sys_swapctl_args ua; 4681 4682 SPARC32TO64_UAP(cmd); 4683 SPARC32TOP_UAP(arg, const void); 4684 SPARC32TO64_UAP(misc); 4685 return (sys_swapctl(p, &ua, retval)); 4686 } 4687 4688 int 4689 compat_sparc32_getdents(p, v, retval) 4690 struct proc *p; 4691 void *v; 4692 register_t *retval; 4693 { 4694 struct compat_sparc32_getdents_args /* { 4695 syscallarg(int) fd; 4696 syscallarg(sparc32_charp) buf; 4697 syscallarg(sparc32_size_t) count; 4698 } */ *uap = v; 4699 struct file *fp; 4700 int error, done; 4701 4702 if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) 4703 return (error); 4704 if ((fp->f_flag & FREAD) == 0) 4705 return (EBADF); 4706 error = vn_readdir(fp, (caddr_t)(u_long)SCARG(uap, buf), UIO_USERSPACE, 4707 SCARG(uap, count), &done, p, 0, 0); 4708 *retval = done; 4709 return (error); 4710 } 4711 4712 4713 int 4714 compat_sparc32_minherit(p, v, retval) 4715 struct proc *p; 4716 void *v; 4717 register_t *retval; 4718 { 4719 struct compat_sparc32_minherit_args /* { 4720 syscallarg(sparc32_voidp) addr; 4721 syscallarg(sparc32_size_t) len; 4722 syscallarg(int) inherit; 4723 } */ *uap = v; 4724 struct sys_minherit_args ua; 4725 4726 SPARC32TOP_UAP(addr, void); 4727 SPARC32TOX_UAP(len, size_t); 4728 SPARC32TO64_UAP(inherit); 4729 return (sys_minherit(p, &ua, retval)); 4730 } 4731 4732 int 4733 compat_sparc32_lchmod(p, v, retval) 4734 struct proc *p; 4735 void *v; 4736 register_t *retval; 4737 { 4738 struct compat_sparc32_lchmod_args /* { 4739 syscallarg(const sparc32_charp) path; 4740 syscallarg(mode_t) mode; 4741 } */ *uap = v; 4742 struct sys_lchmod_args ua; 4743 4744 SPARC32TOP_UAP(path, const char); 4745 SPARC32TO64_UAP(mode); 4746 return (sys_lchmod(p, &ua, retval)); 4747 } 4748 4749 int 4750 compat_sparc32_lchown(p, v, retval) 4751 struct proc *p; 4752 void *v; 4753 register_t *retval; 4754 { 4755 struct compat_sparc32_lchown_args /* { 4756 syscallarg(const sparc32_charp) path; 4757 syscallarg(uid_t) uid; 4758 syscallarg(gid_t) gid; 4759 } */ *uap = v; 4760 struct sys_lchown_args ua; 4761 4762 SPARC32TOP_UAP(path, const char); 4763 SPARC32TO64_UAP(uid); 4764 SPARC32TO64_UAP(gid); 4765 return (sys_lchown(p, &ua, retval)); 4766 } 4767 4768 int 4769 compat_sparc32_lutimes(p, v, retval) 4770 struct proc *p; 4771 void *v; 4772 register_t *retval; 4773 { 4774 struct compat_sparc32_lutimes_args /* { 4775 syscallarg(const sparc32_charp) path; 4776 syscallarg(const sparc32_timevalp_t) tptr; 4777 } */ *uap = v; 4778 int error; 4779 struct nameidata nd; 4780 4781 NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, (caddr_t)(u_long)SCARG(uap, path), p); 4782 if ((error = namei(&nd)) != 0) 4783 return (error); 4784 4785 error = change_utimes32(nd.ni_vp, (struct timeval *)(u_long)SCARG(uap, tptr), p); 4786 4787 vrele(nd.ni_vp); 4788 return (error); 4789 } 4790 4791 4792 int 4793 compat_sparc32___msync13(p, v, retval) 4794 struct proc *p; 4795 void *v; 4796 register_t *retval; 4797 { 4798 struct compat_sparc32___msync13_args /* { 4799 syscallarg(sparc32_voidp) addr; 4800 syscallarg(sparc32_size_t) len; 4801 syscallarg(int) flags; 4802 } */ *uap = v; 4803 struct sys___msync13_args ua; 4804 4805 SPARC32TOP_UAP(addr, void); 4806 SPARC32TOX_UAP(len, size_t); 4807 SPARC32TO64_UAP(flags); 4808 return (sys___msync13(p, &ua, retval)); 4809 } 4810 4811 int 4812 compat_sparc32___stat13(p, v, retval) 4813 struct proc *p; 4814 void *v; 4815 register_t *retval; 4816 { 4817 struct compat_sparc32___stat13_args /* { 4818 syscallarg(const sparc32_charp) path; 4819 syscallarg(sparc32_statp_t) ub; 4820 } */ *uap = v; 4821 struct sparc32_stat sb32; 4822 struct stat sb; 4823 int error; 4824 struct nameidata nd; 4825 4826 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, 4827 (caddr_t)(u_long)SCARG(uap, path), p); 4828 if ((error = namei(&nd)) != 0) 4829 return (error); 4830 error = vn_stat(nd.ni_vp, &sb, p); 4831 vput(nd.ni_vp); 4832 if (error) 4833 return (error); 4834 sparc32_from___stat13(&sb, &sb32); 4835 error = copyout(&sb32, (caddr_t)(u_long)SCARG(uap, ub), sizeof(sb32)); 4836 return (error); 4837 } 4838 4839 int 4840 compat_sparc32___fstat13(p, v, retval) 4841 struct proc *p; 4842 void *v; 4843 register_t *retval; 4844 { 4845 struct compat_sparc32___fstat13_args /* { 4846 syscallarg(int) fd; 4847 syscallarg(sparc32_statp_t) sb; 4848 } */ *uap = v; 4849 int fd = SCARG(uap, fd); 4850 register struct filedesc *fdp = p->p_fd; 4851 register struct file *fp; 4852 struct sparc32_stat sb32; 4853 struct stat ub; 4854 int error = 0; 4855 4856 if ((u_int)fd >= fdp->fd_nfiles || 4857 (fp = fdp->fd_ofiles[fd]) == NULL) 4858 return (EBADF); 4859 switch (fp->f_type) { 4860 4861 case DTYPE_VNODE: 4862 error = vn_stat((struct vnode *)fp->f_data, &ub, p); 4863 break; 4864 4865 case DTYPE_SOCKET: 4866 error = soo_stat((struct socket *)fp->f_data, &ub); 4867 break; 4868 4869 default: 4870 panic("fstat"); 4871 /*NOTREACHED*/ 4872 } 4873 if (error == 0) { 4874 sparc32_from___stat13(&ub, &sb32); 4875 error = copyout(&sb32, (caddr_t)(u_long)SCARG(uap, sb), sizeof(sb32)); 4876 } 4877 return (error); 4878 } 4879 4880 int 4881 compat_sparc32___lstat13(p, v, retval) 4882 struct proc *p; 4883 void *v; 4884 register_t *retval; 4885 { 4886 struct compat_sparc32___lstat13_args /* { 4887 syscallarg(const sparc32_charp) path; 4888 syscallarg(sparc32_statp_t) ub; 4889 } */ *uap = v; 4890 struct sparc32_stat sb32; 4891 struct stat sb; 4892 int error; 4893 struct nameidata nd; 4894 4895 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, 4896 (caddr_t)(u_long)SCARG(uap, path), p); 4897 if ((error = namei(&nd)) != 0) 4898 return (error); 4899 error = vn_stat(nd.ni_vp, &sb, p); 4900 vput(nd.ni_vp); 4901 if (error) 4902 return (error); 4903 sparc32_from___stat13(&sb, &sb32); 4904 error = copyout(&sb32, (caddr_t)(u_long)SCARG(uap, ub), sizeof(sb32)); 4905 return (error); 4906 } 4907 4908 int 4909 compat_sparc32___sigaltstack14(p, v, retval) 4910 struct proc *p; 4911 void *v; 4912 register_t *retval; 4913 { 4914 struct compat_sparc32___sigaltstack14_args /* { 4915 syscallarg(const sparc32_sigaltstackp_t) nss; 4916 syscallarg(sparc32_sigaltstackp_t) oss; 4917 } */ *uap = v; 4918 struct sparc32_sigaltstack s32; 4919 struct sigaltstack nss, oss; 4920 int error; 4921 4922 if (SCARG(uap, nss)) { 4923 error = copyin((caddr_t)(u_long)SCARG(uap, nss), &s32, sizeof(s32)); 4924 if (error) 4925 return (error); 4926 nss.ss_sp = (void *)(u_long)s32.ss_sp; 4927 nss.ss_size = (size_t)s32.ss_size; 4928 nss.ss_flags = s32.ss_flags; 4929 } 4930 error = sigaltstack1(p, 4931 SCARG(uap, nss) ? &nss : 0, SCARG(uap, oss) ? &oss : 0); 4932 if (error) 4933 return (error); 4934 if (SCARG(uap, oss)) { 4935 s32.ss_sp = (sparc32_voidp)(u_long)oss.ss_sp; 4936 s32.ss_size = (sparc32_size_t)oss.ss_size; 4937 s32.ss_flags = oss.ss_flags; 4938 error = copyout(&s32, (caddr_t)(u_long)SCARG(uap, oss), sizeof(s32)); 4939 if (error) 4940 return (error); 4941 } 4942 return (0); 4943 } 4944 4945 int 4946 compat_sparc32___posix_chown(p, v, retval) 4947 struct proc *p; 4948 void *v; 4949 register_t *retval; 4950 { 4951 struct compat_sparc32___posix_chown_args /* { 4952 syscallarg(const sparc32_charp) path; 4953 syscallarg(uid_t) uid; 4954 syscallarg(gid_t) gid; 4955 } */ *uap = v; 4956 struct sys___posix_chown_args ua; 4957 4958 SPARC32TOP_UAP(path, const char); 4959 SPARC32TO64_UAP(uid); 4960 SPARC32TO64_UAP(gid); 4961 return (sys___posix_chown(p, &ua, retval)); 4962 } 4963 4964 int 4965 compat_sparc32___posix_fchown(p, v, retval) 4966 struct proc *p; 4967 void *v; 4968 register_t *retval; 4969 { 4970 struct compat_sparc32___posix_fchown_args /* { 4971 syscallarg(int) fd; 4972 syscallarg(uid_t) uid; 4973 syscallarg(gid_t) gid; 4974 } */ *uap = v; 4975 struct sys___posix_fchown_args ua; 4976 4977 SPARC32TO64_UAP(fd); 4978 SPARC32TO64_UAP(uid); 4979 SPARC32TO64_UAP(gid); 4980 return (sys___posix_fchown(p, &ua, retval)); 4981 } 4982 4983 int 4984 compat_sparc32___posix_lchown(p, v, retval) 4985 struct proc *p; 4986 void *v; 4987 register_t *retval; 4988 { 4989 struct compat_sparc32___posix_lchown_args /* { 4990 syscallarg(const sparc32_charp) path; 4991 syscallarg(uid_t) uid; 4992 syscallarg(gid_t) gid; 4993 } */ *uap = v; 4994 struct sys___posix_lchown_args ua; 4995 4996 SPARC32TOP_UAP(path, const char); 4997 SPARC32TO64_UAP(uid); 4998 SPARC32TO64_UAP(gid); 4999 return (sys___posix_lchown(p, &ua, retval)); 5000 } 5001 5002 int 5003 compat_sparc32_getsid(p, v, retval) 5004 struct proc *p; 5005 void *v; 5006 register_t *retval; 5007 { 5008 struct compat_sparc32_getsid_args /* { 5009 syscallarg(pid_t) pid; 5010 } */ *uap = v; 5011 struct sys_getsid_args ua; 5012 5013 SPARC32TO64_UAP(pid); 5014 return (sys_getsid(p, &ua, retval)); 5015 } 5016 5017 int 5018 compat_sparc32_fktrace(p, v, retval) 5019 struct proc *p; 5020 void *v; 5021 register_t *retval; 5022 { 5023 struct compat_sparc32_fktrace_args /* { 5024 syscallarg(const int) fd; 5025 syscallarg(int) ops; 5026 syscallarg(int) facs; 5027 syscallarg(int) pid; 5028 } */ *uap = v; 5029 struct sys_fktrace_args ua; 5030 5031 SPARC32TO64_UAP(fd); 5032 SPARC32TO64_UAP(ops); 5033 SPARC32TO64_UAP(facs); 5034 SPARC32TO64_UAP(pid); 5035 return (sys_fktrace(p, &ua, retval)); 5036 } 5037 5038 int 5039 compat_sparc32_preadv(p, v, retval) 5040 struct proc *p; 5041 void *v; 5042 register_t *retval; 5043 { 5044 struct compat_sparc32_preadv_args /* { 5045 syscallarg(int) fd; 5046 syscallarg(const sparc32_iovecp_t) iovp; 5047 syscallarg(int) iovcnt; 5048 syscallarg(int) pad; 5049 syscallarg(off_t) offset; 5050 } */ *uap = v; 5051 struct filedesc *fdp = p->p_fd; 5052 struct file *fp; 5053 struct vnode *vp; 5054 off_t offset; 5055 int error, fd = SCARG(uap, fd); 5056 5057 if ((u_int)fd >= fdp->fd_nfiles || 5058 (fp = fdp->fd_ofiles[fd]) == NULL || 5059 (fp->f_flag & FREAD) == 0) 5060 return (EBADF); 5061 5062 vp = (struct vnode *)fp->f_data; 5063 if (fp->f_type != DTYPE_VNODE 5064 || vp->v_type == VFIFO) 5065 return (ESPIPE); 5066 5067 offset = SCARG(uap, offset); 5068 5069 /* 5070 * XXX This works because no file systems actually 5071 * XXX take any action on the seek operation. 5072 */ 5073 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0) 5074 return (error); 5075 5076 return (dofilereadv32(p, fd, fp, (struct sparc32_iovec *)(u_long)SCARG(uap, iovp), SCARG(uap, iovcnt), 5077 &offset, 0, retval)); 5078 } 5079 5080 int 5081 compat_sparc32_pwritev(p, v, retval) 5082 struct proc *p; 5083 void *v; 5084 register_t *retval; 5085 { 5086 struct compat_sparc32_pwritev_args /* { 5087 syscallarg(int) fd; 5088 syscallarg(const sparc32_iovecp_t) iovp; 5089 syscallarg(int) iovcnt; 5090 syscallarg(int) pad; 5091 syscallarg(off_t) offset; 5092 } */ *uap = v; 5093 struct filedesc *fdp = p->p_fd; 5094 struct file *fp; 5095 struct vnode *vp; 5096 off_t offset; 5097 int error, fd = SCARG(uap, fd); 5098 5099 if ((u_int)fd >= fdp->fd_nfiles || 5100 (fp = fdp->fd_ofiles[fd]) == NULL || 5101 (fp->f_flag & FWRITE) == 0) 5102 return (EBADF); 5103 5104 vp = (struct vnode *)fp->f_data; 5105 if (fp->f_type != DTYPE_VNODE 5106 || vp->v_type == VFIFO) 5107 return (ESPIPE); 5108 5109 offset = SCARG(uap, offset); 5110 5111 /* 5112 * XXX This works because no file systems actually 5113 * XXX take any action on the seek operation. 5114 */ 5115 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0) 5116 return (error); 5117 5118 return (dofilewritev32(p, fd, fp, (struct sparc32_iovec *)(u_long)SCARG(uap, iovp), SCARG(uap, iovcnt), 5119 &offset, 0, retval)); 5120 } 5121 5122 5123 5124 int 5125 compat_13_compat_sparc32_sigprocmask(p, v, retval) 5126 register struct proc *p; 5127 void *v; 5128 register_t *retval; 5129 { 5130 struct compat_13_compat_sparc32_sigprocmask_args /* { 5131 syscallarg(int) how; 5132 syscallarg(int) mask; 5133 } */ *uap = v; 5134 sigset13_t ness, oess; 5135 sigset_t nbss, obss; 5136 int error; 5137 5138 ness = SCARG(uap, mask); 5139 native_sigset13_to_sigset(&ness, &nbss); 5140 error = sigprocmask1(p, SCARG(uap, how), &nbss, &obss); 5141 if (error) 5142 return (error); 5143 native_sigset_to_sigset13(&obss, &oess); 5144 *retval = oess; 5145 return (0); 5146 } 5147 5148 5149 int 5150 compat_13_compat_sparc32_sigsuspend(p, v, retval) 5151 register struct proc *p; 5152 void *v; 5153 register_t *retval; 5154 { 5155 struct compat_13_compat_sparc32_sigsuspend_args /* { 5156 syscallarg(sigset13_t) mask; 5157 } */ *uap = v; 5158 sigset13_t ess; 5159 sigset_t bss; 5160 5161 ess = SCARG(uap, mask); 5162 native_sigset13_to_sigset(&ess, &bss); 5163 return (sigsuspend1(p, &bss)); 5164 } 5165
Indexes created Sun Sep 21 20:09:37 GMT 2025