netbsd32_fs.c revision 1.53.2.2
1 /* $NetBSD: netbsd32_fs.c,v 1.53.2.2 2010/03/11 15:03:17 yamt 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.53.2.2 2010/03/11 15:03:17 yamt Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/malloc.h> 35 #include <sys/mount.h> 36 #include <sys/socket.h> 37 #include <sys/socketvar.h> 38 #include <sys/stat.h> 39 #include <sys/time.h> 40 #include <sys/ktrace.h> 41 #include <sys/resourcevar.h> 42 #include <sys/vnode.h> 43 #include <sys/file.h> 44 #include <sys/filedesc.h> 45 #include <sys/namei.h> 46 #include <sys/statvfs.h> 47 #include <sys/syscallargs.h> 48 #include <sys/proc.h> 49 #include <sys/dirent.h> 50 #include <sys/kauth.h> 51 #include <sys/vfs_syscalls.h> 52 53 #include <fs/cd9660/cd9660_mount.h> 54 #include <ufs/ufs/ufsmount.h> 55 56 #include <compat/netbsd32/netbsd32.h> 57 #include <compat/netbsd32/netbsd32_syscallargs.h> 58 #include <compat/netbsd32/netbsd32_conv.h> 59 #include <compat/sys/mount.h> 60 61 62 static int dofilereadv32(int, struct file *, struct netbsd32_iovec *, 63 int, off_t *, int, register_t *); 64 static int dofilewritev32(int, struct file *, struct netbsd32_iovec *, 65 int, off_t *, int, register_t *); 66 67 struct iovec * 68 netbsd32_get_iov(struct netbsd32_iovec *iov32, int iovlen, struct iovec *aiov, 69 int aiov_len) 70 { 71 #define N_IOV32 8 72 struct netbsd32_iovec aiov32[N_IOV32]; 73 struct iovec *iov = aiov; 74 struct iovec *iovp; 75 int i, n, j; 76 int error; 77 78 if (iovlen < 0 || iovlen > IOV_MAX) 79 return NULL; 80 81 if (iovlen > aiov_len) 82 iov = malloc(iovlen * sizeof (*iov), M_TEMP, M_WAITOK); 83 84 iovp = iov; 85 for (i = 0; i < iovlen; iov32 += N_IOV32, i += N_IOV32) { 86 n = iovlen - i; 87 if (n > N_IOV32) 88 n = N_IOV32; 89 error = copyin(iov32, aiov32, n * sizeof (*iov32)); 90 if (error != 0) { 91 if (iov != aiov) 92 free(iov, M_TEMP); 93 return NULL; 94 } 95 for (j = 0; j < n; iovp++, j++) { 96 iovp->iov_base = NETBSD32PTR64(aiov32[j].iov_base); 97 iovp->iov_len = aiov32[j].iov_len; 98 } 99 } 100 return iov; 101 #undef N_IOV32 102 } 103 104 int 105 netbsd32_readv(struct lwp *l, const struct netbsd32_readv_args *uap, register_t *retval) 106 { 107 /* { 108 syscallarg(int) fd; 109 syscallarg(const netbsd32_iovecp_t) iovp; 110 syscallarg(int) iovcnt; 111 } */ 112 int fd = SCARG(uap, fd); 113 file_t *fp; 114 115 if ((fp = fd_getfile(fd)) == NULL) 116 return (EBADF); 117 118 if ((fp->f_flag & FREAD) == 0) { 119 fd_putfile(fd); 120 return (EBADF); 121 } 122 123 return (dofilereadv32(fd, fp, 124 (struct netbsd32_iovec *)SCARG_P32(uap, iovp), 125 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval)); 126 } 127 128 /* Damn thing copies in the iovec! */ 129 int 130 dofilereadv32(int fd, struct file *fp, struct netbsd32_iovec *iovp, int iovcnt, off_t *offset, int flags, register_t *retval) 131 { 132 struct uio auio; 133 struct iovec *iov; 134 struct iovec *needfree; 135 struct iovec aiov[UIO_SMALLIOV]; 136 long i, cnt, error = 0; 137 u_int iovlen; 138 struct iovec *ktriov = NULL; 139 140 /* note: can't use iovlen until iovcnt is validated */ 141 iovlen = iovcnt * sizeof(struct iovec); 142 if ((u_int)iovcnt > UIO_SMALLIOV) { 143 if ((u_int)iovcnt > IOV_MAX) { 144 error = EINVAL; 145 goto out; 146 } 147 iov = malloc(iovlen, M_IOV, M_WAITOK); 148 needfree = iov; 149 } else if ((u_int)iovcnt > 0) { 150 iov = aiov; 151 needfree = NULL; 152 } else { 153 error = EINVAL; 154 goto out; 155 } 156 157 auio.uio_iov = iov; 158 auio.uio_iovcnt = iovcnt; 159 auio.uio_rw = UIO_READ; 160 auio.uio_vmspace = curproc->p_vmspace; 161 error = netbsd32_to_iovecin(iovp, iov, iovcnt); 162 if (error) 163 goto done; 164 auio.uio_resid = 0; 165 for (i = 0; i < iovcnt; i++) { 166 auio.uio_resid += iov->iov_len; 167 /* 168 * Reads return ssize_t because -1 is returned on error. 169 * Therefore we must restrict the length to SSIZE_MAX to 170 * avoid garbage return values. 171 */ 172 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) { 173 error = EINVAL; 174 goto done; 175 } 176 iov++; 177 } 178 179 /* 180 * if tracing, save a copy of iovec 181 */ 182 if (ktrpoint(KTR_GENIO)) { 183 ktriov = malloc(iovlen, M_TEMP, M_WAITOK); 184 memcpy((void *)ktriov, (void *)auio.uio_iov, iovlen); 185 } 186 187 cnt = auio.uio_resid; 188 error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred, flags); 189 if (error) 190 if (auio.uio_resid != cnt && (error == ERESTART || 191 error == EINTR || error == EWOULDBLOCK)) 192 error = 0; 193 cnt -= auio.uio_resid; 194 195 if (ktriov != NULL) { 196 ktrgeniov(fd, UIO_READ, ktriov, cnt, error); 197 free(ktriov, M_TEMP); 198 } 199 200 *retval = cnt; 201 done: 202 if (needfree) 203 free(needfree, M_IOV); 204 out: 205 fd_putfile(fd); 206 return (error); 207 } 208 209 int 210 netbsd32_writev(struct lwp *l, const struct netbsd32_writev_args *uap, register_t *retval) 211 { 212 /* { 213 syscallarg(int) fd; 214 syscallarg(const netbsd32_iovecp_t) iovp; 215 syscallarg(int) iovcnt; 216 } */ 217 int fd = SCARG(uap, fd); 218 file_t *fp; 219 220 if ((fp = fd_getfile(fd)) == NULL) 221 return (EBADF); 222 223 if ((fp->f_flag & FWRITE) == 0) { 224 fd_putfile(fd); 225 return (EBADF); 226 } 227 228 return (dofilewritev32(fd, fp, 229 (struct netbsd32_iovec *)SCARG_P32(uap, iovp), 230 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval)); 231 } 232 233 int 234 dofilewritev32(int fd, struct file *fp, struct netbsd32_iovec *iovp, int iovcnt, off_t *offset, int flags, register_t *retval) 235 { 236 struct uio auio; 237 struct iovec *iov; 238 struct iovec *needfree; 239 struct iovec aiov[UIO_SMALLIOV]; 240 long i, cnt, error = 0; 241 u_int iovlen; 242 struct iovec *ktriov = NULL; 243 244 /* note: can't use iovlen until iovcnt is validated */ 245 iovlen = iovcnt * sizeof(struct iovec); 246 if ((u_int)iovcnt > UIO_SMALLIOV) { 247 if ((u_int)iovcnt > IOV_MAX) { 248 error = EINVAL; 249 goto out; 250 } 251 iov = malloc(iovlen, M_IOV, M_WAITOK); 252 needfree = iov; 253 } else if ((u_int)iovcnt > 0) { 254 iov = aiov; 255 needfree = NULL; 256 } else { 257 error = EINVAL; 258 goto out; 259 } 260 261 auio.uio_iov = iov; 262 auio.uio_iovcnt = iovcnt; 263 auio.uio_rw = UIO_WRITE; 264 auio.uio_vmspace = curproc->p_vmspace; 265 error = netbsd32_to_iovecin(iovp, iov, iovcnt); 266 if (error) 267 goto done; 268 auio.uio_resid = 0; 269 for (i = 0; i < iovcnt; i++) { 270 auio.uio_resid += iov->iov_len; 271 /* 272 * Writes return ssize_t because -1 is returned on error. 273 * Therefore we must restrict the length to SSIZE_MAX to 274 * avoid garbage return values. 275 */ 276 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) { 277 error = EINVAL; 278 goto done; 279 } 280 iov++; 281 } 282 283 /* 284 * if tracing, save a copy of iovec 285 */ 286 if (ktrpoint(KTR_GENIO)) { 287 ktriov = malloc(iovlen, M_TEMP, M_WAITOK); 288 memcpy((void *)ktriov, (void *)auio.uio_iov, iovlen); 289 } 290 291 cnt = auio.uio_resid; 292 error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred, flags); 293 if (error) { 294 if (auio.uio_resid != cnt && (error == ERESTART || 295 error == EINTR || error == EWOULDBLOCK)) 296 error = 0; 297 if (error == EPIPE) { 298 mutex_enter(proc_lock); 299 psignal(curproc, SIGPIPE); 300 mutex_exit(proc_lock); 301 } 302 } 303 cnt -= auio.uio_resid; 304 if (ktriov != NULL) { 305 ktrgenio(fd, UIO_WRITE, ktriov, cnt, error); 306 free(ktriov, M_TEMP); 307 } 308 *retval = cnt; 309 done: 310 if (needfree) 311 free(needfree, M_IOV); 312 out: 313 fd_putfile(fd); 314 return (error); 315 } 316 317 /* 318 * Common routine to set access and modification times given a vnode. 319 */ 320 static int 321 get_utimes32(const netbsd32_timevalp_t *tptr, struct timeval *tv, 322 struct timeval **tvp) 323 { 324 int error; 325 struct netbsd32_timeval tv32[2]; 326 327 if (tptr == NULL) { 328 *tvp = NULL; 329 return 0; 330 } 331 332 error = copyin(tptr, tv32, sizeof(tv32)); 333 if (error) 334 return error; 335 netbsd32_to_timeval(&tv32[0], &tv[0]); 336 netbsd32_to_timeval(&tv32[1], &tv[1]); 337 338 *tvp = tv; 339 return 0; 340 } 341 342 int 343 netbsd32___utimes50(struct lwp *l, const struct netbsd32___utimes50_args *uap, register_t *retval) 344 { 345 /* { 346 syscallarg(const netbsd32_charp) path; 347 syscallarg(const netbsd32_timevalp_t) tptr; 348 } */ 349 int error; 350 struct timeval tv[2], *tvp; 351 352 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 353 if (error != 0) 354 return error; 355 356 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), FOLLOW, 357 tvp, UIO_SYSSPACE); 358 } 359 360 static int 361 netbds32_copyout_statvfs(const void *kp, void *up, size_t len) 362 { 363 struct netbsd32_statvfs *sbuf_32; 364 int error; 365 366 sbuf_32 = malloc(sizeof *sbuf_32, M_TEMP, M_WAITOK); 367 netbsd32_from_statvfs(kp, sbuf_32); 368 error = copyout(sbuf_32, up, sizeof(*sbuf_32)); 369 free(sbuf_32, M_TEMP); 370 371 return error; 372 } 373 374 int 375 netbsd32_statvfs1(struct lwp *l, const struct netbsd32_statvfs1_args *uap, register_t *retval) 376 { 377 /* { 378 syscallarg(const netbsd32_charp) path; 379 syscallarg(netbsd32_statvfsp_t) buf; 380 syscallarg(int) flags; 381 } */ 382 struct statvfs *sb; 383 int error; 384 385 sb = STATVFSBUF_GET(); 386 error = do_sys_pstatvfs(l, SCARG_P32(uap, path), SCARG(uap, flags), sb); 387 if (error == 0) 388 error = netbds32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0); 389 STATVFSBUF_PUT(sb); 390 return error; 391 } 392 393 int 394 netbsd32_fstatvfs1(struct lwp *l, const struct netbsd32_fstatvfs1_args *uap, register_t *retval) 395 { 396 /* { 397 syscallarg(int) fd; 398 syscallarg(netbsd32_statvfsp_t) buf; 399 syscallarg(int) flags; 400 } */ 401 struct statvfs *sb; 402 int error; 403 404 sb = STATVFSBUF_GET(); 405 error = do_sys_fstatvfs(l, SCARG(uap, fd), SCARG(uap, flags), sb); 406 if (error == 0) 407 error = netbds32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0); 408 STATVFSBUF_PUT(sb); 409 return error; 410 } 411 412 int 413 netbsd32_getvfsstat(struct lwp *l, const struct netbsd32_getvfsstat_args *uap, register_t *retval) 414 { 415 /* { 416 syscallarg(netbsd32_statvfsp_t) buf; 417 syscallarg(netbsd32_size_t) bufsize; 418 syscallarg(int) flags; 419 } */ 420 421 return do_sys_getvfsstat(l, SCARG_P32(uap, buf), SCARG(uap, bufsize), 422 SCARG(uap, flags), netbds32_copyout_statvfs, 423 sizeof (struct netbsd32_statvfs), retval); 424 } 425 426 int 427 netbsd32___fhstatvfs140(struct lwp *l, const struct netbsd32___fhstatvfs140_args *uap, register_t *retval) 428 { 429 /* { 430 syscallarg(const netbsd32_pointer_t) fhp; 431 syscallarg(netbsd32_size_t) fh_size; 432 syscallarg(netbsd32_statvfsp_t) buf; 433 syscallarg(int) flags; 434 } */ 435 struct statvfs *sb; 436 int error; 437 438 sb = STATVFSBUF_GET(); 439 error = do_fhstatvfs(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), sb, 440 SCARG(uap, flags)); 441 442 if (error == 0) 443 error = netbds32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0); 444 STATVFSBUF_PUT(sb); 445 446 return error; 447 } 448 449 int 450 netbsd32___futimes50(struct lwp *l, const struct netbsd32___futimes50_args *uap, register_t *retval) 451 { 452 /* { 453 syscallarg(int) fd; 454 syscallarg(const netbsd32_timevalp_t) tptr; 455 } */ 456 int error; 457 file_t *fp; 458 struct timeval tv[2], *tvp; 459 460 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 461 if (error != 0) 462 return error; 463 464 /* fd_getvnode() will use the descriptor for us */ 465 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 466 return (error); 467 468 error = do_sys_utimes(l, fp->f_data, NULL, 0, tvp, UIO_SYSSPACE); 469 470 fd_putfile(SCARG(uap, fd)); 471 return (error); 472 } 473 474 int 475 netbsd32___getdents30(struct lwp *l, 476 const struct netbsd32___getdents30_args *uap, register_t *retval) 477 { 478 /* { 479 syscallarg(int) fd; 480 syscallarg(netbsd32_charp) buf; 481 syscallarg(netbsd32_size_t) count; 482 } */ 483 file_t *fp; 484 int error, done; 485 486 /* fd_getvnode() will use the descriptor for us */ 487 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) 488 return (error); 489 if ((fp->f_flag & FREAD) == 0) { 490 error = EBADF; 491 goto out; 492 } 493 error = vn_readdir(fp, SCARG_P32(uap, buf), 494 UIO_USERSPACE, SCARG(uap, count), &done, l, 0, 0); 495 *retval = done; 496 out: 497 fd_putfile(SCARG(uap, fd)); 498 return (error); 499 } 500 501 int 502 netbsd32___lutimes50(struct lwp *l, 503 const struct netbsd32___lutimes50_args *uap, register_t *retval) 504 { 505 /* { 506 syscallarg(const netbsd32_charp) path; 507 syscallarg(const netbsd32_timevalp_t) tptr; 508 } */ 509 int error; 510 struct timeval tv[2], *tvp; 511 512 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp); 513 if (error != 0) 514 return error; 515 516 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), NOFOLLOW, 517 tvp, UIO_SYSSPACE); 518 } 519 520 int 521 netbsd32___stat50(struct lwp *l, const struct netbsd32___stat50_args *uap, register_t *retval) 522 { 523 /* { 524 syscallarg(const netbsd32_charp) path; 525 syscallarg(netbsd32_statp_t) ub; 526 } */ 527 struct netbsd32_stat sb32; 528 struct stat sb; 529 int error; 530 const char *path; 531 532 path = SCARG_P32(uap, path); 533 534 error = do_sys_stat(path, FOLLOW, &sb); 535 if (error) 536 return (error); 537 netbsd32_from_stat(&sb, &sb32); 538 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32)); 539 return (error); 540 } 541 542 int 543 netbsd32___fstat50(struct lwp *l, const struct netbsd32___fstat50_args *uap, register_t *retval) 544 { 545 /* { 546 syscallarg(int) fd; 547 syscallarg(netbsd32_statp_t) sb; 548 } */ 549 struct netbsd32_stat sb32; 550 struct stat ub; 551 int error; 552 553 error = do_sys_fstat(SCARG(uap, fd), &ub); 554 if (error == 0) { 555 netbsd32_from_stat(&ub, &sb32); 556 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32)); 557 } 558 return (error); 559 } 560 561 int 562 netbsd32___lstat50(struct lwp *l, const struct netbsd32___lstat50_args *uap, register_t *retval) 563 { 564 /* { 565 syscallarg(const netbsd32_charp) path; 566 syscallarg(netbsd32_statp_t) ub; 567 } */ 568 struct netbsd32_stat sb32; 569 struct stat sb; 570 int error; 571 const char *path; 572 573 path = SCARG_P32(uap, path); 574 575 error = do_sys_stat(path, NOFOLLOW, &sb); 576 if (error) 577 return (error); 578 netbsd32_from_stat(&sb, &sb32); 579 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32)); 580 return (error); 581 } 582 583 int 584 netbsd32___fhstat50(struct lwp *l, const struct netbsd32___fhstat50_args *uap, register_t *retval) 585 { 586 /* { 587 syscallarg(const netbsd32_pointer_t) fhp; 588 syscallarg(netbsd32_size_t) fh_size; 589 syscallarg(netbsd32_statp_t) sb; 590 } */ 591 struct stat sb; 592 struct netbsd32_stat sb32; 593 int error; 594 595 error = do_fhstat(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), &sb); 596 if (error != 0) { 597 netbsd32_from_stat(&sb, &sb32); 598 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb)); 599 } 600 return error; 601 } 602 603 int 604 netbsd32_preadv(struct lwp *l, const struct netbsd32_preadv_args *uap, register_t *retval) 605 { 606 /* { 607 syscallarg(int) fd; 608 syscallarg(const netbsd32_iovecp_t) iovp; 609 syscallarg(int) iovcnt; 610 syscallarg(int) pad; 611 syscallarg(off_t) offset; 612 } */ 613 file_t *fp; 614 struct vnode *vp; 615 off_t offset; 616 int error, fd = SCARG(uap, fd); 617 618 if ((fp = fd_getfile(fd)) == NULL) 619 return (EBADF); 620 621 if ((fp->f_flag & FREAD) == 0) { 622 fd_putfile(fd); 623 return (EBADF); 624 } 625 626 vp = fp->f_data; 627 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) { 628 error = ESPIPE; 629 goto out; 630 } 631 632 offset = SCARG(uap, offset); 633 634 /* 635 * XXX This works because no file systems actually 636 * XXX take any action on the seek operation. 637 */ 638 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0) 639 goto out; 640 641 return (dofilereadv32(fd, fp, SCARG_P32(uap, iovp), 642 SCARG(uap, iovcnt), &offset, 0, retval)); 643 644 out: 645 fd_putfile(fd); 646 return (error); 647 } 648 649 int 650 netbsd32_pwritev(struct lwp *l, const struct netbsd32_pwritev_args *uap, register_t *retval) 651 { 652 /* { 653 syscallarg(int) fd; 654 syscallarg(const netbsd32_iovecp_t) iovp; 655 syscallarg(int) iovcnt; 656 syscallarg(int) pad; 657 syscallarg(off_t) offset; 658 } */ 659 file_t *fp; 660 struct vnode *vp; 661 off_t offset; 662 int error, fd = SCARG(uap, fd); 663 664 if ((fp = fd_getfile(fd)) == NULL) 665 return (EBADF); 666 667 if ((fp->f_flag & FWRITE) == 0) { 668 fd_putfile(fd); 669 return (EBADF); 670 } 671 672 vp = fp->f_data; 673 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) { 674 error = ESPIPE; 675 goto out; 676 } 677 678 offset = SCARG(uap, offset); 679 680 /* 681 * XXX This works because no file systems actually 682 * XXX take any action on the seek operation. 683 */ 684 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0) 685 goto out; 686 687 return (dofilewritev32(fd, fp, SCARG_P32(uap, iovp), 688 SCARG(uap, iovcnt), &offset, 0, retval)); 689 690 out: 691 fd_putfile(fd); 692 return (error); 693 } 694 695 /* 696 * Find pathname of process's current directory. 697 * 698 * Use vfs vnode-to-name reverse cache; if that fails, fall back 699 * to reading directory contents. 700 */ 701 /* XXX NH Why does this exist */ 702 int 703 getcwd_common(struct vnode *, struct vnode *, 704 char **, char *, int, int, struct lwp *); 705 706 int 707 netbsd32___getcwd(struct lwp *l, const struct netbsd32___getcwd_args *uap, register_t *retval) 708 { 709 /* { 710 syscallarg(char *) bufp; 711 syscallarg(size_t) length; 712 } */ 713 struct proc *p = l->l_proc; 714 int error; 715 char *path; 716 char *bp, *bend; 717 int len = (int)SCARG(uap, length); 718 int lenused; 719 struct cwdinfo *cwdi; 720 721 if (len > MAXPATHLEN*4) 722 len = MAXPATHLEN*4; 723 else if (len < 2) 724 return ERANGE; 725 726 path = (char *)malloc(len, M_TEMP, M_WAITOK); 727 if (!path) 728 return ENOMEM; 729 730 bp = &path[len]; 731 bend = bp; 732 *(--bp) = '\0'; 733 734 /* 735 * 5th argument here is "max number of vnodes to traverse". 736 * Since each entry takes up at least 2 bytes in the output buffer, 737 * limit it to N/2 vnodes for an N byte buffer. 738 */ 739 #define GETCWD_CHECK_ACCESS 0x0001 740 cwdi = p->p_cwdi; 741 rw_enter(&cwdi->cwdi_lock, RW_READER); 742 error = getcwd_common (cwdi->cwdi_cdir, NULL, &bp, path, len/2, 743 GETCWD_CHECK_ACCESS, l); 744 rw_exit(&cwdi->cwdi_lock); 745 746 if (error) 747 goto out; 748 lenused = bend - bp; 749 *retval = lenused; 750 /* put the result into user buffer */ 751 error = copyout(bp, SCARG_P32(uap, bufp), lenused); 752 753 out: 754 free(path, M_TEMP); 755 return error; 756 } 757 758 int 759 netbsd32___mount50(struct lwp *l, const struct netbsd32___mount50_args *uap, 760 register_t *retval) 761 { 762 /* { 763 syscallarg(netbsd32_charp) type; 764 syscallarg(netbsd32_charp) path; 765 syscallarg(int) flags; 766 syscallarg(netbsd32_voidp) data; 767 syscallarg(netbsd32_size_t) data_len; 768 } */ 769 char mtype[MNAMELEN]; 770 union { 771 struct netbsd32_ufs_args ufs_args; 772 struct netbsd32_mfs_args mfs_args; 773 struct netbsd32_iso_args iso_args; 774 } fs_args32; 775 union { 776 struct ufs_args ufs_args; 777 struct mfs_args mfs_args; 778 struct iso_args iso_args; 779 } fs_args; 780 const char *type = SCARG_P32(uap, type); 781 const char *path = SCARG_P32(uap, path); 782 int flags = SCARG(uap, flags); 783 void *data = SCARG_P32(uap, data); 784 size_t data_len = SCARG(uap, data_len); 785 enum uio_seg data_seg; 786 size_t len; 787 int error; 788 789 error = copyinstr(type, mtype, sizeof(mtype), &len); 790 if (error) 791 return error; 792 if (strcmp(mtype, MOUNT_MFS) == 0) { 793 if (data_len != sizeof(fs_args32.mfs_args)) 794 return EINVAL; 795 if ((flags & MNT_GETARGS) == 0) { 796 error = copyin(data, &fs_args32.mfs_args, 797 sizeof(fs_args32.mfs_args)); 798 if (error) 799 return error; 800 fs_args.mfs_args.fspec = 801 NETBSD32PTR64(fs_args32.mfs_args.fspec); 802 memset(&fs_args.mfs_args._pad1, 0, 803 sizeof(fs_args.mfs_args._pad1)); 804 fs_args.mfs_args.base = 805 NETBSD32PTR64(fs_args32.mfs_args.base); 806 fs_args.mfs_args.size = fs_args32.mfs_args.size; 807 } 808 data_seg = UIO_SYSSPACE; 809 data = &fs_args.mfs_args; 810 data_len = sizeof(fs_args.mfs_args); 811 } else if (strcmp(mtype, MOUNT_UFS) == 0) { 812 if (data_len > sizeof(fs_args32.ufs_args)) 813 return EINVAL; 814 if ((flags & MNT_GETARGS) == 0) { 815 error = copyin(data, &fs_args32.ufs_args, 816 sizeof(fs_args32.ufs_args)); 817 if (error) 818 return error; 819 fs_args.ufs_args.fspec = 820 NETBSD32PTR64(fs_args32.ufs_args.fspec); 821 } 822 data_seg = UIO_SYSSPACE; 823 data = &fs_args.ufs_args; 824 data_len = sizeof(fs_args.ufs_args); 825 } else if (strcmp(mtype, MOUNT_CD9660) == 0) { 826 if (data_len != sizeof(fs_args32.iso_args)) 827 return EINVAL; 828 if ((flags & MNT_GETARGS) == 0) { 829 error = copyin(data, &fs_args32.iso_args, 830 sizeof(fs_args32.iso_args)); 831 if (error) 832 return error; 833 fs_args.iso_args.fspec = 834 NETBSD32PTR64(fs_args32.iso_args.fspec); 835 memset(&fs_args.iso_args._pad1, 0, 836 sizeof(fs_args.iso_args._pad1)); 837 fs_args.iso_args.flags = fs_args32.iso_args.flags; 838 } 839 data_seg = UIO_SYSSPACE; 840 data = &fs_args.iso_args; 841 data_len = sizeof(fs_args.iso_args); 842 } else { 843 data_seg = UIO_USERSPACE; 844 } 845 error = do_sys_mount(l, NULL, type, path, flags, data, data_seg, 846 data_len, retval); 847 if (error) 848 return error; 849 if (flags & MNT_GETARGS) { 850 data_len = *retval; 851 if (strcmp(mtype, MOUNT_MFS) == 0) { 852 if (data_len != sizeof(fs_args.mfs_args)) 853 return EINVAL; 854 NETBSD32PTR32(fs_args32.mfs_args.fspec, 855 fs_args.mfs_args.fspec); 856 memset(&fs_args32.mfs_args._pad1, 0, 857 sizeof(fs_args32.mfs_args._pad1)); 858 NETBSD32PTR32(fs_args32.mfs_args.base, 859 fs_args.mfs_args.base); 860 fs_args32.mfs_args.size = fs_args.mfs_args.size; 861 error = copyout(&fs_args32.mfs_args, data, 862 sizeof(fs_args32.mfs_args)); 863 } else if (strcmp(mtype, MOUNT_UFS) == 0) { 864 if (data_len != sizeof(fs_args.ufs_args)) 865 return EINVAL; 866 NETBSD32PTR32(fs_args32.ufs_args.fspec, 867 fs_args.ufs_args.fspec); 868 error = copyout(&fs_args32.ufs_args, data, 869 sizeof(fs_args32.ufs_args)); 870 } else if (strcmp(mtype, MOUNT_CD9660) == 0) { 871 if (data_len != sizeof(fs_args.iso_args)) 872 return EINVAL; 873 NETBSD32PTR32(fs_args32.iso_args.fspec, 874 fs_args.iso_args.fspec); 875 memset(&fs_args32.iso_args._pad1, 0, 876 sizeof(fs_args32.iso_args._pad1)); 877 fs_args32.iso_args.flags = fs_args.iso_args.flags; 878 error = copyout(&fs_args32.iso_args, data, 879 sizeof(fs_args32.iso_args)); 880 } 881 } 882 return error; 883 } 884
Indexes created Sat Sep 27 14:09:57 GMT 2025