netbsd32_compat_50.c revision 1.20
1 /* $NetBSD: netbsd32_compat_50.c,v 1.20 2011/11/18 03:34:13 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Christos Zoulas. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: netbsd32_compat_50.c,v 1.20 2011/11/18 03:34:13 christos Exp $"); 40 41 #if defined(_KERNEL_OPT) 42 #include "opt_sysv.h" 43 #endif 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/mount.h> 48 #include <sys/socket.h> 49 #include <sys/socketvar.h> 50 #include <sys/stat.h> 51 #include <sys/time.h> 52 #include <sys/ktrace.h> 53 #include <sys/eventvar.h> 54 #include <sys/resourcevar.h> 55 #include <sys/vnode.h> 56 #include <sys/file.h> 57 #include <sys/filedesc.h> 58 #include <sys/poll.h> 59 #include <sys/namei.h> 60 #include <sys/statvfs.h> 61 #include <sys/syscallargs.h> 62 #include <sys/proc.h> 63 #include <sys/dirent.h> 64 #include <sys/kauth.h> 65 #include <sys/vfs_syscalls.h> 66 #include <sys/ipc.h> 67 #include <sys/msg.h> 68 #include <sys/sem.h> 69 #include <sys/shm.h> 70 71 #include <compat/netbsd32/netbsd32.h> 72 #include <compat/netbsd32/netbsd32_syscallargs.h> 73 #include <compat/netbsd32/netbsd32_conv.h> 74 #include <compat/sys/mount.h> 75 #include <compat/sys/time.h> 76 77 78 /* 79 * Common routine to set access and modification times given a vnode. 80 */ 81 static int 82 get_utimes32(const netbsd32_timeval50p_t *tptr, struct timeval *tv, 83 struct timeval **tvp) 84 { 85 int error; 86 struct netbsd32_timeval50 tv32[2]; 87 88 if (tptr == NULL) { 89 *tvp = NULL; 90 return 0; 91 } 92 93 error = copyin(tptr, tv32, sizeof(tv32)); 94 if (error) 95 return error; 96 netbsd32_to_timeval50(&tv32[0], &tv[0]); 97 netbsd32_to_timeval50(&tv32[1], &tv[1]); 98 99 *tvp = tv; 100 return 0; 101 } 102 103 int 104 compat_50_netbsd32_mknod(struct lwp *l, 105 const struct compat_50_netbsd32_mknod_args *uap, register_t *retval) 106 { 107 /* { 108 syscallarg(netbsd32_charp) path; 109 syscallarg(mode_t) mode; 110 syscallarg(uint32_t) dev; 111 } */ 112 return do_sys_mknod(l, SCARG_P32(uap, path), SCARG(uap, mode), 113 SCARG(uap, dev), retval, UIO_USERSPACE); 114 } 115 116 int 117 compat_50_netbsd32_select(struct lwp *l, 118 const struct compat_50_netbsd32_select_args *uap, register_t *retval) 119 { 120 /* { 121 syscallarg(int) nd; 122 syscallarg(netbsd32_fd_setp_t) in; 123 syscallarg(netbsd32_fd_setp_t) ou; 124 syscallarg(netbsd32_fd_setp_t) ex; 125 syscallarg(netbsd32_timeval50p_t) tv; 126 } */ 127 int error; 128 struct netbsd32_timeval50 tv32; 129 struct timespec ats, *ts = NULL; 130 131 if (SCARG_P32(uap, tv)) { 132 error = copyin(SCARG_P32(uap, tv), &tv32, sizeof(tv32)); 133 if (error != 0) 134 return error; 135 ats.tv_sec = tv32.tv_sec; 136 ats.tv_nsec = tv32.tv_usec * 1000; 137 ts = &ats; 138 } 139 140 return selcommon(retval, SCARG(uap, nd), SCARG_P32(uap, in), 141 SCARG_P32(uap, ou), SCARG_P32(uap, ex), ts, NULL); 142 return 0; 143 } 144 145 int 146 compat_50_netbsd32_gettimeofday(struct lwp *l, 147 const struct compat_50_netbsd32_gettimeofday_args *uap, register_t *retval) 148 { 149 /* { 150 syscallarg(netbsd32_timeval50p_t) tp; 151 syscallarg(netbsd32_timezonep_t) tzp; 152 } */ 153 struct timeval atv; 154 struct netbsd32_timeval50 tv32; 155 int error = 0; 156 struct netbsd32_timezone tzfake; 157 158 if (SCARG_P32(uap, tp)) { 159 microtime(&atv); 160 netbsd32_from_timeval50(&atv, &tv32); 161 error = copyout(&tv32, SCARG_P32(uap, tp), sizeof(tv32)); 162 if (error) 163 return error; 164 } 165 if (SCARG_P32(uap, tzp)) { 166 /* 167 * NetBSD has no kernel notion of time zone, so we just 168 * fake up a timezone struct and return it if demanded. 169 */ 170 tzfake.tz_minuteswest = 0; 171 tzfake.tz_dsttime = 0; 172 error = copyout(&tzfake, SCARG_P32(uap, tzp), sizeof(tzfake)); 173 } 174 return error; 175 } 176 177 int 178 compat_50_netbsd32_settimeofday(struct lwp *l, 179 const struct compat_50_netbsd32_settimeofday_args *uap, register_t *retval) 180 { 181 /* { 182 syscallarg(const netbsd32_timeval50p_t) tv; 183 syscallarg(const netbsd32_timezonep_t) tzp; 184 } */ 185 struct netbsd32_timeval50 atv32; 186 struct timeval atv; 187 struct timespec ats; 188 int error; 189 struct proc *p = l->l_proc; 190 191 /* Verify all parameters before changing time. */ 192 193 /* 194 * NetBSD has no kernel notion of time zone, and only an 195 * obsolete program would try to set it, so we log a warning. 196 */ 197 if (SCARG_P32(uap, tzp)) 198 printf("pid %d attempted to set the " 199 "(obsolete) kernel time zone\n", p->p_pid); 200 201 if (SCARG_P32(uap, tv) == 0) 202 return 0; 203 204 if ((error = copyin(SCARG_P32(uap, tv), &atv32, sizeof(atv32))) != 0) 205 return error; 206 207 netbsd32_to_timeval50(&atv32, &atv); 208 TIMEVAL_TO_TIMESPEC(&atv, &ats); 209 return settime(p, &ats); 210 } 211 212 int 213 compat_50_netbsd32_utimes(struct lwp *l, 214 const struct compat_50_netbsd32_utimes_args *uap, register_t *retval) 215 { 216 /* { 217 syscallarg(const netbsd32_charp) path; 218 syscallarg(const netbsd32_timeval50p_t) tptr; 219 } */ 220 int error; 221 struct timeval tv[2], *tvp; 222 223 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 224 if (error != 0) 225 return error; 226 227 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), FOLLOW, 228 tvp, UIO_SYSSPACE); 229 } 230 231 int 232 compat_50_netbsd32_adjtime(struct lwp *l, 233 const struct compat_50_netbsd32_adjtime_args *uap, register_t *retval) 234 { 235 /* { 236 syscallarg(const netbsd32_timeval50p_t) delta; 237 syscallarg(netbsd32_timeval50p_t) olddelta; 238 } */ 239 struct netbsd32_timeval50 atv; 240 int error; 241 242 extern int time_adjusted; /* in kern_ntptime.c */ 243 extern int64_t time_adjtime; /* in kern_ntptime.c */ 244 245 if ((error = kauth_authorize_system(l->l_cred, 246 KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_ADJTIME, NULL, NULL, 247 NULL)) != 0) 248 return (error); 249 250 if (SCARG_P32(uap, olddelta)) { 251 atv.tv_sec = time_adjtime / 1000000; 252 atv.tv_usec = time_adjtime % 1000000; 253 if (atv.tv_usec < 0) { 254 atv.tv_usec += 1000000; 255 atv.tv_sec--; 256 } 257 (void) copyout(&atv, 258 SCARG_P32(uap, olddelta), 259 sizeof(atv)); 260 if (error) 261 return (error); 262 } 263 264 if (SCARG_P32(uap, delta)) { 265 error = copyin(SCARG_P32(uap, delta), &atv, 266 sizeof(struct timeval)); 267 if (error) 268 return (error); 269 270 time_adjtime = (int64_t)atv.tv_sec * 1000000 + atv.tv_usec; 271 272 if (time_adjtime) 273 /* We need to save the system time during shutdown */ 274 time_adjusted |= 1; 275 } 276 277 return 0; 278 } 279 280 int 281 compat_50_netbsd32_futimes(struct lwp *l, 282 const struct compat_50_netbsd32_futimes_args *uap, register_t *retval) 283 { 284 /* { 285 syscallarg(int) fd; 286 syscallarg(const netbsd32_timeval50p_t) tptr; 287 } */ 288 int error; 289 file_t *fp; 290 struct timeval tv[2], *tvp; 291 292 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 293 if (error != 0) 294 return error; 295 296 /* fd_getvnode() will use the descriptor for us */ 297 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 298 return error; 299 300 error = do_sys_utimes(l, fp->f_data, NULL, 0, tvp, UIO_SYSSPACE); 301 302 fd_putfile(SCARG(uap, fd)); 303 return error; 304 } 305 306 int 307 compat_50_netbsd32_clock_gettime(struct lwp *l, 308 const struct compat_50_netbsd32_clock_gettime_args *uap, register_t *retval) 309 { 310 /* { 311 syscallarg(netbsd32_clockid_t) clock_id; 312 syscallarg(netbsd32_timespec50p_t) tp; 313 } */ 314 int error; 315 struct timespec ats; 316 struct netbsd32_timespec50 ts32; 317 318 error = clock_gettime1(SCARG(uap, clock_id), &ats); 319 if (error != 0) 320 return error; 321 322 netbsd32_from_timespec50(&ats, &ts32); 323 return copyout(&ts32, SCARG_P32(uap, tp), sizeof(ts32)); 324 } 325 326 int 327 compat_50_netbsd32_clock_settime(struct lwp *l, 328 const struct compat_50_netbsd32_clock_settime_args *uap, register_t *retval) 329 { 330 /* { 331 syscallarg(netbsd32_clockid_t) clock_id; 332 syscallarg(const netbsd32_timespec50p_t) tp; 333 } */ 334 struct netbsd32_timespec50 ts32; 335 struct timespec ats; 336 int error; 337 338 if ((error = copyin(SCARG_P32(uap, tp), &ts32, sizeof(ts32))) != 0) 339 return (error); 340 341 netbsd32_to_timespec50(&ts32, &ats); 342 return clock_settime1(l->l_proc, SCARG(uap, clock_id), &ats, true); 343 } 344 345 int 346 compat_50_netbsd32_clock_getres(struct lwp *l, 347 const struct compat_50_netbsd32_clock_getres_args *uap, register_t *retval) 348 { 349 /* { 350 syscallarg(netbsd32_clockid_t) clock_id; 351 syscallarg(netbsd32_timespec50p_t) tp; 352 } */ 353 struct netbsd32_timespec50 ts32; 354 struct timespec ts; 355 int error = 0; 356 357 error = clock_getres1(SCARG(uap, clock_id), &ts); 358 if (error != 0) 359 return error; 360 361 if (SCARG_P32(uap, tp)) { 362 netbsd32_from_timespec50(&ts, &ts32); 363 error = copyout(&ts32, SCARG_P32(uap, tp), sizeof(ts32)); 364 } 365 366 return error; 367 } 368 369 int 370 compat_50_netbsd32_timer_settime(struct lwp *l, 371 const struct compat_50_netbsd32_timer_settime_args *uap, register_t *retval) 372 { 373 /* { 374 syscallarg(netbsd32_timer_t) timerid; 375 syscallarg(int) flags; 376 syscallarg(const netbsd32_itimerspec50p_t) value; 377 syscallarg(netbsd32_itimerspec50p_t) ovalue; 378 } */ 379 int error; 380 struct itimerspec value, ovalue, *ovp = NULL; 381 struct netbsd32_itimerspec50 its32; 382 383 if ((error = copyin(SCARG_P32(uap, value), &its32, sizeof(its32))) != 0) 384 return (error); 385 netbsd32_to_timespec50(&its32.it_interval, &value.it_interval); 386 netbsd32_to_timespec50(&its32.it_value, &value.it_value); 387 388 if (SCARG_P32(uap, ovalue)) 389 ovp = &ovalue; 390 391 if ((error = dotimer_settime(SCARG(uap, timerid), &value, ovp, 392 SCARG(uap, flags), l->l_proc)) != 0) 393 return error; 394 395 if (ovp) { 396 netbsd32_from_timespec50(&ovp->it_interval, &its32.it_interval); 397 netbsd32_from_timespec50(&ovp->it_value, &its32.it_value); 398 return copyout(&its32, SCARG_P32(uap, ovalue), sizeof(its32)); 399 } 400 return 0; 401 } 402 403 int 404 compat_50_netbsd32_timer_gettime(struct lwp *l, const struct compat_50_netbsd32_timer_gettime_args *uap, register_t *retval) 405 { 406 /* { 407 syscallarg(netbsd32_timer_t) timerid; 408 syscallarg(netbsd32_itimerspec50p_t) value; 409 } */ 410 int error; 411 struct itimerspec its; 412 struct netbsd32_itimerspec50 its32; 413 414 if ((error = dotimer_gettime(SCARG(uap, timerid), l->l_proc, 415 &its)) != 0) 416 return error; 417 418 netbsd32_from_timespec50(&its.it_interval, &its32.it_interval); 419 netbsd32_from_timespec50(&its.it_value, &its32.it_value); 420 421 return copyout(&its32, SCARG_P32(uap, value), sizeof(its32)); 422 } 423 424 int 425 compat_50_netbsd32_nanosleep(struct lwp *l, 426 const struct compat_50_netbsd32_nanosleep_args *uap, register_t *retval) 427 { 428 /* { 429 syscallarg(const netbsd32_timespec50p_t) rqtp; 430 syscallarg(netbsd32_timespecp_t) rmtp; 431 } */ 432 struct netbsd32_timespec50 ts32; 433 struct timespec rqt, rmt; 434 int error, error1; 435 436 error = copyin(SCARG_P32(uap, rqtp), &ts32, sizeof(ts32)); 437 if (error) 438 return (error); 439 netbsd32_to_timespec50(&ts32, &rqt); 440 441 error = nanosleep1(l, &rqt, SCARG_P32(uap, rmtp) ? &rmt : NULL); 442 if (SCARG_P32(uap, rmtp) == NULL || (error != 0 && error != EINTR)) 443 return error; 444 445 netbsd32_from_timespec50(&rmt, &ts32); 446 error1 = copyout(&ts32, SCARG_P32(uap,rmtp), sizeof(ts32)); 447 return error1 ? error1 : error; 448 } 449 450 static int 451 compat_50_netbsd32_sigtimedwait_put_info(const void *src, void *dst, size_t size) 452 { 453 const siginfo_t *info = src; 454 siginfo32_t info32; 455 456 netbsd32_si_to_si32(&info32, info); 457 458 return copyout(&info32, dst, sizeof(info32)); 459 } 460 461 static int 462 compat_50_netbsd32_sigtimedwait_fetch_timeout(const void *src, void *dst, size_t size) 463 { 464 struct timespec *ts = dst; 465 struct netbsd32_timespec50 ts32; 466 int error; 467 468 error = copyin(src, &ts32, sizeof(ts32)); 469 if (error) 470 return error; 471 472 netbsd32_to_timespec50(&ts32, ts); 473 return 0; 474 } 475 476 static int 477 compat_50_netbsd32_sigtimedwait_put_timeout(const void *src, void *dst, size_t size) 478 { 479 const struct timespec *ts = src; 480 struct netbsd32_timespec50 ts32; 481 482 netbsd32_from_timespec50(ts, &ts32); 483 484 return copyout(&ts32, dst, sizeof(ts32)); 485 } 486 487 int 488 compat_50_netbsd32___sigtimedwait(struct lwp *l, 489 const struct compat_50_netbsd32___sigtimedwait_args *uap, register_t *retval) 490 { 491 /* { 492 syscallarg(netbsd32_sigsetp_t) set; 493 syscallarg(netbsd32_siginfop_t) info; 494 syscallarg(netbsd32_timespec50p_t) timeout; 495 } */ 496 struct sys_____sigtimedwait50_args ua; 497 int res; 498 499 NETBSD32TOP_UAP(set, const sigset_t); 500 NETBSD32TOP_UAP(info, siginfo_t); 501 NETBSD32TOP_UAP(timeout, struct timespec); 502 503 res = sigtimedwait1(l, &ua, retval, 504 copyin, 505 compat_50_netbsd32_sigtimedwait_put_info, 506 compat_50_netbsd32_sigtimedwait_fetch_timeout, 507 compat_50_netbsd32_sigtimedwait_put_timeout); 508 if (!res) 509 *retval = 0; /* XXX NetBSD<=5 was not POSIX compliant */ 510 return res; 511 } 512 513 int 514 compat_50_netbsd32_lutimes(struct lwp *l, 515 const struct compat_50_netbsd32_lutimes_args *uap, register_t *retval) 516 { 517 /* { 518 syscallarg(const netbsd32_charp) path; 519 syscallarg(const netbsd32_timeval50p_t) tptr; 520 } */ 521 int error; 522 struct timeval tv[2], *tvp; 523 524 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 525 if (error != 0) 526 return error; 527 528 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), NOFOLLOW, 529 tvp, UIO_SYSSPACE); 530 } 531 532 int 533 compat_50_netbsd32__lwp_park(struct lwp *l, 534 const struct compat_50_netbsd32__lwp_park_args *uap, register_t *retval) 535 { 536 /* { 537 syscallarg(const netbsd32_timespec50p) ts; 538 syscallarg(lwpid_t) unpark; 539 syscallarg(netbsd32_voidp) hint; 540 syscallarg(netbsd32_voidp) unparkhint; 541 } */ 542 struct timespec ts, *tsp; 543 struct netbsd32_timespec50 ts32; 544 int error; 545 546 if (SCARG_P32(uap, ts) == NULL) 547 tsp = NULL; 548 else { 549 error = copyin(SCARG_P32(uap, ts), &ts32, sizeof ts32); 550 if (error != 0) 551 return error; 552 netbsd32_to_timespec50(&ts32, &ts); 553 tsp = &ts; 554 } 555 556 if (SCARG(uap, unpark) != 0) { 557 error = lwp_unpark(SCARG(uap, unpark), 558 SCARG_P32(uap, unparkhint)); 559 if (error != 0) 560 return error; 561 } 562 563 return lwp_park(tsp, SCARG_P32(uap, hint)); 564 return 0; 565 } 566 567 static int 568 netbsd32_kevent_fetch_timeout(const void *src, void *dest, size_t length) 569 { 570 struct netbsd32_timespec50 ts32; 571 int error; 572 573 KASSERT(length == sizeof(struct timespec50)); 574 575 error = copyin(src, &ts32, sizeof(ts32)); 576 if (error) 577 return error; 578 netbsd32_to_timespec50(&ts32, (struct timespec *)dest); 579 return 0; 580 } 581 582 static int 583 netbsd32_kevent_fetch_changes(void *private, const struct kevent *changelist, 584 struct kevent *changes, size_t index, int n) 585 { 586 const struct netbsd32_kevent *src = 587 (const struct netbsd32_kevent *)changelist; 588 struct netbsd32_kevent *kev32, *changes32 = private; 589 int error, i; 590 591 error = copyin(src + index, changes32, n * sizeof(*changes32)); 592 if (error) 593 return error; 594 for (i = 0, kev32 = changes32; i < n; i++, kev32++, changes++) 595 netbsd32_to_kevent(kev32, changes); 596 return 0; 597 } 598 599 static int 600 netbsd32_kevent_put_events(void *private, struct kevent *events, 601 struct kevent *eventlist, size_t index, int n) 602 { 603 struct netbsd32_kevent *kev32, *events32 = private; 604 int i; 605 606 for (i = 0, kev32 = events32; i < n; i++, kev32++, events++) 607 netbsd32_from_kevent(events, kev32); 608 kev32 = (struct netbsd32_kevent *)eventlist; 609 return copyout(events32, kev32, n * sizeof(*events32)); 610 } 611 612 int 613 compat_50_netbsd32_kevent(struct lwp *l, 614 const struct compat_50_netbsd32_kevent_args *uap, register_t *retval) 615 { 616 /* { 617 syscallarg(int) fd; 618 syscallarg(netbsd32_keventp_t) changelist; 619 syscallarg(netbsd32_size_t) nchanges; 620 syscallarg(netbsd32_keventp_t) eventlist; 621 syscallarg(netbsd32_size_t) nevents; 622 syscallarg(netbsd32_timespec50p_t) timeout; 623 } */ 624 int error; 625 size_t maxalloc, nchanges, nevents; 626 struct kevent_ops netbsd32_kevent_ops = { 627 .keo_fetch_timeout = netbsd32_kevent_fetch_timeout, 628 .keo_fetch_changes = netbsd32_kevent_fetch_changes, 629 .keo_put_events = netbsd32_kevent_put_events, 630 }; 631 632 nchanges = SCARG(uap, nchanges); 633 nevents = SCARG(uap, nevents); 634 maxalloc = MIN(KQ_NEVENTS, MAX(nchanges, nevents)); 635 netbsd32_kevent_ops.keo_private = 636 kmem_alloc(maxalloc * sizeof(struct netbsd32_kevent), KM_SLEEP); 637 638 error = kevent1(retval, SCARG(uap, fd), 639 NETBSD32PTR64(SCARG(uap, changelist)), nchanges, 640 NETBSD32PTR64(SCARG(uap, eventlist)), nevents, 641 NETBSD32PTR64(SCARG(uap, timeout)), &netbsd32_kevent_ops); 642 643 kmem_free(netbsd32_kevent_ops.keo_private, 644 maxalloc * sizeof(struct netbsd32_kevent)); 645 return error; 646 } 647 648 int 649 compat_50_netbsd32_pselect(struct lwp *l, 650 const struct compat_50_netbsd32_pselect_args *uap, register_t *retval) 651 { 652 /* { 653 syscallarg(int) nd; 654 syscallarg(netbsd32_fd_setp_t) in; 655 syscallarg(netbsd32_fd_setp_t) ou; 656 syscallarg(netbsd32_fd_setp_t) ex; 657 syscallarg(const netbsd32_timespec50p_t) ts; 658 syscallarg(const netbsd32_sigsetp_t) mask; 659 } */ 660 int error; 661 struct netbsd32_timespec50 ts32; 662 struct timespec ats, *ts = NULL; 663 sigset_t amask, *mask = NULL; 664 665 if (SCARG_P32(uap, ts)) { 666 error = copyin(SCARG_P32(uap, ts), &ts32, sizeof(ts32)); 667 if (error != 0) 668 return error; 669 netbsd32_to_timespec50(&ts32, &ats); 670 ts = &ats; 671 } 672 if (SCARG_P32(uap, mask)) { 673 error = copyin(SCARG_P32(uap, mask), &amask, sizeof(amask)); 674 if (error != 0) 675 return error; 676 mask = &amask; 677 } 678 679 return selcommon(retval, SCARG(uap, nd), SCARG_P32(uap, in), 680 SCARG_P32(uap, ou), SCARG_P32(uap, ex), ts, mask); 681 return 0; 682 } 683 684 int 685 compat_50_netbsd32_pollts(struct lwp *l, 686 const struct compat_50_netbsd32_pollts_args *uap, register_t *retval) 687 { 688 /* { 689 syscallarg(struct netbsd32_pollfdp_t) fds; 690 syscallarg(u_int) nfds; 691 syscallarg(const netbsd32_timespec50p_t) ts; 692 syscallarg(const netbsd32_sigsetp_t) mask; 693 } */ 694 int error; 695 struct netbsd32_timespec50 ts32; 696 struct timespec ats, *ts = NULL; 697 sigset_t amask, *mask = NULL; 698 699 if (SCARG_P32(uap, ts)) { 700 error = copyin(SCARG_P32(uap, ts), &ts32, sizeof(ts32)); 701 if (error != 0) 702 return error; 703 netbsd32_to_timespec50(&ts32, &ats); 704 ts = &ats; 705 } 706 if (NETBSD32PTR64( SCARG(uap, mask))) { 707 error = copyin(SCARG_P32(uap, mask), &amask, sizeof(amask)); 708 if (error != 0) 709 return error; 710 mask = &amask; 711 } 712 713 return pollcommon(retval, SCARG_P32(uap, fds), 714 SCARG(uap, nfds), ts, mask); 715 } 716 717 int 718 compat_50_netbsd32___stat30(struct lwp *l, 719 const struct compat_50_netbsd32___stat30_args *uap, register_t *retval) 720 { 721 /* { 722 syscallarg(const netbsd32_charp) path; 723 syscallarg(netbsd32_stat50p_t) ub; 724 } */ 725 struct netbsd32_stat50 sb32; 726 struct stat sb; 727 int error; 728 const char *path; 729 730 path = SCARG_P32(uap, path); 731 732 error = do_sys_stat(path, FOLLOW, &sb); 733 if (error) 734 return error; 735 netbsd32_from___stat50(&sb, &sb32); 736 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32)); 737 return error; 738 } 739 740 int 741 compat_50_netbsd32___fstat30(struct lwp *l, 742 const struct compat_50_netbsd32___fstat30_args *uap, register_t *retval) 743 { 744 /* { 745 syscallarg(int) fd; 746 syscallarg(netbsd32_stat50p_t) sb; 747 } */ 748 struct netbsd32_stat50 sb32; 749 struct stat ub; 750 int error; 751 752 error = do_sys_fstat(SCARG(uap, fd), &ub); 753 if (error == 0) { 754 netbsd32_from___stat50(&ub, &sb32); 755 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32)); 756 } 757 return error; 758 } 759 760 int 761 compat_50_netbsd32___lstat30(struct lwp *l, 762 const struct compat_50_netbsd32___lstat30_args *uap, register_t *retval) 763 { 764 /* { 765 syscallarg(const netbsd32_charp) path; 766 syscallarg(netbsd32_stat50p_t) ub; 767 } */ 768 struct netbsd32_stat50 sb32; 769 struct stat sb; 770 int error; 771 const char *path; 772 773 path = SCARG_P32(uap, path); 774 775 error = do_sys_stat(path, NOFOLLOW, &sb); 776 if (error) 777 return error; 778 netbsd32_from___stat50(&sb, &sb32); 779 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32)); 780 return error; 781 } 782 783 int 784 compat_50_netbsd32___fhstat40(struct lwp *l, const struct compat_50_netbsd32___fhstat40_args *uap, register_t *retval) 785 { 786 /* { 787 syscallarg(const netbsd32_pointer_t) fhp; 788 syscallarg(netbsd32_size_t) fh_size; 789 syscallarg(netbsd32_stat50p_t) sb; 790 } */ 791 struct stat sb; 792 struct netbsd32_stat50 sb32; 793 int error; 794 795 error = do_fhstat(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), &sb); 796 if (error != 0) { 797 netbsd32_from___stat50(&sb, &sb32); 798 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb)); 799 } 800 return error; 801 } 802 803 int 804 compat_50_netbsd32_wait4(struct lwp *l, const struct compat_50_netbsd32_wait4_args *uap, register_t *retval) 805 { 806 /* { 807 syscallarg(int) pid; 808 syscallarg(netbsd32_intp) status; 809 syscallarg(int) options; 810 syscallarg(netbsd32_rusage50p_t) rusage; 811 } */ 812 int error, status, pid = SCARG(uap, pid); 813 struct netbsd32_rusage50 ru32; 814 struct rusage ru; 815 816 error = do_sys_wait(&pid, &status, SCARG(uap, options), 817 SCARG_P32(uap, rusage) != NULL ? &ru : NULL); 818 819 retval[0] = pid; 820 if (pid == 0) 821 return error; 822 823 if (SCARG_P32(uap, rusage)) { 824 netbsd32_from_rusage50(&ru, &ru32); 825 error = copyout(&ru32, SCARG_P32(uap, rusage), sizeof(ru32)); 826 } 827 828 if (error == 0 && SCARG_P32(uap, status)) 829 error = copyout(&status, SCARG_P32(uap, status), sizeof(status)); 830 831 return error; 832 } 833 834 835 int 836 compat_50_netbsd32_getrusage(struct lwp *l, const struct compat_50_netbsd32_getrusage_args *uap, register_t *retval) 837 { 838 /* { 839 syscallarg(int) who; 840 syscallarg(netbsd32_rusage50p_t) rusage; 841 } */ 842 struct proc *p = l->l_proc; 843 struct rusage *rup; 844 struct netbsd32_rusage50 ru; 845 846 switch (SCARG(uap, who)) { 847 848 case RUSAGE_SELF: 849 rup = &p->p_stats->p_ru; 850 mutex_enter(p->p_lock); 851 calcru(p, &rup->ru_utime, &rup->ru_stime, NULL, NULL); 852 mutex_exit(p->p_lock); 853 break; 854 855 case RUSAGE_CHILDREN: 856 rup = &p->p_stats->p_cru; 857 break; 858 859 default: 860 return (EINVAL); 861 } 862 netbsd32_from_rusage50(rup, &ru); 863 return copyout(&ru, SCARG_P32(uap, rusage), sizeof(ru)); 864 } 865 866 int 867 compat_50_netbsd32_setitimer(struct lwp *l, 868 const struct compat_50_netbsd32_setitimer_args *uap, register_t *retval) 869 { 870 /* { 871 syscallarg(int) which; 872 syscallarg(const netbsd32_itimerval50p_t) itv; 873 syscallarg(netbsd32_itimerval50p_t) oitv; 874 } */ 875 struct proc *p = l->l_proc; 876 struct netbsd32_itimerval50 s32it, *itv32; 877 int which = SCARG(uap, which); 878 struct compat_50_netbsd32_getitimer_args getargs; 879 struct itimerval aitv; 880 int error; 881 882 if ((u_int)which > ITIMER_PROF) 883 return (EINVAL); 884 itv32 = SCARG_P32(uap, itv); 885 if (itv32) { 886 if ((error = copyin(itv32, &s32it, sizeof(s32it)))) 887 return (error); 888 netbsd32_to_itimerval50(&s32it, &aitv); 889 } 890 if (SCARG_P32(uap, oitv) != 0) { 891 SCARG(&getargs, which) = which; 892 SCARG(&getargs, itv) = SCARG(uap, oitv); 893 if ((error = compat_50_netbsd32_getitimer(l, &getargs, retval)) != 0) 894 return (error); 895 } 896 if (itv32 == 0) 897 return 0; 898 899 return dosetitimer(p, which, &aitv); 900 } 901 902 int 903 compat_50_netbsd32_getitimer(struct lwp *l, const struct compat_50_netbsd32_getitimer_args *uap, register_t *retval) 904 { 905 /* { 906 syscallarg(int) which; 907 syscallarg(netbsd32_itimerval50p_t) itv; 908 } */ 909 struct proc *p = l->l_proc; 910 struct netbsd32_itimerval50 s32it; 911 struct itimerval aitv; 912 int error; 913 914 error = dogetitimer(p, SCARG(uap, which), &aitv); 915 if (error) 916 return error; 917 918 netbsd32_from_itimerval50(&aitv, &s32it); 919 return copyout(&s32it, SCARG_P32(uap, itv), sizeof(s32it)); 920 } 921 922 #if defined(SYSVSEM) 923 924 int 925 compat_50_netbsd32___semctl14(struct lwp *l, const struct compat_50_netbsd32___semctl14_args *uap, register_t *retval) 926 { 927 return do_netbsd32___semctl14(l, uap, retval, NULL); 928 } 929 930 int 931 do_netbsd32___semctl14(struct lwp *l, const struct compat_50_netbsd32___semctl14_args *uap, register_t *retval, void *vkarg) 932 { 933 /* { 934 syscallarg(int) semid; 935 syscallarg(int) semnum; 936 syscallarg(int) cmd; 937 syscallarg(netbsd32_semun50p_t) arg; 938 } */ 939 struct semid_ds sembuf; 940 struct netbsd32_semid_ds50 sembuf32; 941 int cmd, error; 942 void *pass_arg; 943 union __semun karg; 944 union netbsd32_semun50 karg32; 945 946 cmd = SCARG(uap, cmd); 947 948 switch (cmd) { 949 case IPC_SET: 950 case IPC_STAT: 951 pass_arg = &sembuf; 952 break; 953 954 case GETALL: 955 case SETVAL: 956 case SETALL: 957 pass_arg = &karg; 958 break; 959 default: 960 pass_arg = NULL; 961 break; 962 } 963 964 if (pass_arg) { 965 if (vkarg != NULL) 966 karg32 = *(union netbsd32_semun50 *)vkarg; 967 else { 968 error = copyin(SCARG_P32(uap, arg), &karg32, 969 sizeof(karg32)); 970 if (error) 971 return error; 972 } 973 if (pass_arg == &karg) { 974 switch (cmd) { 975 case GETALL: 976 case SETALL: 977 karg.array = NETBSD32PTR64(karg32.array); 978 break; 979 case SETVAL: 980 karg.val = karg32.val; 981 break; 982 } 983 } 984 if (cmd == IPC_SET) { 985 error = copyin(NETBSD32PTR64(karg32.buf), &sembuf32, 986 sizeof(sembuf32)); 987 if (error) 988 return (error); 989 netbsd32_to_semid_ds50(&sembuf32, &sembuf); 990 } 991 } 992 993 error = semctl1(l, SCARG(uap, semid), SCARG(uap, semnum), cmd, 994 pass_arg, retval); 995 996 if (error == 0 && cmd == IPC_STAT) { 997 netbsd32_from_semid_ds50(&sembuf, &sembuf32); 998 error = copyout(&sembuf32, NETBSD32PTR64(karg32.buf), 999 sizeof(sembuf32)); 1000 } 1001 1002 return (error); 1003 } 1004 #endif 1005 1006 #if defined(SYSVMSG) 1007 1008 int 1009 compat_50_netbsd32___msgctl13(struct lwp *l, const struct compat_50_netbsd32___msgctl13_args *uap, register_t *retval) 1010 { 1011 /* { 1012 syscallarg(int) msqid; 1013 syscallarg(int) cmd; 1014 syscallarg(netbsd32_msqid_ds50p_t) buf; 1015 } */ 1016 struct msqid_ds ds; 1017 struct netbsd32_msqid_ds50 ds32; 1018 int error, cmd; 1019 1020 cmd = SCARG(uap, cmd); 1021 if (cmd == IPC_SET) { 1022 error = copyin(SCARG_P32(uap, buf), &ds32, sizeof(ds32)); 1023 if (error) 1024 return error; 1025 netbsd32_to_msqid_ds50(&ds32, &ds); 1026 } 1027 1028 error = msgctl1(l, SCARG(uap, msqid), cmd, 1029 (cmd == IPC_SET || cmd == IPC_STAT) ? &ds : NULL); 1030 1031 if (error == 0 && cmd == IPC_STAT) { 1032 netbsd32_from_msqid_ds50(&ds, &ds32); 1033 error = copyout(&ds32, SCARG_P32(uap, buf), sizeof(ds32)); 1034 } 1035 1036 return error; 1037 } 1038 #endif 1039 1040 #if defined(SYSVSHM) 1041 1042 int 1043 compat_50_netbsd32___shmctl13(struct lwp *l, const struct compat_50_netbsd32___shmctl13_args *uap, register_t *retval) 1044 { 1045 /* { 1046 syscallarg(int) shmid; 1047 syscallarg(int) cmd; 1048 syscallarg(netbsd32_shmid_ds50p_t) buf; 1049 } */ 1050 struct shmid_ds ds; 1051 struct netbsd32_shmid_ds50 ds32; 1052 int error, cmd; 1053 1054 cmd = SCARG(uap, cmd); 1055 if (cmd == IPC_SET) { 1056 error = copyin(SCARG_P32(uap, buf), &ds32, sizeof(ds32)); 1057 if (error) 1058 return error; 1059 netbsd32_to_shmid_ds50(&ds32, &ds); 1060 } 1061 1062 error = shmctl1(l, SCARG(uap, shmid), cmd, 1063 (cmd == IPC_SET || cmd == IPC_STAT) ? &ds : NULL); 1064 1065 if (error == 0 && cmd == IPC_STAT) { 1066 netbsd32_from_shmid_ds50(&ds, &ds32); 1067 error = copyout(&ds32, SCARG_P32(uap, buf), sizeof(ds32)); 1068 } 1069 1070 return error; 1071 } 1072 #endif 1073 1074 int 1075 compat_50_netbsd32_quotactl(struct lwp *l, const struct compat_50_netbsd32_quotactl_args *uap, register_t *retval) 1076 { 1077 /* { 1078 syscallarg(const netbsd32_charp) path; 1079 syscallarg(int) cmd; 1080 syscallarg(int) uid; 1081 syscallarg(netbsd32_voidp) arg; 1082 } */ 1083 struct compat_50_sys_quotactl_args ua; 1084 1085 NETBSD32TOP_UAP(path, const char); 1086 NETBSD32TO64_UAP(cmd); 1087 NETBSD32TO64_UAP(uid); 1088 NETBSD32TOP_UAP(arg, void *); 1089 return (compat_50_sys_quotactl(l, &ua, retval)); 1090 } 1091
Indexes created Wed Sep 24 14:09:57 GMT 2025