1 /* $NetBSD: netbsd32_fs.c,v 1.82 2018/12/26 08:01:40 mrg Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2001 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 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: netbsd32_fs.c,v 1.82 2018/12/26 08:01:40 mrg Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/mount.h> 35 #include <sys/socket.h> 36 #include <sys/socketvar.h> 37 #include <sys/stat.h> 38 #include <sys/time.h> 39 #include <sys/ktrace.h> 40 #include <sys/resourcevar.h> 41 #include <sys/vnode.h> 42 #include <sys/file.h> 43 #include <sys/filedesc.h> 44 #include <sys/namei.h> 45 #include <sys/statvfs.h> 46 #include <sys/syscallargs.h> 47 #include <sys/proc.h> 48 #include <sys/dirent.h> 49 #include <sys/kauth.h> 50 #include <sys/vfs_syscalls.h> 51 52 #include <fs/cd9660/cd9660_mount.h> 53 #include <fs/tmpfs/tmpfs_args.h> 54 #include <fs/msdosfs/bpb.h> 55 #include <fs/msdosfs/msdosfsmount.h> 56 #include <ufs/ufs/ufsmount.h> 57 #include <miscfs/nullfs/null.h> 58 59 #define NFS_ARGS_ONLY 60 #include <nfs/nfsmount.h> 61 62 #include <compat/netbsd32/netbsd32.h> 63 #include <compat/netbsd32/netbsd32_syscallargs.h> 64 #include <compat/netbsd32/netbsd32_conv.h> 65 #include <compat/sys/mount.h> 66 67 68 static int dofilereadv32(int, struct file *, struct netbsd32_iovec *, 69 int, off_t *, int, register_t *); 70 static int dofilewritev32(int, struct file *, struct netbsd32_iovec *, 71 int, off_t *, int, register_t *); 72 73 struct iovec * 74 netbsd32_get_iov(struct netbsd32_iovec *iov32, int iovlen, struct iovec *aiov, 75 int aiov_len) 76 { 77 #define N_IOV32 8 78 struct netbsd32_iovec aiov32[N_IOV32]; 79 struct iovec *iov = aiov; 80 struct iovec *iovp; 81 int i, n, j; 82 int error; 83 84 if (iovlen < 0 || iovlen > IOV_MAX) 85 return NULL; 86 87 if (iovlen > aiov_len) 88 iov = kmem_alloc(iovlen * sizeof(*iov), KM_SLEEP); 89 90 iovp = iov; 91 for (i = 0; i < iovlen; iov32 += N_IOV32, i += N_IOV32) { 92 n = iovlen - i; 93 if (n > N_IOV32) 94 n = N_IOV32; 95 error = copyin(iov32, aiov32, n * sizeof (*iov32)); 96 if (error != 0) { 97 if (iov != aiov) 98 kmem_free(iov, iovlen * sizeof(*iov)); 99 return NULL; 100 } 101 for (j = 0; j < n; iovp++, j++) { 102 iovp->iov_base = NETBSD32PTR64(aiov32[j].iov_base); 103 iovp->iov_len = aiov32[j].iov_len; 104 } 105 } 106 return iov; 107 #undef N_IOV32 108 } 109 110 int 111 netbsd32_readv(struct lwp *l, const struct netbsd32_readv_args *uap, register_t *retval) 112 { 113 /* { 114 syscallarg(int) fd; 115 syscallarg(const netbsd32_iovecp_t) iovp; 116 syscallarg(int) iovcnt; 117 } */ 118 int fd = SCARG(uap, fd); 119 file_t *fp; 120 121 if ((fp = fd_getfile(fd)) == NULL) 122 return (EBADF); 123 124 if ((fp->f_flag & FREAD) == 0) { 125 fd_putfile(fd); 126 return (EBADF); 127 } 128 129 return (dofilereadv32(fd, fp, 130 (struct netbsd32_iovec *)SCARG_P32(uap, iovp), 131 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval)); 132 } 133 134 /* Damn thing copies in the iovec! */ 135 int 136 dofilereadv32(int fd, struct file *fp, struct netbsd32_iovec *iovp, int iovcnt, off_t *offset, int flags, register_t *retval) 137 { 138 struct uio auio; 139 struct iovec *iov; 140 struct iovec *needfree; 141 struct iovec aiov[UIO_SMALLIOV]; 142 long i, cnt, error = 0; 143 u_int iovlen; 144 struct iovec *ktriov = NULL; 145 146 /* note: can't use iovlen until iovcnt is validated */ 147 iovlen = iovcnt * sizeof(struct iovec); 148 if ((u_int)iovcnt > UIO_SMALLIOV) { 149 if ((u_int)iovcnt > IOV_MAX) { 150 error = EINVAL; 151 goto out; 152 } 153 iov = kmem_alloc(iovlen, KM_SLEEP); 154 needfree = iov; 155 } else if ((u_int)iovcnt > 0) { 156 iov = aiov; 157 needfree = NULL; 158 } else { 159 error = EINVAL; 160 goto out; 161 } 162 163 auio.uio_iov = iov; 164 auio.uio_iovcnt = iovcnt; 165 auio.uio_rw = UIO_READ; 166 auio.uio_vmspace = curproc->p_vmspace; 167 error = netbsd32_to_iovecin(iovp, iov, iovcnt); 168 if (error) 169 goto done; 170 auio.uio_resid = 0; 171 for (i = 0; i < iovcnt; i++) { 172 auio.uio_resid += iov->iov_len; 173 /* 174 * Reads return ssize_t because -1 is returned on error. 175 * Therefore we must restrict the length to SSIZE_MAX to 176 * avoid garbage return values. 177 */ 178 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) { 179 error = EINVAL; 180 goto done; 181 } 182 iov++; 183 } 184 185 /* 186 * if tracing, save a copy of iovec 187 */ 188 if (ktrpoint(KTR_GENIO)) { 189 ktriov = kmem_alloc(iovlen, KM_SLEEP); 190 memcpy((void *)ktriov, (void *)auio.uio_iov, iovlen); 191 } 192 193 cnt = auio.uio_resid; 194 error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred, flags); 195 if (error) 196 if (auio.uio_resid != cnt && (error == ERESTART || 197 error == EINTR || error == EWOULDBLOCK)) 198 error = 0; 199 cnt -= auio.uio_resid; 200 201 if (ktriov != NULL) { 202 ktrgeniov(fd, UIO_READ, ktriov, cnt, error); 203 kmem_free(ktriov, iovlen); 204 } 205 206 *retval = cnt; 207 done: 208 if (needfree) 209 kmem_free(needfree, iovlen); 210 out: 211 fd_putfile(fd); 212 return (error); 213 } 214 215 int 216 netbsd32_writev(struct lwp *l, const struct netbsd32_writev_args *uap, register_t *retval) 217 { 218 /* { 219 syscallarg(int) fd; 220 syscallarg(const netbsd32_iovecp_t) iovp; 221 syscallarg(int) iovcnt; 222 } */ 223 int fd = SCARG(uap, fd); 224 file_t *fp; 225 226 if ((fp = fd_getfile(fd)) == NULL) 227 return (EBADF); 228 229 if ((fp->f_flag & FWRITE) == 0) { 230 fd_putfile(fd); 231 return (EBADF); 232 } 233 234 return (dofilewritev32(fd, fp, 235 (struct netbsd32_iovec *)SCARG_P32(uap, iovp), 236 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval)); 237 } 238 239 int 240 dofilewritev32(int fd, struct file *fp, struct netbsd32_iovec *iovp, int iovcnt, off_t *offset, int flags, register_t *retval) 241 { 242 struct uio auio; 243 struct iovec *iov; 244 struct iovec *needfree; 245 struct iovec aiov[UIO_SMALLIOV]; 246 long i, cnt, error = 0; 247 u_int iovlen; 248 struct iovec *ktriov = NULL; 249 250 /* note: can't use iovlen until iovcnt is validated */ 251 iovlen = iovcnt * sizeof(struct iovec); 252 if ((u_int)iovcnt > UIO_SMALLIOV) { 253 if ((u_int)iovcnt > IOV_MAX) { 254 error = EINVAL; 255 goto out; 256 } 257 iov = kmem_alloc(iovlen, KM_SLEEP); 258 needfree = iov; 259 } else if ((u_int)iovcnt > 0) { 260 iov = aiov; 261 needfree = NULL; 262 } else { 263 error = EINVAL; 264 goto out; 265 } 266 267 auio.uio_iov = iov; 268 auio.uio_iovcnt = iovcnt; 269 auio.uio_rw = UIO_WRITE; 270 auio.uio_vmspace = curproc->p_vmspace; 271 error = netbsd32_to_iovecin(iovp, iov, iovcnt); 272 if (error) 273 goto done; 274 auio.uio_resid = 0; 275 for (i = 0; i < iovcnt; i++) { 276 auio.uio_resid += iov->iov_len; 277 /* 278 * Writes return ssize_t because -1 is returned on error. 279 * Therefore we must restrict the length to SSIZE_MAX to 280 * avoid garbage return values. 281 */ 282 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) { 283 error = EINVAL; 284 goto done; 285 } 286 iov++; 287 } 288 289 /* 290 * if tracing, save a copy of iovec 291 */ 292 if (ktrpoint(KTR_GENIO)) { 293 ktriov = kmem_alloc(iovlen, KM_SLEEP); 294 memcpy((void *)ktriov, (void *)auio.uio_iov, iovlen); 295 } 296 297 cnt = auio.uio_resid; 298 error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred, flags); 299 if (error) { 300 if (auio.uio_resid != cnt && (error == ERESTART || 301 error == EINTR || error == EWOULDBLOCK)) 302 error = 0; 303 if (error == EPIPE && (fp->f_flag & FNOSIGPIPE) == 0) { 304 mutex_enter(proc_lock); 305 psignal(curproc, SIGPIPE); 306 mutex_exit(proc_lock); 307 } 308 } 309 cnt -= auio.uio_resid; 310 if (ktriov != NULL) { 311 ktrgeniov(fd, UIO_WRITE, ktriov, cnt, error); 312 kmem_free(ktriov, iovlen); 313 } 314 *retval = cnt; 315 done: 316 if (needfree) 317 kmem_free(needfree, iovlen); 318 out: 319 fd_putfile(fd); 320 return (error); 321 } 322 323 /* 324 * Common routines to set access and modification times given a vnode. 325 */ 326 static int 327 get_utimes32(const netbsd32_timevalp_t *tptr, struct timeval *tv, 328 struct timeval **tvp) 329 { 330 int error; 331 struct netbsd32_timeval tv32[2]; 332 333 if (tptr == NULL) { 334 *tvp = NULL; 335 return 0; 336 } 337 338 error = copyin(tptr, tv32, sizeof(tv32)); 339 if (error) 340 return error; 341 netbsd32_to_timeval(&tv32[0], &tv[0]); 342 netbsd32_to_timeval(&tv32[1], &tv[1]); 343 344 *tvp = tv; 345 return 0; 346 } 347 348 static int 349 get_utimens32(const netbsd32_timespecp_t *tptr, struct timespec *ts, 350 struct timespec **tsp) 351 { 352 int error; 353 struct netbsd32_timespec ts32[2]; 354 355 if (tptr == NULL) { 356 *tsp = NULL; 357 return 0; 358 } 359 360 error = copyin(tptr, ts32, sizeof(ts32)); 361 if (error) 362 return error; 363 netbsd32_to_timespec(&ts32[0], &ts[0]); 364 netbsd32_to_timespec(&ts32[1], &ts[1]); 365 366 *tsp = ts; 367 return 0; 368 } 369 370 int 371 netbsd32___utimes50(struct lwp *l, const struct netbsd32___utimes50_args *uap, register_t *retval) 372 { 373 /* { 374 syscallarg(const netbsd32_charp) path; 375 syscallarg(const netbsd32_timevalp_t) tptr; 376 } */ 377 int error; 378 struct timeval tv[2], *tvp; 379 380 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 381 if (error != 0) 382 return error; 383 384 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), FOLLOW, 385 tvp, UIO_SYSSPACE); 386 } 387 388 static int 389 netbsd32_copyout_statvfs(const void *kp, void *up, size_t len) 390 { 391 struct netbsd32_statvfs *sbuf_32; 392 int error; 393 394 sbuf_32 = kmem_alloc(sizeof(*sbuf_32), KM_SLEEP); 395 netbsd32_from_statvfs(kp, sbuf_32); 396 error = copyout(sbuf_32, up, sizeof(*sbuf_32)); 397 kmem_free(sbuf_32, sizeof(*sbuf_32)); 398 399 return error; 400 } 401 402 int 403 netbsd32_statvfs1(struct lwp *l, const struct netbsd32_statvfs1_args *uap, register_t *retval) 404 { 405 /* { 406 syscallarg(const netbsd32_charp) path; 407 syscallarg(netbsd32_statvfsp_t) buf; 408 syscallarg(int) flags; 409 } */ 410 struct statvfs *sb; 411 int error; 412 413 sb = STATVFSBUF_GET(); 414 error = do_sys_pstatvfs(l, SCARG_P32(uap, path), SCARG(uap, flags), sb); 415 if (error == 0) 416 error = netbsd32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0); 417 STATVFSBUF_PUT(sb); 418 return error; 419 } 420 421 int 422 netbsd32_fstatvfs1(struct lwp *l, const struct netbsd32_fstatvfs1_args *uap, register_t *retval) 423 { 424 /* { 425 syscallarg(int) fd; 426 syscallarg(netbsd32_statvfsp_t) buf; 427 syscallarg(int) flags; 428 } */ 429 struct statvfs *sb; 430 int error; 431 432 sb = STATVFSBUF_GET(); 433 error = do_sys_fstatvfs(l, SCARG(uap, fd), SCARG(uap, flags), sb); 434 if (error == 0) 435 error = netbsd32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0); 436 STATVFSBUF_PUT(sb); 437 return error; 438 } 439 440 int 441 netbsd32_getvfsstat(struct lwp *l, const struct netbsd32_getvfsstat_args *uap, register_t *retval) 442 { 443 /* { 444 syscallarg(netbsd32_statvfsp_t) buf; 445 syscallarg(netbsd32_size_t) bufsize; 446 syscallarg(int) flags; 447 } */ 448 449 return do_sys_getvfsstat(l, SCARG_P32(uap, buf), SCARG(uap, bufsize), 450 SCARG(uap, flags), netbsd32_copyout_statvfs, 451 sizeof (struct netbsd32_statvfs), retval); 452 } 453 454 int 455 netbsd32___fhstatvfs140(struct lwp *l, const struct netbsd32___fhstatvfs140_args *uap, register_t *retval) 456 { 457 /* { 458 syscallarg(const netbsd32_pointer_t) fhp; 459 syscallarg(netbsd32_size_t) fh_size; 460 syscallarg(netbsd32_statvfsp_t) buf; 461 syscallarg(int) flags; 462 } */ 463 struct statvfs *sb; 464 int error; 465 466 sb = STATVFSBUF_GET(); 467 error = do_fhstatvfs(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), sb, 468 SCARG(uap, flags)); 469 470 if (error == 0) 471 error = netbsd32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0); 472 STATVFSBUF_PUT(sb); 473 474 return error; 475 } 476 477 int 478 netbsd32___futimes50(struct lwp *l, const struct netbsd32___futimes50_args *uap, register_t *retval) 479 { 480 /* { 481 syscallarg(int) fd; 482 syscallarg(const netbsd32_timevalp_t) tptr; 483 } */ 484 int error; 485 file_t *fp; 486 struct timeval tv[2], *tvp; 487 488 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 489 if (error != 0) 490 return error; 491 492 /* fd_getvnode() will use the descriptor for us */ 493 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 494 return (error); 495 496 error = do_sys_utimes(l, fp->f_vnode, NULL, 0, tvp, UIO_SYSSPACE); 497 498 fd_putfile(SCARG(uap, fd)); 499 return (error); 500 } 501 502 int 503 netbsd32___getdents30(struct lwp *l, 504 const struct netbsd32___getdents30_args *uap, register_t *retval) 505 { 506 /* { 507 syscallarg(int) fd; 508 syscallarg(netbsd32_charp) buf; 509 syscallarg(netbsd32_size_t) count; 510 } */ 511 file_t *fp; 512 int error, done; 513 514 /* fd_getvnode() will use the descriptor for us */ 515 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 516 return (error); 517 if ((fp->f_flag & FREAD) == 0) { 518 error = EBADF; 519 goto out; 520 } 521 error = vn_readdir(fp, SCARG_P32(uap, buf), 522 UIO_USERSPACE, SCARG(uap, count), &done, l, 0, 0); 523 ktrgenio(SCARG(uap, fd), UIO_READ, SCARG_P32(uap, buf), done, error); 524 *retval = done; 525 out: 526 fd_putfile(SCARG(uap, fd)); 527 return (error); 528 } 529 530 int 531 netbsd32___lutimes50(struct lwp *l, 532 const struct netbsd32___lutimes50_args *uap, register_t *retval) 533 { 534 /* { 535 syscallarg(const netbsd32_charp) path; 536 syscallarg(const netbsd32_timevalp_t) tptr; 537 } */ 538 int error; 539 struct timeval tv[2], *tvp; 540 541 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 542 if (error != 0) 543 return error; 544 545 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), NOFOLLOW, 546 tvp, UIO_SYSSPACE); 547 } 548 549 int 550 netbsd32___stat50(struct lwp *l, const struct netbsd32___stat50_args *uap, register_t *retval) 551 { 552 /* { 553 syscallarg(const netbsd32_charp) path; 554 syscallarg(netbsd32_statp_t) ub; 555 } */ 556 struct netbsd32_stat sb32; 557 struct stat sb; 558 int error; 559 const char *path; 560 561 path = SCARG_P32(uap, path); 562 563 error = do_sys_stat(path, FOLLOW, &sb); 564 if (error) 565 return (error); 566 netbsd32_from_stat(&sb, &sb32); 567 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32)); 568 return (error); 569 } 570 571 int 572 netbsd32___fstat50(struct lwp *l, const struct netbsd32___fstat50_args *uap, register_t *retval) 573 { 574 /* { 575 syscallarg(int) fd; 576 syscallarg(netbsd32_statp_t) sb; 577 } */ 578 struct netbsd32_stat sb32; 579 struct stat ub; 580 int error; 581 582 error = do_sys_fstat(SCARG(uap, fd), &ub); 583 if (error == 0) { 584 netbsd32_from_stat(&ub, &sb32); 585 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32)); 586 } 587 return (error); 588 } 589 590 int 591 netbsd32___lstat50(struct lwp *l, const struct netbsd32___lstat50_args *uap, register_t *retval) 592 { 593 /* { 594 syscallarg(const netbsd32_charp) path; 595 syscallarg(netbsd32_statp_t) ub; 596 } */ 597 struct netbsd32_stat sb32; 598 struct stat sb; 599 int error; 600 const char *path; 601 602 path = SCARG_P32(uap, path); 603 604 error = do_sys_stat(path, NOFOLLOW, &sb); 605 if (error) 606 return (error); 607 netbsd32_from_stat(&sb, &sb32); 608 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32)); 609 return (error); 610 } 611 612 int 613 netbsd32___fhstat50(struct lwp *l, const struct netbsd32___fhstat50_args *uap, register_t *retval) 614 { 615 /* { 616 syscallarg(const netbsd32_pointer_t) fhp; 617 syscallarg(netbsd32_size_t) fh_size; 618 syscallarg(netbsd32_statp_t) sb; 619 } */ 620 struct stat sb; 621 struct netbsd32_stat sb32; 622 int error; 623 624 error = do_fhstat(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), &sb); 625 if (error == 0) { 626 netbsd32_from_stat(&sb, &sb32); 627 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb)); 628 } 629 return error; 630 } 631 632 int 633 netbsd32_preadv(struct lwp *l, const struct netbsd32_preadv_args *uap, register_t *retval) 634 { 635 /* { 636 syscallarg(int) fd; 637 syscallarg(const netbsd32_iovecp_t) iovp; 638 syscallarg(int) iovcnt; 639 syscallarg(int) pad; 640 syscallarg(netbsd32_off_t) offset; 641 } */ 642 file_t *fp; 643 struct vnode *vp; 644 off_t offset; 645 int error, fd = SCARG(uap, fd); 646 647 if ((fp = fd_getfile(fd)) == NULL) 648 return (EBADF); 649 650 if ((fp->f_flag & FREAD) == 0) { 651 fd_putfile(fd); 652 return (EBADF); 653 } 654 655 vp = fp->f_vnode; 656 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) { 657 error = ESPIPE; 658 goto out; 659 } 660 661 offset = SCARG(uap, offset); 662 663 /* 664 * XXX This works because no file systems actually 665 * XXX take any action on the seek operation. 666 */ 667 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0) 668 goto out; 669 670 return (dofilereadv32(fd, fp, SCARG_P32(uap, iovp), 671 SCARG(uap, iovcnt), &offset, 0, retval)); 672 673 out: 674 fd_putfile(fd); 675 return (error); 676 } 677 678 int 679 netbsd32_pwritev(struct lwp *l, const struct netbsd32_pwritev_args *uap, register_t *retval) 680 { 681 /* { 682 syscallarg(int) fd; 683 syscallarg(const netbsd32_iovecp_t) iovp; 684 syscallarg(int) iovcnt; 685 syscallarg(int) pad; 686 syscallarg(netbsd32_off_t) offset; 687 } */ 688 file_t *fp; 689 struct vnode *vp; 690 off_t offset; 691 int error, fd = SCARG(uap, fd); 692 693 if ((fp = fd_getfile(fd)) == NULL) 694 return (EBADF); 695 696 if ((fp->f_flag & FWRITE) == 0) { 697 fd_putfile(fd); 698 return (EBADF); 699 } 700 701 vp = fp->f_vnode; 702 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) { 703 error = ESPIPE; 704 goto out; 705 } 706 707 offset = SCARG(uap, offset); 708 709 /* 710 * XXX This works because no file systems actually 711 * XXX take any action on the seek operation. 712 */ 713 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0) 714 goto out; 715 716 return (dofilewritev32(fd, fp, SCARG_P32(uap, iovp), 717 SCARG(uap, iovcnt), &offset, 0, retval)); 718 719 out: 720 fd_putfile(fd); 721 return (error); 722 } 723 724 /* 725 * Find pathname of process's current directory. 726 * 727 * Use vfs vnode-to-name reverse cache; if that fails, fall back 728 * to reading directory contents. 729 */ 730 int 731 netbsd32___getcwd(struct lwp *l, const struct netbsd32___getcwd_args *uap, register_t *retval) 732 { 733 /* { 734 syscallarg(char *) bufp; 735 syscallarg(size_t) length; 736 } */ 737 struct proc *p = l->l_proc; 738 int error; 739 char *path; 740 char *bp, *bend; 741 int len = (int)SCARG(uap, length); 742 int lenused; 743 struct cwdinfo *cwdi; 744 745 if (len > MAXPATHLEN*4) 746 len = MAXPATHLEN*4; 747 else if (len < 2) 748 return ERANGE; 749 750 path = kmem_alloc(len, KM_SLEEP); 751 bp = &path[len]; 752 bend = bp; 753 *(--bp) = '\0'; 754 755 /* 756 * 5th argument here is "max number of vnodes to traverse". 757 * Since each entry takes up at least 2 bytes in the output buffer, 758 * limit it to N/2 vnodes for an N byte buffer. 759 */ 760 #define GETCWD_CHECK_ACCESS 0x0001 761 cwdi = p->p_cwdi; 762 rw_enter(&cwdi->cwdi_lock, RW_READER); 763 error = getcwd_common (cwdi->cwdi_cdir, NULL, &bp, path, len/2, 764 GETCWD_CHECK_ACCESS, l); 765 rw_exit(&cwdi->cwdi_lock); 766 767 if (error) 768 goto out; 769 lenused = bend - bp; 770 *retval = lenused; 771 /* put the result into user buffer */ 772 error = copyout(bp, SCARG_P32(uap, bufp), lenused); 773 774 out: 775 kmem_free(path, len); 776 return error; 777 } 778 779 int 780 netbsd32___mount50(struct lwp *l, const struct netbsd32___mount50_args *uap, 781 register_t *retval) 782 { 783 /* { 784 syscallarg(netbsd32_charp) type; 785 syscallarg(netbsd32_charp) path; 786 syscallarg(int) flags; 787 syscallarg(netbsd32_voidp) data; 788 syscallarg(netbsd32_size_t) data_len; 789 } */ 790 char mtype[MNAMELEN]; 791 union { 792 struct netbsd32_ufs_args ufs_args; 793 struct netbsd32_mfs_args mfs_args; 794 struct netbsd32_iso_args iso_args; 795 struct netbsd32_nfs_args nfs_args; 796 struct netbsd32_msdosfs_args msdosfs_args; 797 struct netbsd32_tmpfs_args tmpfs_args; 798 struct netbsd32_null_args null_args; 799 } fs_args32; 800 union { 801 struct ufs_args ufs_args; 802 struct mfs_args mfs_args; 803 struct iso_args iso_args; 804 struct nfs_args nfs_args; 805 struct msdosfs_args msdosfs_args; 806 struct tmpfs_args tmpfs_args; 807 struct null_args null_args; 808 } fs_args; 809 const char *type = SCARG_P32(uap, type); 810 const char *path = SCARG_P32(uap, path); 811 int flags = SCARG(uap, flags); 812 void *data = SCARG_P32(uap, data); 813 size_t data_len = SCARG(uap, data_len); 814 enum uio_seg data_seg; 815 size_t len; 816 int error; 817 818 error = copyinstr(type, mtype, sizeof(mtype), &len); 819 if (error) 820 return error; 821 if (strcmp(mtype, MOUNT_TMPFS) == 0) { 822 if (data_len != sizeof(fs_args32.tmpfs_args)) 823 return EINVAL; 824 if ((flags & MNT_GETARGS) == 0) { 825 error = copyin(data, &fs_args32.tmpfs_args, 826 sizeof(fs_args32.tmpfs_args)); 827 if (error) 828 return error; 829 fs_args.tmpfs_args.ta_version = 830 fs_args32.tmpfs_args.ta_version; 831 fs_args.tmpfs_args.ta_nodes_max = 832 fs_args32.tmpfs_args.ta_nodes_max; 833 fs_args.tmpfs_args.ta_size_max = 834 fs_args32.tmpfs_args.ta_size_max; 835 fs_args.tmpfs_args.ta_root_uid = 836 fs_args32.tmpfs_args.ta_root_uid; 837 fs_args.tmpfs_args.ta_root_gid = 838 fs_args32.tmpfs_args.ta_root_gid; 839 fs_args.tmpfs_args.ta_root_mode = 840 fs_args32.tmpfs_args.ta_root_mode; 841 } 842 data_seg = UIO_SYSSPACE; 843 data = &fs_args.tmpfs_args; 844 data_len = sizeof(fs_args.tmpfs_args); 845 } else if (strcmp(mtype, MOUNT_MFS) == 0) { 846 if (data_len != sizeof(fs_args32.mfs_args)) 847 return EINVAL; 848 if ((flags & MNT_GETARGS) == 0) { 849 error = copyin(data, &fs_args32.mfs_args, 850 sizeof(fs_args32.mfs_args)); 851 if (error) 852 return error; 853 fs_args.mfs_args.fspec = 854 NETBSD32PTR64(fs_args32.mfs_args.fspec); 855 memset(&fs_args.mfs_args._pad1, 0, 856 sizeof(fs_args.mfs_args._pad1)); 857 fs_args.mfs_args.base = 858 NETBSD32PTR64(fs_args32.mfs_args.base); 859 fs_args.mfs_args.size = fs_args32.mfs_args.size; 860 } 861 data_seg = UIO_SYSSPACE; 862 data = &fs_args.mfs_args; 863 data_len = sizeof(fs_args.mfs_args); 864 } else if ((strcmp(mtype, MOUNT_UFS) == 0) || 865 (strcmp(mtype, MOUNT_EXT2FS) == 0) || 866 (strcmp(mtype, MOUNT_LFS) == 0)) { 867 if (data_len > sizeof(fs_args32.ufs_args)) 868 return EINVAL; 869 if ((flags & MNT_GETARGS) == 0) { 870 error = copyin(data, &fs_args32.ufs_args, 871 sizeof(fs_args32.ufs_args)); 872 if (error) 873 return error; 874 fs_args.ufs_args.fspec = 875 NETBSD32PTR64(fs_args32.ufs_args.fspec); 876 } 877 data_seg = UIO_SYSSPACE; 878 data = &fs_args.ufs_args; 879 data_len = sizeof(fs_args.ufs_args); 880 } else if (strcmp(mtype, MOUNT_CD9660) == 0) { 881 if (data_len != sizeof(fs_args32.iso_args)) 882 return EINVAL; 883 if ((flags & MNT_GETARGS) == 0) { 884 error = copyin(data, &fs_args32.iso_args, 885 sizeof(fs_args32.iso_args)); 886 if (error) 887 return error; 888 fs_args.iso_args.fspec = 889 NETBSD32PTR64(fs_args32.iso_args.fspec); 890 memset(&fs_args.iso_args._pad1, 0, 891 sizeof(fs_args.iso_args._pad1)); 892 fs_args.iso_args.flags = fs_args32.iso_args.flags; 893 } 894 data_seg = UIO_SYSSPACE; 895 data = &fs_args.iso_args; 896 data_len = sizeof(fs_args.iso_args); 897 } else if (strcmp(mtype, MOUNT_MSDOS) == 0) { 898 if (data_len != sizeof(fs_args32.msdosfs_args)) 899 return EINVAL; 900 if ((flags & MNT_GETARGS) == 0) { 901 error = copyin(data, &fs_args32.msdosfs_args, 902 sizeof(fs_args32.msdosfs_args)); 903 if (error) 904 return error; 905 fs_args.msdosfs_args.fspec = 906 NETBSD32PTR64(fs_args32.msdosfs_args.fspec); 907 memset(&fs_args.msdosfs_args._pad1, 0, 908 sizeof(fs_args.msdosfs_args._pad1)); 909 fs_args.msdosfs_args.uid = 910 fs_args32.msdosfs_args.uid; 911 fs_args.msdosfs_args.gid = 912 fs_args32.msdosfs_args.gid; 913 fs_args.msdosfs_args.mask = 914 fs_args32.msdosfs_args.mask; 915 fs_args.msdosfs_args.flags = 916 fs_args32.msdosfs_args.flags; 917 fs_args.msdosfs_args.version = 918 fs_args32.msdosfs_args.version; 919 fs_args.msdosfs_args.dirmask = 920 fs_args32.msdosfs_args.dirmask; 921 fs_args.msdosfs_args.gmtoff = 922 fs_args32.msdosfs_args.gmtoff; 923 } 924 data_seg = UIO_SYSSPACE; 925 data = &fs_args.msdosfs_args; 926 data_len = sizeof(fs_args.msdosfs_args); 927 } else if (strcmp(mtype, MOUNT_NFS) == 0) { 928 if (data_len != sizeof(fs_args32.nfs_args)) 929 return EINVAL; 930 if ((flags & MNT_GETARGS) == 0) { 931 error = copyin(data, &fs_args32.nfs_args, 932 sizeof(fs_args32.nfs_args)); 933 if (error) 934 return error; 935 fs_args.nfs_args.version = fs_args32.nfs_args.version; 936 fs_args.nfs_args.addr = 937 NETBSD32PTR64(fs_args32.nfs_args.addr); 938 memcpy(&fs_args.nfs_args.addrlen, 939 &fs_args32.nfs_args.addrlen, 940 offsetof(struct nfs_args, fh) 941 - offsetof(struct nfs_args, addrlen)); 942 fs_args.nfs_args.fh = 943 NETBSD32PTR64(fs_args32.nfs_args.fh); 944 memcpy(&fs_args.nfs_args.fhsize, 945 &fs_args32.nfs_args.fhsize, 946 offsetof(struct nfs_args, hostname) 947 - offsetof(struct nfs_args, fhsize)); 948 fs_args.nfs_args.hostname = 949 NETBSD32PTR64(fs_args32.nfs_args.hostname); 950 } 951 data_seg = UIO_SYSSPACE; 952 data = &fs_args.nfs_args; 953 data_len = sizeof(fs_args.nfs_args); 954 } else if (strcmp(mtype, MOUNT_NULL) == 0) { 955 if (data_len > sizeof(fs_args32.null_args)) 956 return EINVAL; 957 if ((flags & MNT_GETARGS) == 0) { 958 error = copyin(data, &fs_args32.null_args, 959 sizeof(fs_args32.null_args)); 960 if (error) 961 return error; 962 fs_args.null_args.la.target = 963 NETBSD32PTR64(fs_args32.null_args.la.target); 964 } 965 data_seg = UIO_SYSSPACE; 966 data = &fs_args.null_args; 967 data_len = sizeof(fs_args.null_args); 968 } else { 969 data_seg = UIO_USERSPACE; 970 } 971 error = do_sys_mount(l, mtype, UIO_SYSSPACE, path, flags, data, data_seg, 972 data_len, retval); 973 if (error) 974 return error; 975 if (flags & MNT_GETARGS) { 976 data_len = *retval; 977 if (strcmp(mtype, MOUNT_TMPFS) == 0) { 978 if (data_len != sizeof(fs_args.tmpfs_args)) 979 return EINVAL; 980 fs_args32.tmpfs_args.ta_version = 981 fs_args.tmpfs_args.ta_version; 982 fs_args32.tmpfs_args.ta_nodes_max = 983 fs_args.tmpfs_args.ta_nodes_max; 984 fs_args32.tmpfs_args.ta_size_max = 985 fs_args.tmpfs_args.ta_size_max; 986 fs_args32.tmpfs_args.ta_root_uid = 987 fs_args.tmpfs_args.ta_root_uid; 988 fs_args32.tmpfs_args.ta_root_gid = 989 fs_args.tmpfs_args.ta_root_gid; 990 fs_args32.tmpfs_args.ta_root_mode = 991 fs_args.tmpfs_args.ta_root_mode; 992 error = copyout(&fs_args32.tmpfs_args, data, 993 sizeof(fs_args32.tmpfs_args)); 994 } else if (strcmp(mtype, MOUNT_MFS) == 0) { 995 if (data_len != sizeof(fs_args.mfs_args)) 996 return EINVAL; 997 NETBSD32PTR32(fs_args32.mfs_args.fspec, 998 fs_args.mfs_args.fspec); 999 memset(&fs_args32.mfs_args._pad1, 0, 1000 sizeof(fs_args32.mfs_args._pad1)); 1001 NETBSD32PTR32(fs_args32.mfs_args.base, 1002 fs_args.mfs_args.base); 1003 fs_args32.mfs_args.size = fs_args.mfs_args.size; 1004 error = copyout(&fs_args32.mfs_args, data, 1005 sizeof(fs_args32.mfs_args)); 1006 } else if (strcmp(mtype, MOUNT_UFS) == 0) { 1007 if (data_len != sizeof(fs_args.ufs_args)) 1008 return EINVAL; 1009 NETBSD32PTR32(fs_args32.ufs_args.fspec, 1010 fs_args.ufs_args.fspec); 1011 error = copyout(&fs_args32.ufs_args, data, 1012 sizeof(fs_args32.ufs_args)); 1013 } else if (strcmp(mtype, MOUNT_CD9660) == 0) { 1014 if (data_len != sizeof(fs_args.iso_args)) 1015 return EINVAL; 1016 NETBSD32PTR32(fs_args32.iso_args.fspec, 1017 fs_args.iso_args.fspec); 1018 memset(&fs_args32.iso_args._pad1, 0, 1019 sizeof(fs_args32.iso_args._pad1)); 1020 fs_args32.iso_args.flags = fs_args.iso_args.flags; 1021 error = copyout(&fs_args32.iso_args, data, 1022 sizeof(fs_args32.iso_args)); 1023 } else if (strcmp(mtype, MOUNT_NFS) == 0) { 1024 if (data_len != sizeof(fs_args.nfs_args)) 1025 return EINVAL; 1026 error = copyin(data, &fs_args32.nfs_args, 1027 sizeof(fs_args32.nfs_args)); 1028 if (error) 1029 return error; 1030 fs_args.nfs_args.version = fs_args32.nfs_args.version; 1031 NETBSD32PTR32(fs_args32.nfs_args.addr, 1032 fs_args.nfs_args.addr); 1033 memcpy(&fs_args32.nfs_args.addrlen, 1034 &fs_args.nfs_args.addrlen, 1035 offsetof(struct nfs_args, fh) 1036 - offsetof(struct nfs_args, addrlen)); 1037 NETBSD32PTR32(fs_args32.nfs_args.fh, 1038 fs_args.nfs_args.fh); 1039 memcpy(&fs_args32.nfs_args.fhsize, 1040 &fs_args.nfs_args.fhsize, 1041 offsetof(struct nfs_args, hostname) 1042 - offsetof(struct nfs_args, fhsize)); 1043 NETBSD32PTR32(fs_args32.nfs_args.hostname, 1044 fs_args.nfs_args.hostname); 1045 error = copyout(&fs_args32.nfs_args, data, 1046 sizeof(fs_args32.nfs_args)); 1047 } else if (strcmp(mtype, MOUNT_NULL) == 0) { 1048 if (data_len != sizeof(fs_args.null_args)) 1049 return EINVAL; 1050 NETBSD32PTR32(fs_args32.null_args.la.target, 1051 fs_args.null_args.la.target); 1052 error = copyout(&fs_args32.null_args, data, 1053 sizeof(fs_args32.null_args)); 1054 } 1055 } 1056 return error; 1057 } 1058 1059 int 1060 netbsd32_linkat(struct lwp *l, const struct netbsd32_linkat_args *uap, 1061 register_t *retval) 1062 { 1063 /* { 1064 syscallarg(int) fd1; 1065 syscallarg(const netbsd32_charp) name1; 1066 syscallarg(int) fd2; 1067 syscallarg(const netbsd32_charp) name2; 1068 syscallarg(int) flags; 1069 } */ 1070 struct sys_linkat_args ua; 1071 1072 NETBSD32TO64_UAP(fd1); 1073 NETBSD32TOP_UAP(name1, const char); 1074 NETBSD32TO64_UAP(fd2); 1075 NETBSD32TOP_UAP(name2, const char); 1076 NETBSD32TO64_UAP(flags); 1077 1078 return sys_linkat(l, &ua, retval); 1079 } 1080 1081 int 1082 netbsd32_renameat(struct lwp *l, const struct netbsd32_renameat_args *uap, 1083 register_t *retval) 1084 { 1085 /* { 1086 syscallarg(int) fromfd; 1087 syscallarg(const netbsd32_charp) from; 1088 syscallarg(int) tofd; 1089 syscallarg(const netbsd32_charp) to; 1090 } */ 1091 struct sys_renameat_args ua; 1092 1093 NETBSD32TO64_UAP(fromfd); 1094 NETBSD32TOP_UAP(from, const char); 1095 NETBSD32TO64_UAP(tofd); 1096 NETBSD32TOP_UAP(to, const char); 1097 1098 return sys_renameat(l, &ua, retval); 1099 } 1100 1101 int 1102 netbsd32_mkfifoat(struct lwp *l, const struct netbsd32_mkfifoat_args *uap, 1103 register_t *retval) 1104 { 1105 /* { 1106 syscallarg(int) fd; 1107 syscallarg(const netbsd32_charp) path; 1108 syscallarg(mode_t) mode; 1109 } */ 1110 struct sys_mkfifoat_args ua; 1111 1112 NETBSD32TO64_UAP(fd); 1113 NETBSD32TOP_UAP(path, const char); 1114 NETBSD32TO64_UAP(mode); 1115 1116 return sys_mkfifoat(l, &ua, retval); 1117 } 1118 1119 int 1120 netbsd32_mknodat(struct lwp *l, const struct netbsd32_mknodat_args *uap, 1121 register_t *retval) 1122 { 1123 /* { 1124 syscallarg(int) fd; 1125 syscallarg(netbsd32_charp) path; 1126 syscallarg(mode_t) mode; 1127 syscallarg(int) pad; 1128 syscallarg(netbsd32_dev_t) dev; 1129 } */ 1130 struct sys_mknodat_args ua; 1131 1132 NETBSD32TO64_UAP(fd); 1133 NETBSD32TOP_UAP(path, const char); 1134 NETBSD32TO64_UAP(mode); 1135 NETBSD32TO64_UAP(PAD); 1136 NETBSD32TO64_UAP(dev); 1137 1138 return sys_mknodat(l, &ua, retval); 1139 } 1140 1141 int 1142 netbsd32_mkdirat(struct lwp *l, const struct netbsd32_mkdirat_args *uap, 1143 register_t *retval) 1144 { 1145 /* { 1146 syscallarg(int) fd; 1147 syscallarg(netbsd32_charp) path; 1148 syscallarg(mode_t) mode; 1149 } */ 1150 struct sys_mkdirat_args ua; 1151 1152 NETBSD32TO64_UAP(fd); 1153 NETBSD32TOP_UAP(path, const char); 1154 NETBSD32TO64_UAP(mode); 1155 1156 return sys_mkdirat(l, &ua, retval); 1157 } 1158 1159 int 1160 netbsd32_faccessat(struct lwp *l, const struct netbsd32_faccessat_args *uap, 1161 register_t *retval) 1162 { 1163 /* { 1164 syscallarg(int) fd; 1165 syscallarg(netbsd32_charp) path; 1166 syscallarg(int) amode; 1167 syscallarg(int) flag; 1168 } */ 1169 struct sys_faccessat_args ua; 1170 1171 NETBSD32TO64_UAP(fd); 1172 NETBSD32TOP_UAP(path, const char); 1173 NETBSD32TO64_UAP(amode); 1174 NETBSD32TO64_UAP(flag); 1175 1176 return sys_faccessat(l, &ua, retval); 1177 } 1178 1179 int 1180 netbsd32_fchmodat(struct lwp *l, const struct netbsd32_fchmodat_args *uap, 1181 register_t *retval) 1182 { 1183 /* { 1184 syscallarg(int) fd; 1185 syscallarg(netbsd32_charp) path; 1186 syscallarg(mode_t) mode; 1187 syscallarg(int) flag; 1188 } */ 1189 struct sys_fchmodat_args ua; 1190 1191 NETBSD32TO64_UAP(fd); 1192 NETBSD32TOP_UAP(path, const char); 1193 NETBSD32TO64_UAP(mode); 1194 NETBSD32TO64_UAP(flag); 1195 1196 return sys_fchmodat(l, &ua, retval); 1197 } 1198 1199 int 1200 netbsd32_fchownat(struct lwp *l, const struct netbsd32_fchownat_args *uap, 1201 register_t *retval) 1202 { 1203 /* { 1204 syscallarg(int) fd; 1205 syscallarg(netbsd32_charp) path; 1206 syscallarg(uid_t) owner; 1207 syscallarg(gid_t) group; 1208 syscallarg(int) flag; 1209 } */ 1210 struct sys_fchownat_args ua; 1211 1212 NETBSD32TO64_UAP(fd); 1213 NETBSD32TOP_UAP(path, const char); 1214 NETBSD32TO64_UAP(owner); 1215 NETBSD32TO64_UAP(group); 1216 NETBSD32TO64_UAP(flag); 1217 1218 return sys_fchownat(l, &ua, retval); 1219 } 1220 1221 int 1222 netbsd32_fstatat(struct lwp *l, const struct netbsd32_fstatat_args *uap, 1223 register_t *retval) 1224 { 1225 /* { 1226 syscallarg(int) fd; 1227 syscallarg(netbsd32_charp) path; 1228 syscallarg(netbsd32_statp_t) buf; 1229 syscallarg(int) flag; 1230 } */ 1231 struct netbsd32_stat sb32; 1232 struct stat sb; 1233 int follow; 1234 int error; 1235 1236 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 1237 1238 error = do_sys_statat(l, SCARG(uap, fd), SCARG_P32(uap, path), 1239 follow, &sb); 1240 if (error) 1241 return error; 1242 netbsd32_from_stat(&sb, &sb32); 1243 return copyout(&sb32, SCARG_P32(uap, buf), sizeof(sb32)); 1244 } 1245 1246 int 1247 netbsd32_utimensat(struct lwp *l, const struct netbsd32_utimensat_args *uap, 1248 register_t *retval) 1249 { 1250 /* { 1251 syscallarg(int) fd; 1252 syscallarg(netbsd32_charp) path; 1253 syscallarg(netbsd32_timespecp_t) tptr; 1254 syscallarg(int) flag; 1255 } */ 1256 struct timespec ts[2], *tsp; 1257 int follow; 1258 int error; 1259 1260 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp); 1261 if (error != 0) 1262 return error; 1263 1264 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 1265 1266 return do_sys_utimensat(l, SCARG(uap, fd), NULL, 1267 SCARG_P32(uap, path), follow, tsp, UIO_SYSSPACE); 1268 } 1269 1270 int 1271 netbsd32_openat(struct lwp *l, const struct netbsd32_openat_args *uap, 1272 register_t *retval) 1273 { 1274 /* { 1275 syscallarg(int) fd; 1276 syscallarg(netbsd32_charp) path; 1277 syscallarg(int) oflags; 1278 syscallarg(mode_t) mode; 1279 } */ 1280 struct sys_openat_args ua; 1281 1282 NETBSD32TO64_UAP(fd); 1283 NETBSD32TOP_UAP(path, const char); 1284 NETBSD32TO64_UAP(oflags); 1285 NETBSD32TO64_UAP(mode); 1286 1287 return sys_openat(l, &ua, retval); 1288 } 1289 1290 int 1291 netbsd32_readlinkat(struct lwp *l, const struct netbsd32_readlinkat_args *uap, 1292 register_t *retval) 1293 { 1294 /* { 1295 syscallarg(int) fd; 1296 syscallarg(netbsd32_charp) path; 1297 syscallarg(netbsd32_charp) buf; 1298 syscallarg(netbsd32_size_t) bufsize; 1299 } */ 1300 struct sys_readlinkat_args ua; 1301 1302 NETBSD32TO64_UAP(fd); 1303 NETBSD32TOP_UAP(path, const char *); 1304 NETBSD32TOP_UAP(buf, char *); 1305 NETBSD32TOX_UAP(bufsize, size_t); 1306 1307 return sys_readlinkat(l, &ua, retval); 1308 } 1309 1310 int 1311 netbsd32_symlinkat(struct lwp *l, const struct netbsd32_symlinkat_args *uap, 1312 register_t *retval) 1313 { 1314 /* { 1315 syscallarg(netbsd32_charp) path1; 1316 syscallarg(int) fd; 1317 syscallarg(netbsd32_charp) path2; 1318 } */ 1319 struct sys_symlinkat_args ua; 1320 1321 NETBSD32TOP_UAP(path1, const char *); 1322 NETBSD32TO64_UAP(fd); 1323 NETBSD32TOP_UAP(path2, const char *); 1324 1325 return sys_symlinkat(l, &ua, retval); 1326 } 1327 1328 int 1329 netbsd32_unlinkat(struct lwp *l, const struct netbsd32_unlinkat_args *uap, 1330 register_t *retval) 1331 { 1332 /* { 1333 syscallarg(int) fd; 1334 syscallarg(netbsd32_charp) path; 1335 syscallarg(int) flag; 1336 } */ 1337 struct sys_unlinkat_args ua; 1338 1339 NETBSD32TO64_UAP(fd); 1340 NETBSD32TOP_UAP(path, const char *); 1341 NETBSD32TO64_UAP(flag); 1342 1343 return sys_unlinkat(l, &ua, retval); 1344 } 1345 1346 int 1347 netbsd32_futimens(struct lwp *l, const struct netbsd32_futimens_args *uap, 1348 register_t *retval) 1349 { 1350 /* { 1351 syscallarg(int) fd; 1352 syscallarg(netbsd32_timespecp_t) tptr; 1353 } */ 1354 struct timespec ts[2], *tsp; 1355 file_t *fp; 1356 int error; 1357 1358 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp); 1359 if (error != 0) 1360 return error; 1361 1362 /* fd_getvnode() will use the descriptor for us */ 1363 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 1364 return (error); 1365 error = do_sys_utimensat(l, AT_FDCWD, fp->f_vnode, NULL, 0, 1366 tsp, UIO_SYSSPACE); 1367 fd_putfile(SCARG(uap, fd)); 1368 return (error); 1369 } 1370