netbsd32_fs.c revision 1.80.10.2
1 /* $NetBSD: netbsd32_fs.c,v 1.80.10.2 2020/04/08 14:08:01 martin 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.80.10.2 2020/04/08 14:08:01 martin 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(sb32)); 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 int error; 738 char *path; 739 char *bp, *bend; 740 int len = (int)SCARG(uap, length); 741 int lenused; 742 struct vnode *dvp; 743 744 if (len > MAXPATHLEN*4) 745 len = MAXPATHLEN*4; 746 else if (len < 2) 747 return ERANGE; 748 749 path = kmem_alloc(len, KM_SLEEP); 750 bp = &path[len]; 751 bend = bp; 752 *(--bp) = '\0'; 753 754 /* 755 * 5th argument here is "max number of vnodes to traverse". 756 * Since each entry takes up at least 2 bytes in the output buffer, 757 * limit it to N/2 vnodes for an N byte buffer. 758 */ 759 #define GETCWD_CHECK_ACCESS 0x0001 760 dvp = cwdcdir(); 761 error = getcwd_common (dvp, NULL, &bp, path, len/2, 762 GETCWD_CHECK_ACCESS, l); 763 vrele(dvp); 764 765 if (error) 766 goto out; 767 lenused = bend - bp; 768 *retval = lenused; 769 /* put the result into user buffer */ 770 error = copyout(bp, SCARG_P32(uap, bufp), lenused); 771 772 out: 773 kmem_free(path, len); 774 return error; 775 } 776 777 int 778 netbsd32___mount50(struct lwp *l, const struct netbsd32___mount50_args *uap, 779 register_t *retval) 780 { 781 /* { 782 syscallarg(netbsd32_charp) type; 783 syscallarg(netbsd32_charp) path; 784 syscallarg(int) flags; 785 syscallarg(netbsd32_voidp) data; 786 syscallarg(netbsd32_size_t) data_len; 787 } */ 788 char mtype[MNAMELEN]; 789 union { 790 struct netbsd32_ufs_args ufs_args; 791 struct netbsd32_mfs_args mfs_args; 792 struct netbsd32_iso_args iso_args; 793 struct netbsd32_nfs_args nfs_args; 794 struct netbsd32_msdosfs_args msdosfs_args; 795 struct netbsd32_tmpfs_args tmpfs_args; 796 struct netbsd32_null_args null_args; 797 } fs_args32; 798 union { 799 struct ufs_args ufs_args; 800 struct mfs_args mfs_args; 801 struct iso_args iso_args; 802 struct nfs_args nfs_args; 803 struct msdosfs_args msdosfs_args; 804 struct tmpfs_args tmpfs_args; 805 struct null_args null_args; 806 } fs_args; 807 const char *type = SCARG_P32(uap, type); 808 const char *path = SCARG_P32(uap, path); 809 int flags = SCARG(uap, flags); 810 void *data = SCARG_P32(uap, data); 811 size_t data_len = SCARG(uap, data_len); 812 enum uio_seg data_seg; 813 size_t len; 814 int error; 815 816 error = copyinstr(type, mtype, sizeof(mtype), &len); 817 if (error) 818 return error; 819 if (strcmp(mtype, MOUNT_TMPFS) == 0) { 820 if (data_len != sizeof(fs_args32.tmpfs_args)) 821 return EINVAL; 822 if ((flags & MNT_GETARGS) == 0) { 823 error = copyin(data, &fs_args32.tmpfs_args, 824 sizeof(fs_args32.tmpfs_args)); 825 if (error) 826 return error; 827 fs_args.tmpfs_args.ta_version = 828 fs_args32.tmpfs_args.ta_version; 829 fs_args.tmpfs_args.ta_nodes_max = 830 fs_args32.tmpfs_args.ta_nodes_max; 831 fs_args.tmpfs_args.ta_size_max = 832 fs_args32.tmpfs_args.ta_size_max; 833 fs_args.tmpfs_args.ta_root_uid = 834 fs_args32.tmpfs_args.ta_root_uid; 835 fs_args.tmpfs_args.ta_root_gid = 836 fs_args32.tmpfs_args.ta_root_gid; 837 fs_args.tmpfs_args.ta_root_mode = 838 fs_args32.tmpfs_args.ta_root_mode; 839 } 840 data_seg = UIO_SYSSPACE; 841 data = &fs_args.tmpfs_args; 842 data_len = sizeof(fs_args.tmpfs_args); 843 } else if (strcmp(mtype, MOUNT_MFS) == 0) { 844 if (data_len != sizeof(fs_args32.mfs_args)) 845 return EINVAL; 846 if ((flags & MNT_GETARGS) == 0) { 847 error = copyin(data, &fs_args32.mfs_args, 848 sizeof(fs_args32.mfs_args)); 849 if (error) 850 return error; 851 fs_args.mfs_args.fspec = 852 NETBSD32PTR64(fs_args32.mfs_args.fspec); 853 memset(&fs_args.mfs_args._pad1, 0, 854 sizeof(fs_args.mfs_args._pad1)); 855 fs_args.mfs_args.base = 856 NETBSD32PTR64(fs_args32.mfs_args.base); 857 fs_args.mfs_args.size = fs_args32.mfs_args.size; 858 } 859 data_seg = UIO_SYSSPACE; 860 data = &fs_args.mfs_args; 861 data_len = sizeof(fs_args.mfs_args); 862 } else if ((strcmp(mtype, MOUNT_UFS) == 0) || 863 (strcmp(mtype, MOUNT_EXT2FS) == 0) || 864 (strcmp(mtype, MOUNT_LFS) == 0)) { 865 if (data_len > sizeof(fs_args32.ufs_args)) 866 return EINVAL; 867 if ((flags & MNT_GETARGS) == 0) { 868 error = copyin(data, &fs_args32.ufs_args, 869 sizeof(fs_args32.ufs_args)); 870 if (error) 871 return error; 872 fs_args.ufs_args.fspec = 873 NETBSD32PTR64(fs_args32.ufs_args.fspec); 874 } 875 data_seg = UIO_SYSSPACE; 876 data = &fs_args.ufs_args; 877 data_len = sizeof(fs_args.ufs_args); 878 } else if (strcmp(mtype, MOUNT_CD9660) == 0) { 879 if (data_len != sizeof(fs_args32.iso_args)) 880 return EINVAL; 881 if ((flags & MNT_GETARGS) == 0) { 882 error = copyin(data, &fs_args32.iso_args, 883 sizeof(fs_args32.iso_args)); 884 if (error) 885 return error; 886 fs_args.iso_args.fspec = 887 NETBSD32PTR64(fs_args32.iso_args.fspec); 888 memset(&fs_args.iso_args._pad1, 0, 889 sizeof(fs_args.iso_args._pad1)); 890 fs_args.iso_args.flags = fs_args32.iso_args.flags; 891 } 892 data_seg = UIO_SYSSPACE; 893 data = &fs_args.iso_args; 894 data_len = sizeof(fs_args.iso_args); 895 } else if (strcmp(mtype, MOUNT_MSDOS) == 0) { 896 if (data_len != sizeof(fs_args32.msdosfs_args)) 897 return EINVAL; 898 if ((flags & MNT_GETARGS) == 0) { 899 error = copyin(data, &fs_args32.msdosfs_args, 900 sizeof(fs_args32.msdosfs_args)); 901 if (error) 902 return error; 903 fs_args.msdosfs_args.fspec = 904 NETBSD32PTR64(fs_args32.msdosfs_args.fspec); 905 memset(&fs_args.msdosfs_args._pad1, 0, 906 sizeof(fs_args.msdosfs_args._pad1)); 907 fs_args.msdosfs_args.uid = 908 fs_args32.msdosfs_args.uid; 909 fs_args.msdosfs_args.gid = 910 fs_args32.msdosfs_args.gid; 911 fs_args.msdosfs_args.mask = 912 fs_args32.msdosfs_args.mask; 913 fs_args.msdosfs_args.flags = 914 fs_args32.msdosfs_args.flags; 915 fs_args.msdosfs_args.version = 916 fs_args32.msdosfs_args.version; 917 fs_args.msdosfs_args.dirmask = 918 fs_args32.msdosfs_args.dirmask; 919 fs_args.msdosfs_args.gmtoff = 920 fs_args32.msdosfs_args.gmtoff; 921 } 922 data_seg = UIO_SYSSPACE; 923 data = &fs_args.msdosfs_args; 924 data_len = sizeof(fs_args.msdosfs_args); 925 } else if (strcmp(mtype, MOUNT_NFS) == 0) { 926 if (data_len != sizeof(fs_args32.nfs_args)) 927 return EINVAL; 928 if ((flags & MNT_GETARGS) == 0) { 929 error = copyin(data, &fs_args32.nfs_args, 930 sizeof(fs_args32.nfs_args)); 931 if (error) 932 return error; 933 fs_args.nfs_args.version = fs_args32.nfs_args.version; 934 fs_args.nfs_args.addr = 935 NETBSD32PTR64(fs_args32.nfs_args.addr); 936 memcpy(&fs_args.nfs_args.addrlen, 937 &fs_args32.nfs_args.addrlen, 938 offsetof(struct nfs_args, fh) 939 - offsetof(struct nfs_args, addrlen)); 940 fs_args.nfs_args.fh = 941 NETBSD32PTR64(fs_args32.nfs_args.fh); 942 memcpy(&fs_args.nfs_args.fhsize, 943 &fs_args32.nfs_args.fhsize, 944 offsetof(struct nfs_args, hostname) 945 - offsetof(struct nfs_args, fhsize)); 946 fs_args.nfs_args.hostname = 947 NETBSD32PTR64(fs_args32.nfs_args.hostname); 948 } 949 data_seg = UIO_SYSSPACE; 950 data = &fs_args.nfs_args; 951 data_len = sizeof(fs_args.nfs_args); 952 } else if (strcmp(mtype, MOUNT_NULL) == 0) { 953 if (data_len > sizeof(fs_args32.null_args)) 954 return EINVAL; 955 if ((flags & MNT_GETARGS) == 0) { 956 error = copyin(data, &fs_args32.null_args, 957 sizeof(fs_args32.null_args)); 958 if (error) 959 return error; 960 fs_args.null_args.la.target = 961 NETBSD32PTR64(fs_args32.null_args.la.target); 962 } 963 data_seg = UIO_SYSSPACE; 964 data = &fs_args.null_args; 965 data_len = sizeof(fs_args.null_args); 966 } else { 967 data_seg = UIO_USERSPACE; 968 } 969 error = do_sys_mount(l, mtype, UIO_SYSSPACE, path, flags, data, data_seg, 970 data_len, retval); 971 if (error) 972 return error; 973 if (flags & MNT_GETARGS) { 974 data_len = *retval; 975 if (strcmp(mtype, MOUNT_TMPFS) == 0) { 976 if (data_len != sizeof(fs_args.tmpfs_args)) 977 return EINVAL; 978 fs_args32.tmpfs_args.ta_version = 979 fs_args.tmpfs_args.ta_version; 980 fs_args32.tmpfs_args.ta_nodes_max = 981 fs_args.tmpfs_args.ta_nodes_max; 982 fs_args32.tmpfs_args.ta_size_max = 983 fs_args.tmpfs_args.ta_size_max; 984 fs_args32.tmpfs_args.ta_root_uid = 985 fs_args.tmpfs_args.ta_root_uid; 986 fs_args32.tmpfs_args.ta_root_gid = 987 fs_args.tmpfs_args.ta_root_gid; 988 fs_args32.tmpfs_args.ta_root_mode = 989 fs_args.tmpfs_args.ta_root_mode; 990 error = copyout(&fs_args32.tmpfs_args, data, 991 sizeof(fs_args32.tmpfs_args)); 992 } else if (strcmp(mtype, MOUNT_MFS) == 0) { 993 if (data_len != sizeof(fs_args.mfs_args)) 994 return EINVAL; 995 NETBSD32PTR32(fs_args32.mfs_args.fspec, 996 fs_args.mfs_args.fspec); 997 memset(&fs_args32.mfs_args._pad1, 0, 998 sizeof(fs_args32.mfs_args._pad1)); 999 NETBSD32PTR32(fs_args32.mfs_args.base, 1000 fs_args.mfs_args.base); 1001 fs_args32.mfs_args.size = fs_args.mfs_args.size; 1002 error = copyout(&fs_args32.mfs_args, data, 1003 sizeof(fs_args32.mfs_args)); 1004 } else if (strcmp(mtype, MOUNT_UFS) == 0) { 1005 if (data_len != sizeof(fs_args.ufs_args)) 1006 return EINVAL; 1007 NETBSD32PTR32(fs_args32.ufs_args.fspec, 1008 fs_args.ufs_args.fspec); 1009 error = copyout(&fs_args32.ufs_args, data, 1010 sizeof(fs_args32.ufs_args)); 1011 } else if (strcmp(mtype, MOUNT_CD9660) == 0) { 1012 if (data_len != sizeof(fs_args.iso_args)) 1013 return EINVAL; 1014 NETBSD32PTR32(fs_args32.iso_args.fspec, 1015 fs_args.iso_args.fspec); 1016 memset(&fs_args32.iso_args._pad1, 0, 1017 sizeof(fs_args32.iso_args._pad1)); 1018 fs_args32.iso_args.flags = fs_args.iso_args.flags; 1019 error = copyout(&fs_args32.iso_args, data, 1020 sizeof(fs_args32.iso_args)); 1021 } else if (strcmp(mtype, MOUNT_NFS) == 0) { 1022 if (data_len != sizeof(fs_args.nfs_args)) 1023 return EINVAL; 1024 error = copyin(data, &fs_args32.nfs_args, 1025 sizeof(fs_args32.nfs_args)); 1026 if (error) 1027 return error; 1028 fs_args.nfs_args.version = fs_args32.nfs_args.version; 1029 NETBSD32PTR32(fs_args32.nfs_args.addr, 1030 fs_args.nfs_args.addr); 1031 memcpy(&fs_args32.nfs_args.addrlen, 1032 &fs_args.nfs_args.addrlen, 1033 offsetof(struct nfs_args, fh) 1034 - offsetof(struct nfs_args, addrlen)); 1035 NETBSD32PTR32(fs_args32.nfs_args.fh, 1036 fs_args.nfs_args.fh); 1037 memcpy(&fs_args32.nfs_args.fhsize, 1038 &fs_args.nfs_args.fhsize, 1039 offsetof(struct nfs_args, hostname) 1040 - offsetof(struct nfs_args, fhsize)); 1041 NETBSD32PTR32(fs_args32.nfs_args.hostname, 1042 fs_args.nfs_args.hostname); 1043 error = copyout(&fs_args32.nfs_args, data, 1044 sizeof(fs_args32.nfs_args)); 1045 } else if (strcmp(mtype, MOUNT_NULL) == 0) { 1046 if (data_len != sizeof(fs_args.null_args)) 1047 return EINVAL; 1048 NETBSD32PTR32(fs_args32.null_args.la.target, 1049 fs_args.null_args.la.target); 1050 error = copyout(&fs_args32.null_args, data, 1051 sizeof(fs_args32.null_args)); 1052 } 1053 } 1054 return error; 1055 } 1056 1057 int 1058 netbsd32_linkat(struct lwp *l, const struct netbsd32_linkat_args *uap, 1059 register_t *retval) 1060 { 1061 /* { 1062 syscallarg(int) fd1; 1063 syscallarg(const netbsd32_charp) name1; 1064 syscallarg(int) fd2; 1065 syscallarg(const netbsd32_charp) name2; 1066 syscallarg(int) flags; 1067 } */ 1068 struct sys_linkat_args ua; 1069 1070 NETBSD32TO64_UAP(fd1); 1071 NETBSD32TOP_UAP(name1, const char); 1072 NETBSD32TO64_UAP(fd2); 1073 NETBSD32TOP_UAP(name2, const char); 1074 NETBSD32TO64_UAP(flags); 1075 1076 return sys_linkat(l, &ua, retval); 1077 } 1078 1079 int 1080 netbsd32_renameat(struct lwp *l, const struct netbsd32_renameat_args *uap, 1081 register_t *retval) 1082 { 1083 /* { 1084 syscallarg(int) fromfd; 1085 syscallarg(const netbsd32_charp) from; 1086 syscallarg(int) tofd; 1087 syscallarg(const netbsd32_charp) to; 1088 } */ 1089 struct sys_renameat_args ua; 1090 1091 NETBSD32TO64_UAP(fromfd); 1092 NETBSD32TOP_UAP(from, const char); 1093 NETBSD32TO64_UAP(tofd); 1094 NETBSD32TOP_UAP(to, const char); 1095 1096 return sys_renameat(l, &ua, retval); 1097 } 1098 1099 int 1100 netbsd32_mkfifoat(struct lwp *l, const struct netbsd32_mkfifoat_args *uap, 1101 register_t *retval) 1102 { 1103 /* { 1104 syscallarg(int) fd; 1105 syscallarg(const netbsd32_charp) path; 1106 syscallarg(mode_t) mode; 1107 } */ 1108 struct sys_mkfifoat_args ua; 1109 1110 NETBSD32TO64_UAP(fd); 1111 NETBSD32TOP_UAP(path, const char); 1112 NETBSD32TO64_UAP(mode); 1113 1114 return sys_mkfifoat(l, &ua, retval); 1115 } 1116 1117 int 1118 netbsd32_mknodat(struct lwp *l, const struct netbsd32_mknodat_args *uap, 1119 register_t *retval) 1120 { 1121 /* { 1122 syscallarg(int) fd; 1123 syscallarg(netbsd32_charp) path; 1124 syscallarg(mode_t) mode; 1125 syscallarg(int) pad; 1126 syscallarg(netbsd32_dev_t) dev; 1127 } */ 1128 struct sys_mknodat_args ua; 1129 1130 NETBSD32TO64_UAP(fd); 1131 NETBSD32TOP_UAP(path, const char); 1132 NETBSD32TO64_UAP(mode); 1133 NETBSD32TO64_UAP(PAD); 1134 NETBSD32TO64_UAP(dev); 1135 1136 return sys_mknodat(l, &ua, retval); 1137 } 1138 1139 int 1140 netbsd32_mkdirat(struct lwp *l, const struct netbsd32_mkdirat_args *uap, 1141 register_t *retval) 1142 { 1143 /* { 1144 syscallarg(int) fd; 1145 syscallarg(netbsd32_charp) path; 1146 syscallarg(mode_t) mode; 1147 } */ 1148 struct sys_mkdirat_args ua; 1149 1150 NETBSD32TO64_UAP(fd); 1151 NETBSD32TOP_UAP(path, const char); 1152 NETBSD32TO64_UAP(mode); 1153 1154 return sys_mkdirat(l, &ua, retval); 1155 } 1156 1157 int 1158 netbsd32_faccessat(struct lwp *l, const struct netbsd32_faccessat_args *uap, 1159 register_t *retval) 1160 { 1161 /* { 1162 syscallarg(int) fd; 1163 syscallarg(netbsd32_charp) path; 1164 syscallarg(int) amode; 1165 syscallarg(int) flag; 1166 } */ 1167 struct sys_faccessat_args ua; 1168 1169 NETBSD32TO64_UAP(fd); 1170 NETBSD32TOP_UAP(path, const char); 1171 NETBSD32TO64_UAP(amode); 1172 NETBSD32TO64_UAP(flag); 1173 1174 return sys_faccessat(l, &ua, retval); 1175 } 1176 1177 int 1178 netbsd32_fchmodat(struct lwp *l, const struct netbsd32_fchmodat_args *uap, 1179 register_t *retval) 1180 { 1181 /* { 1182 syscallarg(int) fd; 1183 syscallarg(netbsd32_charp) path; 1184 syscallarg(mode_t) mode; 1185 syscallarg(int) flag; 1186 } */ 1187 struct sys_fchmodat_args ua; 1188 1189 NETBSD32TO64_UAP(fd); 1190 NETBSD32TOP_UAP(path, const char); 1191 NETBSD32TO64_UAP(mode); 1192 NETBSD32TO64_UAP(flag); 1193 1194 return sys_fchmodat(l, &ua, retval); 1195 } 1196 1197 int 1198 netbsd32_fchownat(struct lwp *l, const struct netbsd32_fchownat_args *uap, 1199 register_t *retval) 1200 { 1201 /* { 1202 syscallarg(int) fd; 1203 syscallarg(netbsd32_charp) path; 1204 syscallarg(uid_t) owner; 1205 syscallarg(gid_t) group; 1206 syscallarg(int) flag; 1207 } */ 1208 struct sys_fchownat_args ua; 1209 1210 NETBSD32TO64_UAP(fd); 1211 NETBSD32TOP_UAP(path, const char); 1212 NETBSD32TO64_UAP(owner); 1213 NETBSD32TO64_UAP(group); 1214 NETBSD32TO64_UAP(flag); 1215 1216 return sys_fchownat(l, &ua, retval); 1217 } 1218 1219 int 1220 netbsd32_fstatat(struct lwp *l, const struct netbsd32_fstatat_args *uap, 1221 register_t *retval) 1222 { 1223 /* { 1224 syscallarg(int) fd; 1225 syscallarg(netbsd32_charp) path; 1226 syscallarg(netbsd32_statp_t) buf; 1227 syscallarg(int) flag; 1228 } */ 1229 struct netbsd32_stat sb32; 1230 struct stat sb; 1231 int follow; 1232 int error; 1233 1234 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 1235 1236 error = do_sys_statat(l, SCARG(uap, fd), SCARG_P32(uap, path), 1237 follow, &sb); 1238 if (error) 1239 return error; 1240 netbsd32_from_stat(&sb, &sb32); 1241 return copyout(&sb32, SCARG_P32(uap, buf), sizeof(sb32)); 1242 } 1243 1244 int 1245 netbsd32_utimensat(struct lwp *l, const struct netbsd32_utimensat_args *uap, 1246 register_t *retval) 1247 { 1248 /* { 1249 syscallarg(int) fd; 1250 syscallarg(netbsd32_charp) path; 1251 syscallarg(netbsd32_timespecp_t) tptr; 1252 syscallarg(int) flag; 1253 } */ 1254 struct timespec ts[2], *tsp; 1255 int follow; 1256 int error; 1257 1258 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp); 1259 if (error != 0) 1260 return error; 1261 1262 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 1263 1264 return do_sys_utimensat(l, SCARG(uap, fd), NULL, 1265 SCARG_P32(uap, path), follow, tsp, UIO_SYSSPACE); 1266 } 1267 1268 int 1269 netbsd32_openat(struct lwp *l, const struct netbsd32_openat_args *uap, 1270 register_t *retval) 1271 { 1272 /* { 1273 syscallarg(int) fd; 1274 syscallarg(netbsd32_charp) path; 1275 syscallarg(int) oflags; 1276 syscallarg(mode_t) mode; 1277 } */ 1278 struct sys_openat_args ua; 1279 1280 NETBSD32TO64_UAP(fd); 1281 NETBSD32TOP_UAP(path, const char); 1282 NETBSD32TO64_UAP(oflags); 1283 NETBSD32TO64_UAP(mode); 1284 1285 return sys_openat(l, &ua, retval); 1286 } 1287 1288 int 1289 netbsd32_readlinkat(struct lwp *l, const struct netbsd32_readlinkat_args *uap, 1290 register_t *retval) 1291 { 1292 /* { 1293 syscallarg(int) fd; 1294 syscallarg(netbsd32_charp) path; 1295 syscallarg(netbsd32_charp) buf; 1296 syscallarg(netbsd32_size_t) bufsize; 1297 } */ 1298 struct sys_readlinkat_args ua; 1299 1300 NETBSD32TO64_UAP(fd); 1301 NETBSD32TOP_UAP(path, const char *); 1302 NETBSD32TOP_UAP(buf, char *); 1303 NETBSD32TOX_UAP(bufsize, size_t); 1304 1305 return sys_readlinkat(l, &ua, retval); 1306 } 1307 1308 int 1309 netbsd32_symlinkat(struct lwp *l, const struct netbsd32_symlinkat_args *uap, 1310 register_t *retval) 1311 { 1312 /* { 1313 syscallarg(netbsd32_charp) path1; 1314 syscallarg(int) fd; 1315 syscallarg(netbsd32_charp) path2; 1316 } */ 1317 struct sys_symlinkat_args ua; 1318 1319 NETBSD32TOP_UAP(path1, const char *); 1320 NETBSD32TO64_UAP(fd); 1321 NETBSD32TOP_UAP(path2, const char *); 1322 1323 return sys_symlinkat(l, &ua, retval); 1324 } 1325 1326 int 1327 netbsd32_unlinkat(struct lwp *l, const struct netbsd32_unlinkat_args *uap, 1328 register_t *retval) 1329 { 1330 /* { 1331 syscallarg(int) fd; 1332 syscallarg(netbsd32_charp) path; 1333 syscallarg(int) flag; 1334 } */ 1335 struct sys_unlinkat_args ua; 1336 1337 NETBSD32TO64_UAP(fd); 1338 NETBSD32TOP_UAP(path, const char *); 1339 NETBSD32TO64_UAP(flag); 1340 1341 return sys_unlinkat(l, &ua, retval); 1342 } 1343 1344 int 1345 netbsd32_futimens(struct lwp *l, const struct netbsd32_futimens_args *uap, 1346 register_t *retval) 1347 { 1348 /* { 1349 syscallarg(int) fd; 1350 syscallarg(netbsd32_timespecp_t) tptr; 1351 } */ 1352 struct timespec ts[2], *tsp; 1353 file_t *fp; 1354 int error; 1355 1356 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp); 1357 if (error != 0) 1358 return error; 1359 1360 /* fd_getvnode() will use the descriptor for us */ 1361 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 1362 return (error); 1363 error = do_sys_utimensat(l, AT_FDCWD, fp->f_vnode, NULL, 0, 1364 tsp, UIO_SYSSPACE); 1365 fd_putfile(SCARG(uap, fd)); 1366 return (error); 1367 } 1368
Indexes created Fri Sep 26 20:09:58 GMT 2025