![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_syscalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / vfs|
Return to vfs_syscalls.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / vfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1989, 1993 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * (c) UNIX System Laboratories, Inc. ! 30: * All or some portions of this file are derived from material licensed ! 31: * to the University of California by American Telephone and Telegraph ! 32: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 33: * the permission of UNIX System Laboratories, Inc. ! 34: * ! 35: * Redistribution and use in source and binary forms, with or without ! 36: * modification, are permitted provided that the following conditions ! 37: * are met: ! 38: * 1. Redistributions of source code must retain the above copyright ! 39: * notice, this list of conditions and the following disclaimer. ! 40: * 2. Redistributions in binary form must reproduce the above copyright ! 41: * notice, this list of conditions and the following disclaimer in the ! 42: * documentation and/or other materials provided with the distribution. ! 43: * 3. All advertising materials mentioning features or use of this software ! 44: * must display the following acknowledgement: ! 45: * This product includes software developed by the University of ! 46: * California, Berkeley and its contributors. ! 47: * 4. Neither the name of the University nor the names of its contributors ! 48: * may be used to endorse or promote products derived from this software ! 49: * without specific prior written permission. ! 50: * ! 51: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 52: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 53: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 54: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 55: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 56: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 57: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 58: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 59: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 60: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 61: * SUCH DAMAGE. ! 62: * ! 63: * @(#)vfs_syscalls.c 8.41 (Berkeley) 6/15/95 ! 64: */ ! 65: ! 66: #include <mach_nbc.h> ! 67: #include <sys/param.h> ! 68: #include <sys/systm.h> ! 69: #include <sys/namei.h> ! 70: #include <sys/filedesc.h> ! 71: #include <sys/kernel.h> ! 72: #include <sys/file.h> ! 73: #include <sys/stat.h> ! 74: #include <sys/vnode.h> ! 75: #include <sys/mount.h> ! 76: #include <sys/proc.h> ! 77: #include <sys/uio.h> ! 78: #include <sys/malloc.h> ! 79: #include <sys/dirent.h> ! 80: #include <sys/attr.h> ! 81: #include <sys/sysctl.h> ! 82: ! 83: struct lock__bsd__ exchangelock; ! 84: ! 85: static int change_dir __P((struct nameidata *ndp, struct proc *p)); ! 86: static void checkdirs __P((struct vnode *olddp)); ! 87: ! 88: #ifdef NeXT ! 89: unsigned int vfs_nummntops=0; /* counts number of mount and unmount operations */ ! 90: #endif ! 91: ! 92: /* ! 93: * Virtual File System System Calls ! 94: */ ! 95: ! 96: /* ! 97: * Mount a file system. ! 98: */ ! 99: struct mount_args { ! 100: char *type; ! 101: char *path; ! 102: int flags; ! 103: caddr_t data; ! 104: }; ! 105: /* ARGSUSED */ ! 106: int ! 107: mount(p, uap, retval) ! 108: struct proc *p; ! 109: register struct mount_args *uap; ! 110: register_t *retval; ! 111: { ! 112: struct vnode *vp; ! 113: struct mount *mp; ! 114: struct vfsconf *vfsp; ! 115: int error, flag; ! 116: struct vattr va; ! 117: u_long fstypenum; ! 118: struct nameidata nd; ! 119: char fstypename[MFSNAMELEN]; ! 120: ! 121: /* ! 122: * Get vnode to be covered ! 123: */ ! 124: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 125: uap->path, p); ! 126: if (error = namei(&nd)) ! 127: return (error); ! 128: vp = nd.ni_vp; ! 129: if (uap->flags & MNT_UPDATE) { ! 130: if ((vp->v_flag & VROOT) == 0) { ! 131: vput(vp); ! 132: return (EINVAL); ! 133: } ! 134: mp = vp->v_mount; ! 135: flag = mp->mnt_flag; ! 136: /* ! 137: * We only allow the filesystem to be reloaded if it ! 138: * is currently mounted read-only. ! 139: */ ! 140: if ((uap->flags & MNT_RELOAD) && ! 141: ((mp->mnt_flag & MNT_RDONLY) == 0)) { ! 142: vput(vp); ! 143: return (EOPNOTSUPP); /* Needs translation */ ! 144: } ! 145: mp->mnt_flag |= ! 146: uap->flags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE); ! 147: /* ! 148: * Only root, or the user that did the original mount is ! 149: * permitted to update it. ! 150: */ ! 151: if (mp->mnt_stat.f_owner != p->p_ucred->cr_uid && ! 152: (error = suser(p->p_ucred, &p->p_acflag))) { ! 153: vput(vp); ! 154: return (error); ! 155: } ! 156: /* ! 157: * Do not allow NFS export by non-root users. Silently ! 158: * enforce MNT_NOSUID and MNT_NODEV for non-root users. ! 159: */ ! 160: if (p->p_ucred->cr_uid != 0) { ! 161: if (uap->flags & MNT_EXPORTED) { ! 162: vput(vp); ! 163: return (EPERM); ! 164: } ! 165: uap->flags |= MNT_NOSUID | MNT_NODEV; ! 166: } ! 167: if (vfs_busy(mp, LK_NOWAIT, 0, p)) { ! 168: vput(vp); ! 169: return (EBUSY); ! 170: } ! 171: VOP_UNLOCK(vp, 0, p); ! 172: goto update; ! 173: } ! 174: /* ! 175: * If the user is not root, ensure that they own the directory ! 176: * onto which we are attempting to mount. ! 177: */ ! 178: if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) || ! 179: (va.va_uid != p->p_ucred->cr_uid && ! 180: (error = suser(p->p_ucred, &p->p_acflag)))) { ! 181: vput(vp); ! 182: return (error); ! 183: } ! 184: /* ! 185: * Do not allow NFS export by non-root users. Silently ! 186: * enforce MNT_NOSUID and MNT_NODEV for non-root users. ! 187: */ ! 188: if (p->p_ucred->cr_uid != 0) { ! 189: if (uap->flags & MNT_EXPORTED) { ! 190: vput(vp); ! 191: return (EPERM); ! 192: } ! 193: uap->flags |= MNT_NOSUID | MNT_NODEV; ! 194: } ! 195: if (error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0)) { ! 196: vput(vp); ! 197: return (error); ! 198: } ! 199: if (vp->v_type != VDIR) { ! 200: vput(vp); ! 201: return (ENOTDIR); ! 202: } ! 203: #if COMPAT_43 ! 204: /* ! 205: * Historically filesystem types were identified by number. If we ! 206: * get an integer for the filesystem type instead of a string, we ! 207: * check to see if it matches one of the historic filesystem types. ! 208: */ ! 209: fstypenum = (u_long)uap->type; ! 210: if (fstypenum < maxvfsconf) { ! 211: for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) ! 212: if (vfsp->vfc_typenum == fstypenum) ! 213: break; ! 214: if (vfsp == NULL) { ! 215: vput(vp); ! 216: return (ENODEV); ! 217: } ! 218: strncpy(fstypename, vfsp->vfc_name, MFSNAMELEN); ! 219: } else ! 220: #endif /* COMPAT_43 */ ! 221: if (error = copyinstr(uap->type, fstypename, MFSNAMELEN, NULL)) { ! 222: vput(vp); ! 223: return (error); ! 224: } ! 225: for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) ! 226: if (!strcmp(vfsp->vfc_name, fstypename)) ! 227: break; ! 228: if (vfsp == NULL) { ! 229: vput(vp); ! 230: return (ENODEV); ! 231: } ! 232: if (vp->v_mountedhere != NULL) { ! 233: vput(vp); ! 234: return (EBUSY); ! 235: } ! 236: ! 237: /* ! 238: * Allocate and initialize the filesystem. ! 239: */ ! 240: mp = (struct mount *)_MALLOC_ZONE((u_long)sizeof(struct mount), ! 241: M_MOUNT, M_WAITOK); ! 242: bzero((char *)mp, (u_long)sizeof(struct mount)); ! 243: lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, 0); ! 244: (void)vfs_busy(mp, LK_NOWAIT, 0, p); ! 245: mp->mnt_op = vfsp->vfc_vfsops; ! 246: mp->mnt_vfc = vfsp; ! 247: vfsp->vfc_refcount++; ! 248: mp->mnt_stat.f_type = vfsp->vfc_typenum; ! 249: mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK; ! 250: strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN); ! 251: vp->v_mountedhere = mp; ! 252: mp->mnt_vnodecovered = vp; ! 253: mp->mnt_stat.f_owner = p->p_ucred->cr_uid; ! 254: update: ! 255: /* ! 256: * Set the mount level flags. ! 257: */ ! 258: if (uap->flags & MNT_RDONLY) ! 259: mp->mnt_flag |= MNT_RDONLY; ! 260: else if (mp->mnt_flag & MNT_RDONLY) ! 261: mp->mnt_flag |= MNT_WANTRDWR; ! 262: mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV | ! 263: MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC); ! 264: mp->mnt_flag |= uap->flags & (MNT_NOSUID | MNT_NOEXEC | ! 265: MNT_NODEV | MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC); ! 266: /* ! 267: * Mount the filesystem. ! 268: */ ! 269: error = VFS_MOUNT(mp, uap->path, uap->data, &nd, p); ! 270: if (mp->mnt_flag & MNT_UPDATE) { ! 271: vrele(vp); ! 272: if (mp->mnt_flag & MNT_WANTRDWR) ! 273: mp->mnt_flag &= ~MNT_RDONLY; ! 274: mp->mnt_flag &=~ ! 275: (MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR); ! 276: if (error) ! 277: mp->mnt_flag = flag; ! 278: vfs_unbusy(mp, p); ! 279: return (error); ! 280: } ! 281: /* ! 282: * Put the new filesystem on the mount list after root. ! 283: */ ! 284: cache_purge(vp); ! 285: if (!error) { ! 286: simple_lock(&mountlist_slock); ! 287: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); ! 288: simple_unlock(&mountlist_slock); ! 289: checkdirs(vp); ! 290: VOP_UNLOCK(vp, 0, p); ! 291: vfs_unbusy(mp, p); ! 292: if (error = VFS_START(mp, 0, p)) ! 293: vrele(vp); ! 294: #ifdef NeXT ! 295: /* increment the operations count */ ! 296: if (!error) vfs_nummntops++; ! 297: #endif ! 298: } else { ! 299: mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0; ! 300: mp->mnt_vfc->vfc_refcount--; ! 301: vfs_unbusy(mp, p); ! 302: _FREE_ZONE((caddr_t)mp, sizeof (struct mount), M_MOUNT); ! 303: vput(vp); ! 304: } ! 305: return (error); ! 306: } ! 307: ! 308: /* ! 309: * Scan all active processes to see if any of them have a current ! 310: * or root directory onto which the new filesystem has just been ! 311: * mounted. If so, replace them with the new mount point. ! 312: */ ! 313: static void ! 314: checkdirs(olddp) ! 315: struct vnode *olddp; ! 316: { ! 317: struct filedesc *fdp; ! 318: struct vnode *newdp; ! 319: struct proc *p; ! 320: ! 321: if (olddp->v_usecount == 1) ! 322: return; ! 323: if (VFS_ROOT(olddp->v_mountedhere, &newdp)) ! 324: panic("mount: lost mount"); ! 325: for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) { ! 326: fdp = p->p_fd; ! 327: if (fdp->fd_cdir == olddp) { ! 328: vrele(fdp->fd_cdir); ! 329: VREF(newdp); ! 330: fdp->fd_cdir = newdp; ! 331: } ! 332: if (fdp->fd_rdir == olddp) { ! 333: vrele(fdp->fd_rdir); ! 334: VREF(newdp); ! 335: fdp->fd_rdir = newdp; ! 336: } ! 337: } ! 338: if (rootvnode == olddp) { ! 339: vrele(rootvnode); ! 340: VREF(newdp); ! 341: rootvnode = newdp; ! 342: } ! 343: vput(newdp); ! 344: } ! 345: ! 346: /* ! 347: * Unmount a file system. ! 348: * ! 349: * Note: unmount takes a path to the vnode mounted on as argument, ! 350: * not special file (as before). ! 351: */ ! 352: struct unmount_args { ! 353: char *path; ! 354: int flags; ! 355: }; ! 356: /* ARGSUSED */ ! 357: int ! 358: unmount(p, uap, retval) ! 359: struct proc *p; ! 360: register struct unmount_args *uap; ! 361: register_t *retval; ! 362: { ! 363: register struct vnode *vp; ! 364: struct mount *mp; ! 365: int error; ! 366: struct nameidata nd; ! 367: ! 368: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 369: uap->path, p); ! 370: if (error = namei(&nd)) ! 371: return (error); ! 372: vp = nd.ni_vp; ! 373: mp = vp->v_mount; ! 374: ! 375: /* ! 376: * Only root, or the user that did the original mount is ! 377: * permitted to unmount this filesystem. ! 378: */ ! 379: if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) && ! 380: (error = suser(p->p_ucred, &p->p_acflag))) { ! 381: vput(vp); ! 382: return (error); ! 383: } ! 384: ! 385: /* ! 386: * Don't allow unmounting the root file system. ! 387: */ ! 388: if (mp->mnt_flag & MNT_ROOTFS) { ! 389: vput(vp); ! 390: return (EINVAL); ! 391: } ! 392: ! 393: /* ! 394: * Must be the root of the filesystem ! 395: */ ! 396: if ((vp->v_flag & VROOT) == 0) { ! 397: vput(vp); ! 398: return (EINVAL); ! 399: } ! 400: vput(vp); ! 401: return (dounmount(mp, uap->flags, p)); ! 402: } ! 403: ! 404: /* ! 405: * Do the actual file system unmount. ! 406: */ ! 407: int ! 408: dounmount(mp, flags, p) ! 409: register struct mount *mp; ! 410: int flags; ! 411: struct proc *p; ! 412: { ! 413: struct vnode *coveredvp; ! 414: int error; ! 415: ! 416: simple_lock(&mountlist_slock); ! 417: mp->mnt_flag |= MNT_UNMOUNT; ! 418: lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_slock, p); ! 419: mp->mnt_flag &=~ MNT_ASYNC; ! 420: #if MACH_NBC ! 421: mapfs_cache_clear(); ! 422: #endif ! 423: vnode_pager_umount(mp); /* release cached vnodes */ ! 424: #if MACH_NBC ! 425: vm_object_cache_clear(); /* clear the object cache */ ! 426: #endif /* MACH_NBC */ ! 427: cache_purgevfs(mp); /* remove cache entries for this file sys */ ! 428: if (((mp->mnt_flag & MNT_RDONLY) || ! 429: (error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0) || ! 430: (flags & MNT_FORCE)) ! 431: error = VFS_UNMOUNT(mp, flags, p); ! 432: simple_lock(&mountlist_slock); ! 433: if (error) { ! 434: mp->mnt_flag &= ~MNT_UNMOUNT; ! 435: lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK | LK_REENABLE, ! 436: &mountlist_slock, p); ! 437: goto out; ! 438: } ! 439: #ifdef NeXT ! 440: /* increment the operations count */ ! 441: if (!error) vfs_nummntops++; ! 442: #endif ! 443: CIRCLEQ_REMOVE(&mountlist, mp, mnt_list); ! 444: if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) { ! 445: coveredvp->v_mountedhere = (struct mount *)0; ! 446: simple_unlock(&mountlist_slock); ! 447: vrele(coveredvp); ! 448: simple_lock(&mountlist_slock); ! 449: } ! 450: mp->mnt_vfc->vfc_refcount--; ! 451: if (mp->mnt_vnodelist.lh_first != NULL) ! 452: panic("unmount: dangling vnode"); ! 453: lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_slock, p); ! 454: out: ! 455: if (mp->mnt_flag & MNT_MWAIT) ! 456: wakeup((caddr_t)mp); ! 457: if (!error) ! 458: _FREE_ZONE((caddr_t)mp, sizeof (struct mount), M_MOUNT); ! 459: return (error); ! 460: } ! 461: ! 462: /* ! 463: * Sync each mounted filesystem. ! 464: */ ! 465: #if DIAGNOSTIC ! 466: int syncprt = 0; ! 467: struct ctldebug debug0 = { "syncprt", &syncprt }; ! 468: #endif ! 469: ! 470: struct sync_args { ! 471: int dummy; ! 472: }; ! 473: /* ARGSUSED */ ! 474: int ! 475: sync(p, uap, retval) ! 476: struct proc *p; ! 477: struct sync_args *uap; ! 478: register_t *retval; ! 479: { ! 480: register struct mount *mp, *nmp; ! 481: int asyncflag; ! 482: ! 483: #if MACH_NBC ! 484: #if DIAGNOSTIC ! 485: { ! 486: int error = 0; ! 487: error = mapfs_sync(); ! 488: if (error) ! 489: panic("sync: mapfs_sync %d", error); ! 490: } ! 491: #else ! 492: (void)mapfs_sync(); /* Ignore errors! */ ! 493: #endif /* DIAGNOSTIC */ ! 494: #endif /* MACH_NBC */ ! 495: ! 496: simple_lock(&mountlist_slock); ! 497: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { ! 498: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) { ! 499: nmp = mp->mnt_list.cqe_next; ! 500: continue; ! 501: } ! 502: if ((mp->mnt_flag & MNT_RDONLY) == 0) { ! 503: asyncflag = mp->mnt_flag & MNT_ASYNC; ! 504: mp->mnt_flag &= ~MNT_ASYNC; ! 505: VFS_SYNC(mp, MNT_NOWAIT, p->p_ucred, p); ! 506: if (asyncflag) ! 507: mp->mnt_flag |= MNT_ASYNC; ! 508: } ! 509: simple_lock(&mountlist_slock); ! 510: nmp = mp->mnt_list.cqe_next; ! 511: vfs_unbusy(mp, p); ! 512: } ! 513: simple_unlock(&mountlist_slock); ! 514: #if DIAGNOSTIC ! 515: if (syncprt) ! 516: vfs_bufstats(); ! 517: #endif /* DIAGNOSTIC */ ! 518: return (0); ! 519: } ! 520: ! 521: /* ! 522: * Change filesystem quotas. ! 523: */ ! 524: struct quotactl_args { ! 525: char *path; ! 526: int cmd; ! 527: int uid; ! 528: caddr_t arg; ! 529: }; ! 530: /* ARGSUSED */ ! 531: int ! 532: quotactl(p, uap, retval) ! 533: struct proc *p; ! 534: register struct quotactl_args *uap; ! 535: register_t *retval; ! 536: { ! 537: register struct mount *mp; ! 538: int error; ! 539: struct nameidata nd; ! 540: ! 541: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 542: if (error = namei(&nd)) ! 543: return (error); ! 544: mp = nd.ni_vp->v_mount; ! 545: vrele(nd.ni_vp); ! 546: return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, ! 547: uap->arg, p)); ! 548: } ! 549: ! 550: /* ! 551: * Get filesystem statistics. ! 552: */ ! 553: struct statfs_args { ! 554: char *path; ! 555: struct statfs *buf; ! 556: }; ! 557: /* ARGSUSED */ ! 558: int ! 559: statfs(p, uap, retval) ! 560: struct proc *p; ! 561: register struct statfs_args *uap; ! 562: register_t *retval; ! 563: { ! 564: register struct mount *mp; ! 565: register struct statfs *sp; ! 566: int error; ! 567: struct nameidata nd; ! 568: ! 569: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 570: if (error = namei(&nd)) ! 571: return (error); ! 572: mp = nd.ni_vp->v_mount; ! 573: sp = &mp->mnt_stat; ! 574: vrele(nd.ni_vp); ! 575: if (error = VFS_STATFS(mp, sp, p)) ! 576: return (error); ! 577: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; ! 578: return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp))); ! 579: } ! 580: ! 581: /* ! 582: * Get filesystem statistics. ! 583: */ ! 584: struct fstatfs_args { ! 585: int fd; ! 586: struct statfs *buf; ! 587: }; ! 588: /* ARGSUSED */ ! 589: int ! 590: fstatfs(p, uap, retval) ! 591: struct proc *p; ! 592: register struct fstatfs_args *uap; ! 593: register_t *retval; ! 594: { ! 595: struct file *fp; ! 596: struct mount *mp; ! 597: register struct statfs *sp; ! 598: int error; ! 599: ! 600: if (error = getvnode(p, uap->fd, &fp)) ! 601: return (error); ! 602: mp = ((struct vnode *)fp->f_data)->v_mount; ! 603: sp = &mp->mnt_stat; ! 604: if (error = VFS_STATFS(mp, sp, p)) ! 605: return (error); ! 606: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; ! 607: return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp))); ! 608: } ! 609: ! 610: /* ! 611: * Get statistics on all filesystems. ! 612: */ ! 613: struct getfsstat_args { ! 614: struct statfs *buf; ! 615: long bufsize; ! 616: int flags; ! 617: }; ! 618: int ! 619: getfsstat(p, uap, retval) ! 620: struct proc *p; ! 621: register struct getfsstat_args *uap; ! 622: register_t *retval; ! 623: { ! 624: register struct mount *mp, *nmp; ! 625: register struct statfs *sp; ! 626: caddr_t sfsp; ! 627: long count, maxcount, error; ! 628: ! 629: maxcount = uap->bufsize / sizeof(struct statfs); ! 630: sfsp = (caddr_t)uap->buf; ! 631: count = 0; ! 632: simple_lock(&mountlist_slock); ! 633: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { ! 634: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) { ! 635: nmp = mp->mnt_list.cqe_next; ! 636: continue; ! 637: } ! 638: if (sfsp && count < maxcount) { ! 639: sp = &mp->mnt_stat; ! 640: /* ! 641: * If MNT_NOWAIT is specified, do not refresh the ! 642: * fsstat cache. MNT_WAIT overrides MNT_NOWAIT. ! 643: */ ! 644: if (((uap->flags & MNT_NOWAIT) == 0 || ! 645: (uap->flags & MNT_WAIT)) && ! 646: (error = VFS_STATFS(mp, sp, p))) { ! 647: simple_lock(&mountlist_slock); ! 648: nmp = mp->mnt_list.cqe_next; ! 649: vfs_unbusy(mp, p); ! 650: continue; ! 651: } ! 652: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; ! 653: if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp))) ! 654: return (error); ! 655: sfsp += sizeof(*sp); ! 656: } ! 657: count++; ! 658: simple_lock(&mountlist_slock); ! 659: nmp = mp->mnt_list.cqe_next; ! 660: vfs_unbusy(mp, p); ! 661: } ! 662: simple_unlock(&mountlist_slock); ! 663: if (sfsp && count > maxcount) ! 664: *retval = maxcount; ! 665: else ! 666: *retval = count; ! 667: return (0); ! 668: } ! 669: ! 670: /* ! 671: * Change current working directory to a given file descriptor. ! 672: */ ! 673: struct fchdir_args { ! 674: int fd; ! 675: }; ! 676: /* ARGSUSED */ ! 677: int ! 678: fchdir(p, uap, retval) ! 679: struct proc *p; ! 680: struct fchdir_args *uap; ! 681: register_t *retval; ! 682: { ! 683: register struct filedesc *fdp = p->p_fd; ! 684: struct vnode *vp, *tdp; ! 685: struct mount *mp; ! 686: struct file *fp; ! 687: int error; ! 688: ! 689: if (error = getvnode(p, uap->fd, &fp)) ! 690: return (error); ! 691: vp = (struct vnode *)fp->f_data; ! 692: VREF(vp); ! 693: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 694: if (vp->v_type != VDIR) ! 695: error = ENOTDIR; ! 696: else ! 697: error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); ! 698: while (!error && (mp = vp->v_mountedhere) != NULL) { ! 699: if (vfs_busy(mp, 0, 0, p)) ! 700: continue; ! 701: error = VFS_ROOT(mp, &tdp); ! 702: vfs_unbusy(mp, p); ! 703: if (error) ! 704: break; ! 705: vput(vp); ! 706: vp = tdp; ! 707: } ! 708: if (error) { ! 709: vput(vp); ! 710: return (error); ! 711: } ! 712: VOP_UNLOCK(vp, 0, p); ! 713: vrele(fdp->fd_cdir); ! 714: fdp->fd_cdir = vp; ! 715: return (0); ! 716: } ! 717: ! 718: /* ! 719: * Change current working directory (``.''). ! 720: */ ! 721: struct chdir_args { ! 722: char *path; ! 723: }; ! 724: /* ARGSUSED */ ! 725: int ! 726: chdir(p, uap, retval) ! 727: struct proc *p; ! 728: struct chdir_args *uap; ! 729: register_t *retval; ! 730: { ! 731: register struct filedesc *fdp = p->p_fd; ! 732: int error; ! 733: struct nameidata nd; ! 734: ! 735: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 736: uap->path, p); ! 737: if (error = change_dir(&nd, p)) ! 738: return (error); ! 739: vrele(fdp->fd_cdir); ! 740: fdp->fd_cdir = nd.ni_vp; ! 741: return (0); ! 742: } ! 743: ! 744: /* ! 745: * Change notion of root (``/'') directory. ! 746: */ ! 747: struct chroot_args { ! 748: char *path; ! 749: }; ! 750: /* ARGSUSED */ ! 751: int ! 752: chroot(p, uap, retval) ! 753: struct proc *p; ! 754: struct chroot_args *uap; ! 755: register_t *retval; ! 756: { ! 757: register struct filedesc *fdp = p->p_fd; ! 758: int error; ! 759: struct nameidata nd; ! 760: ! 761: if (error = suser(p->p_ucred, &p->p_acflag)) ! 762: return (error); ! 763: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 764: uap->path, p); ! 765: if (error = change_dir(&nd, p)) ! 766: return (error); ! 767: if (fdp->fd_rdir != NULL) ! 768: vrele(fdp->fd_rdir); ! 769: fdp->fd_rdir = nd.ni_vp; ! 770: return (0); ! 771: } ! 772: ! 773: /* ! 774: * Common routine for chroot and chdir. ! 775: */ ! 776: static int ! 777: change_dir(ndp, p) ! 778: register struct nameidata *ndp; ! 779: struct proc *p; ! 780: { ! 781: struct vnode *vp; ! 782: int error; ! 783: ! 784: if (error = namei(ndp)) ! 785: return (error); ! 786: vp = ndp->ni_vp; ! 787: if (vp->v_type != VDIR) ! 788: error = ENOTDIR; ! 789: else ! 790: error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); ! 791: if (error) ! 792: vput(vp); ! 793: else ! 794: VOP_UNLOCK(vp, 0, p); ! 795: return (error); ! 796: } ! 797: ! 798: /* ! 799: * Check permissions, allocate an open file structure, ! 800: * and call the device open routine if any. ! 801: */ ! 802: struct open_args { ! 803: char *path; ! 804: int flags; ! 805: int mode; ! 806: }; ! 807: int ! 808: open(p, uap, retval) ! 809: struct proc *p; ! 810: register struct open_args *uap; ! 811: register_t *retval; ! 812: { ! 813: register struct filedesc *fdp = p->p_fd; ! 814: register struct file *fp; ! 815: register struct vnode *vp; ! 816: int flags, cmode; ! 817: struct file *nfp; ! 818: int type, indx, error; ! 819: struct flock lf; ! 820: struct nameidata nd; ! 821: extern struct fileops vnops; ! 822: ! 823: /* CERT advisory patch applied from FreeBSD */ ! 824: /* Refer to Radar#2262895 A. Ramesh */ ! 825: flags = FFLAGS(uap->flags); ! 826: if ((flags & (FREAD | FWRITE))==0) ! 827: return(EINVAL); ! 828: if (error = falloc(p, &nfp, &indx)) ! 829: return (error); ! 830: fp = nfp; ! 831: cmode = ((uap->mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT; ! 832: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 833: p->p_dupfd = -indx - 1; /* XXX check for fdopen */ ! 834: if (error = vn_open(&nd, flags, cmode)) { ! 835: ffree(fp); ! 836: if ((error == ENODEV || error == ENXIO) && ! 837: p->p_dupfd >= 0 && /* XXX from fdopen */ ! 838: (error = ! 839: dupfdopen(fdp, indx, p->p_dupfd, flags, error)) == 0) { ! 840: *retval = indx; ! 841: return (0); ! 842: } ! 843: if (error == ERESTART) ! 844: error = EINTR; ! 845: fdrelse(p, indx); ! 846: return (error); ! 847: } ! 848: p->p_dupfd = 0; ! 849: vp = nd.ni_vp; ! 850: fp->f_flag = flags & FMASK; ! 851: fp->f_type = DTYPE_VNODE; ! 852: fp->f_ops = &vnops; ! 853: fp->f_data = (caddr_t)vp; ! 854: if (flags & (O_EXLOCK | O_SHLOCK)) { ! 855: lf.l_whence = SEEK_SET; ! 856: lf.l_start = 0; ! 857: lf.l_len = 0; ! 858: if (flags & O_EXLOCK) ! 859: lf.l_type = F_WRLCK; ! 860: else ! 861: lf.l_type = F_RDLCK; ! 862: type = F_FLOCK; ! 863: if ((flags & FNONBLOCK) == 0) ! 864: type |= F_WAIT; ! 865: VOP_UNLOCK(vp, 0, p); ! 866: if (error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) { ! 867: (void) vn_close(vp, fp->f_flag, fp->f_cred, p); ! 868: ffree(fp); ! 869: fdrelse(p, indx); ! 870: return (error); ! 871: } ! 872: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 873: fp->f_flag |= FHASLOCK; ! 874: } ! 875: VOP_UNLOCK(vp, 0, p); ! 876: *fdflags(p, indx) &= ~UF_RESERVED; ! 877: *retval = indx; ! 878: return (0); ! 879: } ! 880: ! 881: #if COMPAT_43 ! 882: /* ! 883: * Create a file. ! 884: */ ! 885: struct ocreat_args { ! 886: char *path; ! 887: int mode; ! 888: }; ! 889: int ! 890: ocreat(p, uap, retval) ! 891: struct proc *p; ! 892: register struct ocreat_args *uap; ! 893: register_t *retval; ! 894: { ! 895: struct open_args nuap; ! 896: ! 897: nuap.path = uap->path; ! 898: nuap.mode = uap->mode; ! 899: nuap.flags = O_WRONLY | O_CREAT | O_TRUNC; ! 900: return (open(p, &nuap, retval)); ! 901: } ! 902: #endif /* COMPAT_43 */ ! 903: ! 904: /* ! 905: * Create a special file. ! 906: */ ! 907: struct mknod_args { ! 908: char *path; ! 909: int mode; ! 910: int dev; ! 911: }; ! 912: /* ARGSUSED */ ! 913: int ! 914: mknod(p, uap, retval) ! 915: struct proc *p; ! 916: register struct mknod_args *uap; ! 917: register_t *retval; ! 918: { ! 919: register struct vnode *vp; ! 920: struct vattr vattr; ! 921: int error; ! 922: int whiteout; ! 923: struct nameidata nd; ! 924: ! 925: if (error = suser(p->p_ucred, &p->p_acflag)) ! 926: return (error); ! 927: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p); ! 928: if (error = namei(&nd)) ! 929: return (error); ! 930: vp = nd.ni_vp; ! 931: if (vp != NULL) ! 932: error = EEXIST; ! 933: else { ! 934: VATTR_NULL(&vattr); ! 935: vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask; ! 936: vattr.va_rdev = uap->dev; ! 937: whiteout = 0; ! 938: ! 939: switch (uap->mode & S_IFMT) { ! 940: case S_IFMT: /* used by badsect to flag bad sectors */ ! 941: vattr.va_type = VBAD; ! 942: break; ! 943: case S_IFCHR: ! 944: vattr.va_type = VCHR; ! 945: break; ! 946: case S_IFBLK: ! 947: vattr.va_type = VBLK; ! 948: break; ! 949: case S_IFWHT: ! 950: whiteout = 1; ! 951: break; ! 952: default: ! 953: error = EINVAL; ! 954: break; ! 955: } ! 956: } ! 957: if (!error) { ! 958: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 959: if (whiteout) { ! 960: error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE); ! 961: if (error) ! 962: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 963: vput(nd.ni_dvp); ! 964: } else { ! 965: error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, ! 966: &nd.ni_cnd, &vattr); ! 967: } ! 968: } else { ! 969: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 970: if (nd.ni_dvp == vp) ! 971: vrele(nd.ni_dvp); ! 972: else ! 973: vput(nd.ni_dvp); ! 974: if (vp) ! 975: vrele(vp); ! 976: } ! 977: return (error); ! 978: } ! 979: ! 980: /* ! 981: * Create a named pipe. ! 982: */ ! 983: struct mkfifo_args { ! 984: char *path; ! 985: int mode; ! 986: }; ! 987: /* ARGSUSED */ ! 988: int ! 989: mkfifo(p, uap, retval) ! 990: struct proc *p; ! 991: register struct mkfifo_args *uap; ! 992: register_t *retval; ! 993: { ! 994: struct vattr vattr; ! 995: int error; ! 996: struct nameidata nd; ! 997: ! 998: #if !FIFO ! 999: return (EOPNOTSUPP); ! 1000: #else ! 1001: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p); ! 1002: if (error = namei(&nd)) ! 1003: return (error); ! 1004: if (nd.ni_vp != NULL) { ! 1005: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 1006: if (nd.ni_dvp == nd.ni_vp) ! 1007: vrele(nd.ni_dvp); ! 1008: else ! 1009: vput(nd.ni_dvp); ! 1010: vrele(nd.ni_vp); ! 1011: return (EEXIST); ! 1012: } ! 1013: VATTR_NULL(&vattr); ! 1014: vattr.va_type = VFIFO; ! 1015: vattr.va_mode = (uap->mode & ALLPERMS) &~ p->p_fd->fd_cmask; ! 1016: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 1017: return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr)); ! 1018: #endif /* FIFO */ ! 1019: } ! 1020: ! 1021: /* ! 1022: * Make a hard file link. ! 1023: */ ! 1024: struct link_args { ! 1025: char *path; ! 1026: char *link; ! 1027: }; ! 1028: /* ARGSUSED */ ! 1029: int ! 1030: link(p, uap, retval) ! 1031: struct proc *p; ! 1032: register struct link_args *uap; ! 1033: register_t *retval; ! 1034: { ! 1035: register struct vnode *vp; ! 1036: struct nameidata nd; ! 1037: int error; ! 1038: ! 1039: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 1040: if (error = namei(&nd)) ! 1041: return (error); ! 1042: vp = nd.ni_vp; ! 1043: if (vp->v_type == VDIR) ! 1044: error = EPERM; /* POSIX */ ! 1045: else { ! 1046: nd.ni_cnd.cn_nameiop = CREATE; ! 1047: nd.ni_cnd.cn_flags = LOCKPARENT; ! 1048: nd.ni_dirp = uap->link; ! 1049: if ((error = namei(&nd)) == 0) { ! 1050: if (nd.ni_vp != NULL) ! 1051: error = EEXIST; ! 1052: if (!error) { ! 1053: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, ! 1054: LEASE_WRITE); ! 1055: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1056: error = VOP_LINK(vp, nd.ni_dvp, &nd.ni_cnd); ! 1057: } else { ! 1058: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 1059: if (nd.ni_dvp == nd.ni_vp) ! 1060: vrele(nd.ni_dvp); ! 1061: else ! 1062: vput(nd.ni_dvp); ! 1063: if (nd.ni_vp) ! 1064: vrele(nd.ni_vp); ! 1065: } ! 1066: } ! 1067: } ! 1068: vrele(vp); ! 1069: return (error); ! 1070: } ! 1071: ! 1072: /* ! 1073: * Make a symbolic link. ! 1074: */ ! 1075: struct symlink_args { ! 1076: char *path; ! 1077: char *link; ! 1078: }; ! 1079: /* ARGSUSED */ ! 1080: int ! 1081: symlink(p, uap, retval) ! 1082: struct proc *p; ! 1083: register struct symlink_args *uap; ! 1084: register_t *retval; ! 1085: { ! 1086: struct vattr vattr; ! 1087: char *path; ! 1088: int error; ! 1089: struct nameidata nd; ! 1090: ! 1091: MALLOC_ZONE(path, char *, MAXPATHLEN, M_NAMEI, M_WAITOK); ! 1092: if (error = copyinstr(uap->path, path, MAXPATHLEN, NULL)) ! 1093: goto out; ! 1094: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->link, p); ! 1095: if (error = namei(&nd)) ! 1096: goto out; ! 1097: if (nd.ni_vp) { ! 1098: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 1099: if (nd.ni_dvp == nd.ni_vp) ! 1100: vrele(nd.ni_dvp); ! 1101: else ! 1102: vput(nd.ni_dvp); ! 1103: vrele(nd.ni_vp); ! 1104: error = EEXIST; ! 1105: goto out; ! 1106: } ! 1107: VATTR_NULL(&vattr); ! 1108: vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask; ! 1109: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 1110: error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path); ! 1111: out: ! 1112: FREE_ZONE(path, MAXPATHLEN, M_NAMEI); ! 1113: return (error); ! 1114: } ! 1115: ! 1116: /* ! 1117: * Delete a whiteout from the filesystem. ! 1118: */ ! 1119: struct undelete_args { ! 1120: char *path; ! 1121: }; ! 1122: /* ARGSUSED */ ! 1123: int ! 1124: undelete(p, uap, retval) ! 1125: struct proc *p; ! 1126: register struct undelete_args *uap; ! 1127: register_t *retval; ! 1128: { ! 1129: int error; ! 1130: struct nameidata nd; ! 1131: ! 1132: NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE, ! 1133: uap->path, p); ! 1134: error = namei(&nd); ! 1135: if (error) ! 1136: return (error); ! 1137: ! 1138: if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) { ! 1139: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 1140: if (nd.ni_dvp == nd.ni_vp) ! 1141: vrele(nd.ni_dvp); ! 1142: else ! 1143: vput(nd.ni_dvp); ! 1144: if (nd.ni_vp) ! 1145: vrele(nd.ni_vp); ! 1146: return (EEXIST); ! 1147: } ! 1148: ! 1149: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 1150: if (error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE)) ! 1151: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 1152: vput(nd.ni_dvp); ! 1153: return (error); ! 1154: } ! 1155: ! 1156: /* ! 1157: * Delete a name from the filesystem. ! 1158: */ ! 1159: struct unlink_args { ! 1160: char *path; ! 1161: }; ! 1162: /* ARGSUSED */ ! 1163: int ! 1164: unlink(p, uap, retval) ! 1165: struct proc *p; ! 1166: struct unlink_args *uap; ! 1167: register_t *retval; ! 1168: { ! 1169: register struct vnode *vp; ! 1170: int error; ! 1171: struct nameidata nd; ! 1172: ! 1173: NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, uap->path, p); ! 1174: if (error = namei(&nd)) ! 1175: return (error); ! 1176: vp = nd.ni_vp; ! 1177: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1178: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1179: ! 1180: if (vp->v_type == VDIR) ! 1181: error = EPERM; /* POSIX */ ! 1182: else { ! 1183: /* ! 1184: * The root of a mounted filesystem cannot be deleted. ! 1185: * ! 1186: * XXX: can this only be a VDIR case? ! 1187: */ ! 1188: if (vp->v_flag & VROOT) ! 1189: error = EBUSY; ! 1190: else ! 1191: (void) vnode_uncache(vp); ! 1192: } ! 1193: ! 1194: if (!error) { ! 1195: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 1196: error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); ! 1197: } else { ! 1198: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 1199: if (nd.ni_dvp == vp) ! 1200: vrele(nd.ni_dvp); ! 1201: else ! 1202: vput(nd.ni_dvp); ! 1203: if (vp != NULLVP) ! 1204: vput(vp); ! 1205: } ! 1206: return (error); ! 1207: } ! 1208: ! 1209: /* ! 1210: * Reposition read/write file offset. ! 1211: */ ! 1212: struct lseek_args { ! 1213: int fd; ! 1214: #ifdef DOUBLE_ALIGN_PARAMS ! 1215: int pad; ! 1216: #endif ! 1217: off_t offset; ! 1218: int whence; ! 1219: }; ! 1220: int ! 1221: lseek(p, uap, retval) ! 1222: struct proc *p; ! 1223: register struct lseek_args *uap; ! 1224: register_t *retval; ! 1225: { ! 1226: struct ucred *cred = p->p_ucred; ! 1227: struct file *fp; ! 1228: struct vattr vattr; ! 1229: int error; ! 1230: ! 1231: if (error = fdgetf(p, uap->fd, &fp)) ! 1232: return (error); ! 1233: if (fp->f_type != DTYPE_VNODE) ! 1234: return (ESPIPE); ! 1235: switch (uap->whence) { ! 1236: case L_INCR: ! 1237: fp->f_offset += uap->offset; ! 1238: break; ! 1239: case L_XTND: ! 1240: if (error = ! 1241: VOP_GETATTR((struct vnode *)fp->f_data, &vattr, cred, p)) ! 1242: return (error); ! 1243: fp->f_offset = uap->offset + vattr.va_size; ! 1244: break; ! 1245: case L_SET: ! 1246: fp->f_offset = uap->offset; ! 1247: break; ! 1248: default: ! 1249: return (EINVAL); ! 1250: } ! 1251: *(off_t *)retval = fp->f_offset; ! 1252: return (0); ! 1253: } ! 1254: ! 1255: #if COMPAT_43 ! 1256: /* ! 1257: * Reposition read/write file offset. ! 1258: */ ! 1259: struct olseek_args { ! 1260: int fd; ! 1261: long offset; ! 1262: int whence; ! 1263: }; ! 1264: int ! 1265: olseek(p, uap, retval) ! 1266: struct proc *p; ! 1267: register struct olseek_args *uap; ! 1268: register_t *retval; ! 1269: { ! 1270: struct lseek_args /* { ! 1271: syscallarg(int) fd; ! 1272: #ifdef DOUBLE_ALIGN_PARAMS ! 1273: syscallarg(int) pad; ! 1274: #endif ! 1275: syscallarg(off_t) offset; ! 1276: syscallarg(int) whence; ! 1277: } */ nuap; ! 1278: off_t qret; ! 1279: int error; ! 1280: ! 1281: nuap.fd = uap->fd; ! 1282: nuap.offset = uap->offset; ! 1283: nuap.whence = uap->whence; ! 1284: error = lseek(p, &nuap, &qret); ! 1285: *(long *)retval = qret; ! 1286: return (error); ! 1287: } ! 1288: #endif /* COMPAT_43 */ ! 1289: ! 1290: /* ! 1291: * Check access permissions. ! 1292: */ ! 1293: struct access_args { ! 1294: char *path; ! 1295: int flags; ! 1296: }; ! 1297: int ! 1298: access(p, uap, retval) ! 1299: struct proc *p; ! 1300: register struct access_args *uap; ! 1301: register_t *retval; ! 1302: { ! 1303: register struct ucred *cred = p->p_ucred; ! 1304: register struct vnode *vp; ! 1305: int error, flags, t_gid, t_uid; ! 1306: struct nameidata nd; ! 1307: ! 1308: t_uid = cred->cr_uid; ! 1309: t_gid = cred->cr_groups[0]; ! 1310: cred->cr_uid = p->p_cred->p_ruid; ! 1311: cred->cr_groups[0] = p->p_cred->p_rgid; ! 1312: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 1313: uap->path, p); ! 1314: if (error = namei(&nd)) ! 1315: goto out1; ! 1316: vp = nd.ni_vp; ! 1317: ! 1318: /* Flags == 0 means only check for existence. */ ! 1319: if (uap->flags) { ! 1320: flags = 0; ! 1321: if (uap->flags & R_OK) ! 1322: flags |= VREAD; ! 1323: if (uap->flags & W_OK) ! 1324: flags |= VWRITE; ! 1325: if (uap->flags & X_OK) ! 1326: flags |= VEXEC; ! 1327: if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0) ! 1328: error = VOP_ACCESS(vp, flags, cred, p); ! 1329: } ! 1330: vput(vp); ! 1331: out1: ! 1332: cred->cr_uid = t_uid; ! 1333: cred->cr_groups[0] = t_gid; ! 1334: return (error); ! 1335: } ! 1336: ! 1337: #if COMPAT_43 ! 1338: /* ! 1339: * Get file status; this version follows links. ! 1340: */ ! 1341: struct ostat_args { ! 1342: char *path; ! 1343: struct ostat *ub; ! 1344: }; ! 1345: /* ARGSUSED */ ! 1346: int ! 1347: ostat(p, uap, retval) ! 1348: struct proc *p; ! 1349: register struct ostat_args *uap; ! 1350: register_t *retval; ! 1351: { ! 1352: struct stat sb; ! 1353: struct ostat osb; ! 1354: int error; ! 1355: struct nameidata nd; ! 1356: ! 1357: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 1358: uap->path, p); ! 1359: if (error = namei(&nd)) ! 1360: return (error); ! 1361: error = vn_stat(nd.ni_vp, &sb, p); ! 1362: vput(nd.ni_vp); ! 1363: if (error) ! 1364: return (error); ! 1365: cvtstat(&sb, &osb); ! 1366: error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb)); ! 1367: return (error); ! 1368: } ! 1369: ! 1370: /* ! 1371: * Get file status; this version does not follow links. ! 1372: */ ! 1373: struct olstat_args { ! 1374: char *path; ! 1375: struct ostat *ub; ! 1376: }; ! 1377: /* ARGSUSED */ ! 1378: int ! 1379: olstat(p, uap, retval) ! 1380: struct proc *p; ! 1381: register struct olstat_args *uap; ! 1382: register_t *retval; ! 1383: { ! 1384: struct vnode *vp, *dvp; ! 1385: struct stat sb, sb1; ! 1386: struct ostat osb; ! 1387: int error; ! 1388: struct nameidata nd; ! 1389: ! 1390: NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE, ! 1391: uap->path, p); ! 1392: if (error = namei(&nd)) ! 1393: return (error); ! 1394: /* ! 1395: * For symbolic links, always return the attributes of its ! 1396: * containing directory, except for mode, size, and links. ! 1397: */ ! 1398: vp = nd.ni_vp; ! 1399: dvp = nd.ni_dvp; ! 1400: if (vp->v_type != VLNK) { ! 1401: if (dvp == vp) ! 1402: vrele(dvp); ! 1403: else ! 1404: vput(dvp); ! 1405: error = vn_stat(vp, &sb, p); ! 1406: vput(vp); ! 1407: if (error) ! 1408: return (error); ! 1409: } else { ! 1410: error = vn_stat(dvp, &sb, p); ! 1411: vput(dvp); ! 1412: if (error) { ! 1413: vput(vp); ! 1414: return (error); ! 1415: } ! 1416: error = vn_stat(vp, &sb1, p); ! 1417: vput(vp); ! 1418: if (error) ! 1419: return (error); ! 1420: sb.st_mode &= ~S_IFDIR; ! 1421: sb.st_mode |= S_IFLNK; ! 1422: sb.st_nlink = sb1.st_nlink; ! 1423: sb.st_size = sb1.st_size; ! 1424: sb.st_blocks = sb1.st_blocks; ! 1425: } ! 1426: cvtstat(&sb, &osb); ! 1427: error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb)); ! 1428: return (error); ! 1429: } ! 1430: ! 1431: /* ! 1432: * Convert from an old to a new stat structure. ! 1433: */ ! 1434: void ! 1435: cvtstat(st, ost) ! 1436: struct stat *st; ! 1437: struct ostat *ost; ! 1438: { ! 1439: ! 1440: ost->st_dev = st->st_dev; ! 1441: ost->st_ino = st->st_ino; ! 1442: ost->st_mode = st->st_mode; ! 1443: ost->st_nlink = st->st_nlink; ! 1444: ost->st_uid = st->st_uid; ! 1445: ost->st_gid = st->st_gid; ! 1446: ost->st_rdev = st->st_rdev; ! 1447: if (st->st_size < (quad_t)1 << 32) ! 1448: ost->st_size = st->st_size; ! 1449: else ! 1450: ost->st_size = -2; ! 1451: ost->st_atime = st->st_atime; ! 1452: ost->st_mtime = st->st_mtime; ! 1453: ost->st_ctime = st->st_ctime; ! 1454: ost->st_blksize = st->st_blksize; ! 1455: ost->st_blocks = st->st_blocks; ! 1456: ost->st_flags = st->st_flags; ! 1457: ost->st_gen = st->st_gen; ! 1458: } ! 1459: #endif /* COMPAT_43 */ ! 1460: ! 1461: /* ! 1462: * Get file status; this version follows links. ! 1463: */ ! 1464: struct stat_args { ! 1465: char *path; ! 1466: struct stat *ub; ! 1467: }; ! 1468: /* ARGSUSED */ ! 1469: int ! 1470: stat(p, uap, retval) ! 1471: struct proc *p; ! 1472: register struct stat_args *uap; ! 1473: register_t *retval; ! 1474: { ! 1475: struct stat sb; ! 1476: int error; ! 1477: struct nameidata nd; ! 1478: ! 1479: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 1480: uap->path, p); ! 1481: if (error = namei(&nd)) ! 1482: return (error); ! 1483: error = vn_stat(nd.ni_vp, &sb, p); ! 1484: vput(nd.ni_vp); ! 1485: if (error) ! 1486: return (error); ! 1487: error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb)); ! 1488: return (error); ! 1489: } ! 1490: ! 1491: /* ! 1492: * Get file status; this version does not follow links. ! 1493: */ ! 1494: struct lstat_args { ! 1495: char *path; ! 1496: struct stat *ub; ! 1497: }; ! 1498: /* ARGSUSED */ ! 1499: int ! 1500: lstat(p, uap, retval) ! 1501: struct proc *p; ! 1502: register struct lstat_args *uap; ! 1503: register_t *retval; ! 1504: { ! 1505: int error; ! 1506: struct vnode *vp, *dvp; ! 1507: struct stat sb, sb1; ! 1508: struct nameidata nd; ! 1509: ! 1510: NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE, ! 1511: uap->path, p); ! 1512: if (error = namei(&nd)) ! 1513: return (error); ! 1514: /* ! 1515: * For symbolic links, always return the attributes of its containing ! 1516: * directory, except for mode, size, inode number, and links. ! 1517: */ ! 1518: vp = nd.ni_vp; ! 1519: dvp = nd.ni_dvp; ! 1520: if ((vp->v_type != VLNK) || ((vp->v_type == VLNK) && (vp->v_tag == VT_NFS))) { ! 1521: if (dvp == vp) ! 1522: vrele(dvp); ! 1523: else ! 1524: vput(dvp); ! 1525: error = vn_stat(vp, &sb, p); ! 1526: vput(vp); ! 1527: if (error) ! 1528: return (error); ! 1529: if (vp->v_type == VLNK) ! 1530: sb.st_mode |= S_IFLNK; ! 1531: } else { ! 1532: error = vn_stat(dvp, &sb, p); ! 1533: vput(dvp); ! 1534: if (error) { ! 1535: vput(vp); ! 1536: return (error); ! 1537: } ! 1538: error = vn_stat(vp, &sb1, p); ! 1539: vput(vp); ! 1540: if (error) ! 1541: return (error); ! 1542: sb.st_mode &= ~S_IFDIR; ! 1543: sb.st_mode |= S_IFLNK; ! 1544: sb.st_nlink = sb1.st_nlink; ! 1545: sb.st_size = sb1.st_size; ! 1546: sb.st_blocks = sb1.st_blocks; ! 1547: sb.st_ino = sb1.st_ino; ! 1548: } ! 1549: error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb)); ! 1550: return (error); ! 1551: } ! 1552: ! 1553: /* ! 1554: * Get configurable pathname variables. ! 1555: */ ! 1556: struct pathconf_args { ! 1557: char *path; ! 1558: int name; ! 1559: }; ! 1560: /* ARGSUSED */ ! 1561: int ! 1562: pathconf(p, uap, retval) ! 1563: struct proc *p; ! 1564: register struct pathconf_args *uap; ! 1565: register_t *retval; ! 1566: { ! 1567: int error; ! 1568: struct nameidata nd; ! 1569: ! 1570: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, ! 1571: uap->path, p); ! 1572: if (error = namei(&nd)) ! 1573: return (error); ! 1574: error = VOP_PATHCONF(nd.ni_vp, uap->name, retval); ! 1575: vput(nd.ni_vp); ! 1576: return (error); ! 1577: } ! 1578: ! 1579: /* ! 1580: * Return target name of a symbolic link. ! 1581: */ ! 1582: struct readlink_args { ! 1583: char *path; ! 1584: char *buf; ! 1585: int count; ! 1586: }; ! 1587: /* ARGSUSED */ ! 1588: int ! 1589: readlink(p, uap, retval) ! 1590: struct proc *p; ! 1591: register struct readlink_args *uap; ! 1592: register_t *retval; ! 1593: { ! 1594: register struct vnode *vp; ! 1595: struct iovec aiov; ! 1596: struct uio auio; ! 1597: int error; ! 1598: struct nameidata nd; ! 1599: ! 1600: NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, ! 1601: uap->path, p); ! 1602: if (error = namei(&nd)) ! 1603: return (error); ! 1604: vp = nd.ni_vp; ! 1605: if (vp->v_type != VLNK) ! 1606: error = EINVAL; ! 1607: else { ! 1608: aiov.iov_base = uap->buf; ! 1609: aiov.iov_len = uap->count; ! 1610: auio.uio_iov = &aiov; ! 1611: auio.uio_iovcnt = 1; ! 1612: auio.uio_offset = 0; ! 1613: auio.uio_rw = UIO_READ; ! 1614: auio.uio_segflg = UIO_USERSPACE; ! 1615: auio.uio_procp = p; ! 1616: auio.uio_resid = uap->count; ! 1617: error = VOP_READLINK(vp, &auio, p->p_ucred); ! 1618: } ! 1619: vput(vp); ! 1620: *retval = uap->count - auio.uio_resid; ! 1621: return (error); ! 1622: } ! 1623: ! 1624: /* ! 1625: * Change flags of a file given a path name. ! 1626: */ ! 1627: struct chflags_args { ! 1628: char *path; ! 1629: int flags; ! 1630: }; ! 1631: /* ARGSUSED */ ! 1632: int ! 1633: chflags(p, uap, retval) ! 1634: struct proc *p; ! 1635: register struct chflags_args *uap; ! 1636: register_t *retval; ! 1637: { ! 1638: register struct vnode *vp; ! 1639: struct vattr vattr; ! 1640: int error; ! 1641: struct nameidata nd; ! 1642: ! 1643: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 1644: if (error = namei(&nd)) ! 1645: return (error); ! 1646: vp = nd.ni_vp; ! 1647: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1648: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1649: VATTR_NULL(&vattr); ! 1650: vattr.va_flags = uap->flags; ! 1651: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1652: vput(vp); ! 1653: return (error); ! 1654: } ! 1655: ! 1656: /* ! 1657: * Change flags of a file given a file descriptor. ! 1658: */ ! 1659: struct fchflags_args { ! 1660: int fd; ! 1661: int flags; ! 1662: }; ! 1663: /* ARGSUSED */ ! 1664: int ! 1665: fchflags(p, uap, retval) ! 1666: struct proc *p; ! 1667: register struct fchflags_args *uap; ! 1668: register_t *retval; ! 1669: { ! 1670: struct vattr vattr; ! 1671: struct vnode *vp; ! 1672: struct file *fp; ! 1673: int error; ! 1674: ! 1675: if (error = getvnode(p, uap->fd, &fp)) ! 1676: return (error); ! 1677: vp = (struct vnode *)fp->f_data; ! 1678: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1679: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1680: VATTR_NULL(&vattr); ! 1681: vattr.va_flags = uap->flags; ! 1682: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1683: VOP_UNLOCK(vp, 0, p); ! 1684: return (error); ! 1685: } ! 1686: ! 1687: /* ! 1688: * Change mode of a file given path name. ! 1689: */ ! 1690: struct chmod_args { ! 1691: char *path; ! 1692: int mode; ! 1693: }; ! 1694: /* ARGSUSED */ ! 1695: int ! 1696: chmod(p, uap, retval) ! 1697: struct proc *p; ! 1698: register struct chmod_args *uap; ! 1699: register_t *retval; ! 1700: { ! 1701: register struct vnode *vp; ! 1702: struct vattr vattr; ! 1703: int error; ! 1704: struct nameidata nd; ! 1705: ! 1706: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 1707: if (error = namei(&nd)) ! 1708: return (error); ! 1709: vp = nd.ni_vp; ! 1710: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1711: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1712: VATTR_NULL(&vattr); ! 1713: vattr.va_mode = uap->mode & ALLPERMS; ! 1714: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1715: vput(vp); ! 1716: return (error); ! 1717: } ! 1718: ! 1719: /* ! 1720: * Change mode of a file given a file descriptor. ! 1721: */ ! 1722: struct fchmod_args { ! 1723: int fd; ! 1724: int mode; ! 1725: }; ! 1726: /* ARGSUSED */ ! 1727: int ! 1728: fchmod(p, uap, retval) ! 1729: struct proc *p; ! 1730: register struct fchmod_args *uap; ! 1731: register_t *retval; ! 1732: { ! 1733: struct vattr vattr; ! 1734: struct vnode *vp; ! 1735: struct file *fp; ! 1736: int error; ! 1737: ! 1738: if (error = getvnode(p, uap->fd, &fp)) ! 1739: return (error); ! 1740: vp = (struct vnode *)fp->f_data; ! 1741: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1742: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1743: VATTR_NULL(&vattr); ! 1744: vattr.va_mode = uap->mode & ALLPERMS; ! 1745: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1746: VOP_UNLOCK(vp, 0, p); ! 1747: return (error); ! 1748: } ! 1749: ! 1750: /* ! 1751: * Set ownership given a path name. ! 1752: */ ! 1753: struct chown_args { ! 1754: char *path; ! 1755: int uid; ! 1756: int gid; ! 1757: }; ! 1758: /* ARGSUSED */ ! 1759: int ! 1760: chown(p, uap, retval) ! 1761: struct proc *p; ! 1762: register struct chown_args *uap; ! 1763: register_t *retval; ! 1764: { ! 1765: register struct vnode *vp; ! 1766: struct vattr vattr; ! 1767: int error; ! 1768: struct nameidata nd; ! 1769: ! 1770: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 1771: if (error = namei(&nd)) ! 1772: return (error); ! 1773: vp = nd.ni_vp; ! 1774: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1775: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1776: VATTR_NULL(&vattr); ! 1777: vattr.va_uid = uap->uid; ! 1778: vattr.va_gid = uap->gid; ! 1779: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1780: vput(vp); ! 1781: return (error); ! 1782: } ! 1783: ! 1784: /* ! 1785: * Set ownership given a file descriptor. ! 1786: */ ! 1787: struct fchown_args { ! 1788: int fd; ! 1789: int uid; ! 1790: int gid; ! 1791: }; ! 1792: /* ARGSUSED */ ! 1793: int ! 1794: fchown(p, uap, retval) ! 1795: struct proc *p; ! 1796: register struct fchown_args *uap; ! 1797: register_t *retval; ! 1798: { ! 1799: struct vattr vattr; ! 1800: struct vnode *vp; ! 1801: struct file *fp; ! 1802: int error; ! 1803: ! 1804: if (error = getvnode(p, uap->fd, &fp)) ! 1805: return (error); ! 1806: vp = (struct vnode *)fp->f_data; ! 1807: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1808: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1809: VATTR_NULL(&vattr); ! 1810: vattr.va_uid = uap->uid; ! 1811: vattr.va_gid = uap->gid; ! 1812: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1813: VOP_UNLOCK(vp, 0, p); ! 1814: return (error); ! 1815: } ! 1816: ! 1817: /* ! 1818: * Set the access and modification times of a file. ! 1819: */ ! 1820: struct utimes_args { ! 1821: char *path; ! 1822: struct timeval *tptr; ! 1823: }; ! 1824: /* ARGSUSED */ ! 1825: int ! 1826: utimes(p, uap, retval) ! 1827: struct proc *p; ! 1828: register struct utimes_args *uap; ! 1829: register_t *retval; ! 1830: { ! 1831: register struct vnode *vp; ! 1832: struct timeval tv[2]; ! 1833: struct vattr vattr; ! 1834: int error; ! 1835: struct nameidata nd; ! 1836: ! 1837: VATTR_NULL(&vattr); ! 1838: if (uap->tptr == NULL) { ! 1839: microtime(&tv[0]); ! 1840: tv[1] = tv[0]; ! 1841: vattr.va_vaflags |= VA_UTIMES_NULL; ! 1842: } else if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, ! 1843: sizeof (tv))) ! 1844: return (error); ! 1845: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 1846: if (error = namei(&nd)) ! 1847: return (error); ! 1848: vp = nd.ni_vp; ! 1849: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1850: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1851: vattr.va_atime.tv_sec = tv[0].tv_sec; ! 1852: vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000; ! 1853: vattr.va_mtime.tv_sec = tv[1].tv_sec; ! 1854: vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000; ! 1855: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1856: vput(vp); ! 1857: return (error); ! 1858: } ! 1859: ! 1860: /* ! 1861: * Truncate a file given its path name. ! 1862: */ ! 1863: struct truncate_args { ! 1864: char *path; ! 1865: #ifdef DOUBLE_ALIGN_PARAMS ! 1866: int pad; ! 1867: #endif ! 1868: off_t length; ! 1869: }; ! 1870: /* ARGSUSED */ ! 1871: int ! 1872: truncate(p, uap, retval) ! 1873: struct proc *p; ! 1874: register struct truncate_args *uap; ! 1875: register_t *retval; ! 1876: { ! 1877: register struct vnode *vp; ! 1878: struct vattr vattr; ! 1879: int error; ! 1880: struct nameidata nd; ! 1881: ! 1882: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 1883: if (error = namei(&nd)) ! 1884: return (error); ! 1885: vp = nd.ni_vp; ! 1886: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1887: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1888: if (vp->v_type == VDIR) ! 1889: error = EISDIR; ! 1890: else if ((error = vn_writechk(vp)) == 0 && ! 1891: (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) { ! 1892: VATTR_NULL(&vattr); ! 1893: vattr.va_size = uap->length; ! 1894: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); ! 1895: } ! 1896: vput(vp); ! 1897: return (error); ! 1898: } ! 1899: ! 1900: /* ! 1901: * Truncate a file given a file descriptor. ! 1902: */ ! 1903: struct ftruncate_args { ! 1904: int fd; ! 1905: #ifdef DOUBLE_ALIGN_PARAMS ! 1906: int pad; ! 1907: #endif ! 1908: off_t length; ! 1909: }; ! 1910: /* ARGSUSED */ ! 1911: int ! 1912: ftruncate(p, uap, retval) ! 1913: struct proc *p; ! 1914: register struct ftruncate_args *uap; ! 1915: register_t *retval; ! 1916: { ! 1917: struct vattr vattr; ! 1918: struct vnode *vp; ! 1919: struct file *fp; ! 1920: int error; ! 1921: ! 1922: if (error = getvnode(p, uap->fd, &fp)) ! 1923: return (error); ! 1924: if ((fp->f_flag & FWRITE) == 0) ! 1925: return (EINVAL); ! 1926: vp = (struct vnode *)fp->f_data; ! 1927: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 1928: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 1929: if (vp->v_type == VDIR) ! 1930: error = EISDIR; ! 1931: else if ((error = vn_writechk(vp)) == 0) { ! 1932: VATTR_NULL(&vattr); ! 1933: vattr.va_size = uap->length; ! 1934: error = VOP_SETATTR(vp, &vattr, fp->f_cred, p); ! 1935: } ! 1936: VOP_UNLOCK(vp, 0, p); ! 1937: return (error); ! 1938: } ! 1939: ! 1940: #if COMPAT_43 ! 1941: /* ! 1942: * Truncate a file given its path name. ! 1943: */ ! 1944: struct otruncate_args { ! 1945: char *path; ! 1946: long length; ! 1947: }; ! 1948: /* ARGSUSED */ ! 1949: int ! 1950: otruncate(p, uap, retval) ! 1951: struct proc *p; ! 1952: register struct otruncate_args *uap; ! 1953: register_t *retval; ! 1954: { ! 1955: struct truncate_args /* { ! 1956: syscallarg(char *) path; ! 1957: #ifdef DOUBLE_ALIGN_PARAMS ! 1958: syscallarg(int) pad; ! 1959: #endif ! 1960: syscallarg(off_t) length; ! 1961: } */ nuap; ! 1962: ! 1963: nuap.path = uap->path; ! 1964: nuap.length = uap->length; ! 1965: return (truncate(p, &nuap, retval)); ! 1966: } ! 1967: ! 1968: /* ! 1969: * Truncate a file given a file descriptor. ! 1970: */ ! 1971: struct oftruncate_args { ! 1972: int fd; ! 1973: long length; ! 1974: }; ! 1975: /* ARGSUSED */ ! 1976: int ! 1977: oftruncate(p, uap, retval) ! 1978: struct proc *p; ! 1979: register struct oftruncate_args *uap; ! 1980: register_t *retval; ! 1981: { ! 1982: struct ftruncate_args /* { ! 1983: syscallarg(int) fd; ! 1984: #ifdef DOUBLE_ALIGN_PARAMS ! 1985: syscallarg(int) pad; ! 1986: #endif ! 1987: syscallarg(off_t) length; ! 1988: } */ nuap; ! 1989: ! 1990: nuap.fd = uap->fd; ! 1991: nuap.length = uap->length; ! 1992: return (ftruncate(p, &nuap, retval)); ! 1993: } ! 1994: #endif /* COMPAT_43 */ ! 1995: ! 1996: /* ! 1997: * Sync an open file. ! 1998: */ ! 1999: struct fsync_args { ! 2000: int fd; ! 2001: }; ! 2002: /* ARGSUSED */ ! 2003: int ! 2004: fsync(p, uap, retval) ! 2005: struct proc *p; ! 2006: struct fsync_args *uap; ! 2007: register_t *retval; ! 2008: { ! 2009: register struct vnode *vp; ! 2010: struct file *fp; ! 2011: int error; ! 2012: ! 2013: if (error = getvnode(p, uap->fd, &fp)) ! 2014: return (error); ! 2015: vp = (struct vnode *)fp->f_data; ! 2016: #if MACH_NBC ! 2017: mapfs_fsync(vp); ! 2018: #endif ! 2019: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 2020: error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p); ! 2021: VOP_UNLOCK(vp, 0, p); ! 2022: return (error); ! 2023: } ! 2024: ! 2025: /* ! 2026: * Rename files. Source and destination must either both be directories, ! 2027: * or both not be directories. If target is a directory, it must be empty. ! 2028: */ ! 2029: struct rename_args { ! 2030: char *from; ! 2031: char *to; ! 2032: }; ! 2033: /* ARGSUSED */ ! 2034: int ! 2035: rename(p, uap, retval) ! 2036: struct proc *p; ! 2037: register struct rename_args *uap; ! 2038: register_t *retval; ! 2039: { ! 2040: register struct vnode *tvp, *fvp, *tdvp; ! 2041: struct nameidata fromnd, tond; ! 2042: int error; ! 2043: ! 2044: NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE, ! 2045: uap->from, p); ! 2046: if (error = namei(&fromnd)) ! 2047: return (error); ! 2048: fvp = fromnd.ni_vp; ! 2049: NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART, ! 2050: UIO_USERSPACE, uap->to, p); ! 2051: if (error = namei(&tond)) { ! 2052: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); ! 2053: vrele(fromnd.ni_dvp); ! 2054: vrele(fvp); ! 2055: goto out1; ! 2056: } ! 2057: tdvp = tond.ni_dvp; ! 2058: tvp = tond.ni_vp; ! 2059: if (tvp != NULL) { ! 2060: if (fvp->v_type == VDIR && tvp->v_type != VDIR) { ! 2061: error = ENOTDIR; ! 2062: goto out; ! 2063: } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) { ! 2064: error = EISDIR; ! 2065: goto out; ! 2066: } ! 2067: } ! 2068: if (fvp == tdvp) ! 2069: error = EINVAL; ! 2070: /* ! 2071: * If source is the same as the destination (that is the ! 2072: * same inode number) then there is nothing to do. ! 2073: * (fixed to have POSIX semantics - CSM 3/2/98) ! 2074: */ ! 2075: if (fvp == tvp) ! 2076: error = -1; ! 2077: out: ! 2078: if (!error) { ! 2079: VOP_LEASE(tdvp, p, p->p_ucred, LEASE_WRITE); ! 2080: if (fromnd.ni_dvp != tdvp) ! 2081: VOP_LEASE(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 2082: if (tvp) ! 2083: VOP_LEASE(tvp, p, p->p_ucred, LEASE_WRITE); ! 2084: error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd, ! 2085: tond.ni_dvp, tond.ni_vp, &tond.ni_cnd); ! 2086: } else { ! 2087: VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd); ! 2088: if (tdvp == tvp) ! 2089: vrele(tdvp); ! 2090: else ! 2091: vput(tdvp); ! 2092: if (tvp) ! 2093: vput(tvp); ! 2094: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); ! 2095: vrele(fromnd.ni_dvp); ! 2096: vrele(fvp); ! 2097: } ! 2098: vrele(tond.ni_startdir); ! 2099: FREE_ZONE(tond.ni_cnd.cn_pnbuf, tond.ni_cnd.cn_pnlen, M_NAMEI); ! 2100: out1: ! 2101: if (fromnd.ni_startdir) ! 2102: vrele(fromnd.ni_startdir); ! 2103: FREE_ZONE(fromnd.ni_cnd.cn_pnbuf, fromnd.ni_cnd.cn_pnlen, M_NAMEI); ! 2104: if (error == -1) ! 2105: return (0); ! 2106: return (error); ! 2107: } ! 2108: ! 2109: /* ! 2110: * Make a directory file. ! 2111: */ ! 2112: struct mkdir_args { ! 2113: char *path; ! 2114: int mode; ! 2115: }; ! 2116: /* ARGSUSED */ ! 2117: int ! 2118: mkdir(p, uap, retval) ! 2119: struct proc *p; ! 2120: register struct mkdir_args *uap; ! 2121: register_t *retval; ! 2122: { ! 2123: register struct vnode *vp; ! 2124: struct vattr vattr; ! 2125: int error; ! 2126: struct nameidata nd; ! 2127: ! 2128: NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->path, p); ! 2129: if (error = namei(&nd)) ! 2130: return (error); ! 2131: vp = nd.ni_vp; ! 2132: if (vp != NULL) { ! 2133: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 2134: if (nd.ni_dvp == vp) ! 2135: vrele(nd.ni_dvp); ! 2136: else ! 2137: vput(nd.ni_dvp); ! 2138: vrele(vp); ! 2139: return (EEXIST); ! 2140: } ! 2141: VATTR_NULL(&vattr); ! 2142: vattr.va_type = VDIR; ! 2143: vattr.va_mode = (uap->mode & ACCESSPERMS) &~ p->p_fd->fd_cmask; ! 2144: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 2145: error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); ! 2146: if (!error) ! 2147: vput(nd.ni_vp); ! 2148: return (error); ! 2149: } ! 2150: ! 2151: /* ! 2152: * Remove a directory file. ! 2153: */ ! 2154: struct rmdir_args { ! 2155: char *path; ! 2156: }; ! 2157: /* ARGSUSED */ ! 2158: int ! 2159: rmdir(p, uap, retval) ! 2160: struct proc *p; ! 2161: struct rmdir_args *uap; ! 2162: register_t *retval; ! 2163: { ! 2164: register struct vnode *vp; ! 2165: int error; ! 2166: struct nameidata nd; ! 2167: ! 2168: NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, ! 2169: uap->path, p); ! 2170: if (error = namei(&nd)) ! 2171: return (error); ! 2172: vp = nd.ni_vp; ! 2173: if (vp->v_type != VDIR) { ! 2174: error = ENOTDIR; ! 2175: goto out; ! 2176: } ! 2177: /* ! 2178: * No rmdir "." please. ! 2179: */ ! 2180: if (nd.ni_dvp == vp) { ! 2181: error = EINVAL; ! 2182: goto out; ! 2183: } ! 2184: /* ! 2185: * The root of a mounted filesystem cannot be deleted. ! 2186: */ ! 2187: if (vp->v_flag & VROOT) ! 2188: error = EBUSY; ! 2189: out: ! 2190: if (!error) { ! 2191: VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); ! 2192: VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); ! 2193: error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); ! 2194: } else { ! 2195: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); ! 2196: if (nd.ni_dvp == vp) ! 2197: vrele(nd.ni_dvp); ! 2198: else ! 2199: vput(nd.ni_dvp); ! 2200: vput(vp); ! 2201: } ! 2202: return (error); ! 2203: } ! 2204: ! 2205: #if COMPAT_43 ! 2206: /* ! 2207: * Read a block of directory entries in a file system independent format. ! 2208: */ ! 2209: struct ogetdirentries_args { ! 2210: int fd; ! 2211: char *buf; ! 2212: u_int count; ! 2213: long *basep; ! 2214: }; ! 2215: int ! 2216: ogetdirentries(p, uap, retval) ! 2217: struct proc *p; ! 2218: register struct ogetdirentries_args *uap; ! 2219: register_t *retval; ! 2220: { ! 2221: register struct vnode *vp; ! 2222: struct file *fp; ! 2223: struct uio auio, kuio; ! 2224: struct iovec aiov, kiov; ! 2225: struct dirent *dp, *edp; ! 2226: caddr_t dirbuf; ! 2227: int error, eofflag, readcnt; ! 2228: long loff; ! 2229: ! 2230: if (error = getvnode(p, uap->fd, &fp)) ! 2231: return (error); ! 2232: if ((fp->f_flag & FREAD) == 0) ! 2233: return (EBADF); ! 2234: vp = (struct vnode *)fp->f_data; ! 2235: unionread: ! 2236: if (vp->v_type != VDIR) ! 2237: return (EINVAL); ! 2238: aiov.iov_base = uap->buf; ! 2239: aiov.iov_len = uap->count; ! 2240: auio.uio_iov = &aiov; ! 2241: auio.uio_iovcnt = 1; ! 2242: auio.uio_rw = UIO_READ; ! 2243: auio.uio_segflg = UIO_USERSPACE; ! 2244: auio.uio_procp = p; ! 2245: auio.uio_resid = uap->count; ! 2246: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 2247: loff = auio.uio_offset = fp->f_offset; ! 2248: # if (BYTE_ORDER != LITTLE_ENDIAN) ! 2249: if (vp->v_mount->mnt_maxsymlinklen <= 0) { ! 2250: error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, ! 2251: (int *)0, (u_long *)0); ! 2252: fp->f_offset = auio.uio_offset; ! 2253: } else ! 2254: # endif ! 2255: { ! 2256: kuio = auio; ! 2257: kuio.uio_iov = &kiov; ! 2258: kuio.uio_segflg = UIO_SYSSPACE; ! 2259: kiov.iov_len = uap->count; ! 2260: MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK); ! 2261: kiov.iov_base = dirbuf; ! 2262: error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag, ! 2263: (int *)0, (u_long *)0); ! 2264: fp->f_offset = kuio.uio_offset; ! 2265: if (error == 0) { ! 2266: readcnt = uap->count - kuio.uio_resid; ! 2267: edp = (struct dirent *)&dirbuf[readcnt]; ! 2268: for (dp = (struct dirent *)dirbuf; dp < edp; ) { ! 2269: # if (BYTE_ORDER == LITTLE_ENDIAN) ! 2270: /* ! 2271: * The expected low byte of ! 2272: * dp->d_namlen is our dp->d_type. ! 2273: * The high MBZ byte of dp->d_namlen ! 2274: * is our dp->d_namlen. ! 2275: */ ! 2276: dp->d_type = dp->d_namlen; ! 2277: dp->d_namlen = 0; ! 2278: # else ! 2279: /* ! 2280: * The dp->d_type is the high byte ! 2281: * of the expected dp->d_namlen, ! 2282: * so must be zero'ed. ! 2283: */ ! 2284: dp->d_type = 0; ! 2285: # endif ! 2286: if (dp->d_reclen > 0) { ! 2287: dp = (struct dirent *) ! 2288: ((char *)dp + dp->d_reclen); ! 2289: } else { ! 2290: error = EIO; ! 2291: break; ! 2292: } ! 2293: } ! 2294: if (dp >= edp) ! 2295: error = uiomove(dirbuf, readcnt, &auio); ! 2296: } ! 2297: FREE(dirbuf, M_TEMP); ! 2298: } ! 2299: VOP_UNLOCK(vp, 0, p); ! 2300: if (error) ! 2301: return (error); ! 2302: ! 2303: #if UNION ! 2304: { ! 2305: extern int (**union_vnodeop_p)(); ! 2306: extern struct vnode *union_dircache __P((struct vnode*, struct proc*)); ! 2307: ! 2308: if ((uap->count == auio.uio_resid) && ! 2309: (vp->v_op == union_vnodeop_p)) { ! 2310: struct vnode *lvp; ! 2311: ! 2312: lvp = union_dircache(vp, p); ! 2313: if (lvp != NULLVP) { ! 2314: struct vattr va; ! 2315: ! 2316: /* ! 2317: * If the directory is opaque, ! 2318: * then don't show lower entries ! 2319: */ ! 2320: error = VOP_GETATTR(vp, &va, fp->f_cred, p); ! 2321: if (va.va_flags & OPAQUE) { ! 2322: vput(lvp); ! 2323: lvp = NULL; ! 2324: } ! 2325: } ! 2326: ! 2327: if (lvp != NULLVP) { ! 2328: error = VOP_OPEN(lvp, FREAD, fp->f_cred, p); ! 2329: if (error) { ! 2330: vput(lvp); ! 2331: return (error); ! 2332: } ! 2333: VOP_UNLOCK(lvp, 0, p); ! 2334: fp->f_data = (caddr_t) lvp; ! 2335: fp->f_offset = 0; ! 2336: error = vn_close(vp, FREAD, fp->f_cred, p); ! 2337: if (error) ! 2338: return (error); ! 2339: vp = lvp; ! 2340: goto unionread; ! 2341: } ! 2342: } ! 2343: } ! 2344: #endif /* UNION */ ! 2345: ! 2346: if ((uap->count == auio.uio_resid) && ! 2347: (vp->v_flag & VROOT) && ! 2348: (vp->v_mount->mnt_flag & MNT_UNION)) { ! 2349: struct vnode *tvp = vp; ! 2350: vp = vp->v_mount->mnt_vnodecovered; ! 2351: VREF(vp); ! 2352: fp->f_data = (caddr_t) vp; ! 2353: fp->f_offset = 0; ! 2354: vrele(tvp); ! 2355: goto unionread; ! 2356: } ! 2357: error = copyout((caddr_t)&loff, (caddr_t)uap->basep, ! 2358: sizeof(long)); ! 2359: *retval = uap->count - auio.uio_resid; ! 2360: return (error); ! 2361: } ! 2362: #endif /* COMPAT_43 */ ! 2363: ! 2364: /* ! 2365: * Read a block of directory entries in a file system independent format. ! 2366: */ ! 2367: struct getdirentries_args { ! 2368: int fd; ! 2369: char *buf; ! 2370: u_int count; ! 2371: long *basep; ! 2372: }; ! 2373: int ! 2374: getdirentries(p, uap, retval) ! 2375: struct proc *p; ! 2376: register struct getdirentries_args *uap; ! 2377: register_t *retval; ! 2378: { ! 2379: register struct vnode *vp; ! 2380: struct file *fp; ! 2381: struct uio auio; ! 2382: struct iovec aiov; ! 2383: long loff; ! 2384: int error, eofflag; ! 2385: ! 2386: if (error = getvnode(p, uap->fd, &fp)) ! 2387: return (error); ! 2388: if ((fp->f_flag & FREAD) == 0) ! 2389: return (EBADF); ! 2390: vp = (struct vnode *)fp->f_data; ! 2391: unionread: ! 2392: if (vp->v_type != VDIR) ! 2393: return (EINVAL); ! 2394: aiov.iov_base = uap->buf; ! 2395: aiov.iov_len = uap->count; ! 2396: auio.uio_iov = &aiov; ! 2397: auio.uio_iovcnt = 1; ! 2398: auio.uio_rw = UIO_READ; ! 2399: auio.uio_segflg = UIO_USERSPACE; ! 2400: auio.uio_procp = p; ! 2401: auio.uio_resid = uap->count; ! 2402: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 2403: loff = auio.uio_offset = fp->f_offset; ! 2404: error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, ! 2405: (int *)0, (u_long *)0); ! 2406: fp->f_offset = auio.uio_offset; ! 2407: VOP_UNLOCK(vp, 0, p); ! 2408: if (error) ! 2409: return (error); ! 2410: ! 2411: #if UNION ! 2412: { ! 2413: extern int (**union_vnodeop_p)(); ! 2414: extern struct vnode *union_dircache __P((struct vnode*, struct proc*)); ! 2415: ! 2416: if ((uap->count == auio.uio_resid) && ! 2417: (vp->v_op == union_vnodeop_p)) { ! 2418: struct vnode *lvp; ! 2419: ! 2420: lvp = union_dircache(vp, p); ! 2421: if (lvp != NULLVP) { ! 2422: struct vattr va; ! 2423: ! 2424: /* ! 2425: * If the directory is opaque, ! 2426: * then don't show lower entries ! 2427: */ ! 2428: error = VOP_GETATTR(vp, &va, fp->f_cred, p); ! 2429: if (va.va_flags & OPAQUE) { ! 2430: vput(lvp); ! 2431: lvp = NULL; ! 2432: } ! 2433: } ! 2434: ! 2435: if (lvp != NULLVP) { ! 2436: error = VOP_OPEN(lvp, FREAD, fp->f_cred, p); ! 2437: if (error) { ! 2438: vput(lvp); ! 2439: return (error); ! 2440: } ! 2441: VOP_UNLOCK(lvp, 0, p); ! 2442: fp->f_data = (caddr_t) lvp; ! 2443: fp->f_offset = 0; ! 2444: error = vn_close(vp, FREAD, fp->f_cred, p); ! 2445: if (error) ! 2446: return (error); ! 2447: vp = lvp; ! 2448: goto unionread; ! 2449: } ! 2450: } ! 2451: } ! 2452: #endif /* UNION */ ! 2453: ! 2454: if ((uap->count == auio.uio_resid) && ! 2455: (vp->v_flag & VROOT) && ! 2456: (vp->v_mount->mnt_flag & MNT_UNION)) { ! 2457: struct vnode *tvp = vp; ! 2458: vp = vp->v_mount->mnt_vnodecovered; ! 2459: VREF(vp); ! 2460: fp->f_data = (caddr_t) vp; ! 2461: fp->f_offset = 0; ! 2462: vrele(tvp); ! 2463: goto unionread; ! 2464: } ! 2465: error = copyout((caddr_t)&loff, (caddr_t)uap->basep, ! 2466: sizeof(long)); ! 2467: *retval = uap->count - auio.uio_resid; ! 2468: return (error); ! 2469: } ! 2470: ! 2471: /* ! 2472: * Set the mode mask for creation of filesystem nodes. ! 2473: */ ! 2474: struct umask_args { ! 2475: int newmask; ! 2476: }; ! 2477: int ! 2478: umask(p, uap, retval) ! 2479: struct proc *p; ! 2480: struct umask_args *uap; ! 2481: register_t *retval; ! 2482: { ! 2483: register struct filedesc *fdp; ! 2484: ! 2485: fdp = p->p_fd; ! 2486: *retval = fdp->fd_cmask; ! 2487: fdp->fd_cmask = uap->newmask & ALLPERMS; ! 2488: return (0); ! 2489: } ! 2490: ! 2491: /* ! 2492: * Void all references to file by ripping underlying filesystem ! 2493: * away from vnode. ! 2494: */ ! 2495: struct revoke_args { ! 2496: char *path; ! 2497: }; ! 2498: /* ARGSUSED */ ! 2499: int ! 2500: revoke(p, uap, retval) ! 2501: struct proc *p; ! 2502: register struct revoke_args *uap; ! 2503: register_t *retval; ! 2504: { ! 2505: register struct vnode *vp; ! 2506: struct vattr vattr; ! 2507: int error; ! 2508: struct nameidata nd; ! 2509: ! 2510: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); ! 2511: if (error = namei(&nd)) ! 2512: return (error); ! 2513: vp = nd.ni_vp; ! 2514: if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) ! 2515: goto out; ! 2516: if (p->p_ucred->cr_uid != vattr.va_uid && ! 2517: (error = suser(p->p_ucred, &p->p_acflag))) ! 2518: goto out; ! 2519: if (vp->v_usecount > 1 || (vp->v_flag & VALIASED)) ! 2520: VOP_REVOKE(vp, REVOKEALL); ! 2521: out: ! 2522: vrele(vp); ! 2523: return (error); ! 2524: } ! 2525: ! 2526: /* ! 2527: * Convert a user file descriptor to a kernel file entry. ! 2528: */ ! 2529: int ! 2530: getvnode(p, fd, fpp) ! 2531: struct proc *p; ! 2532: int fd; ! 2533: struct file **fpp; ! 2534: { ! 2535: struct file *fp; ! 2536: int error; ! 2537: ! 2538: if (error = fdgetf(p, fd, &fp)) ! 2539: return (error); ! 2540: if (fp->f_type != DTYPE_VNODE) ! 2541: return (EINVAL); ! 2542: *fpp = fp; ! 2543: return (0); ! 2544: } ! 2545: /* ! 2546: * HFS/HFS PlUS SPECIFIC SYSTEM CALLS ! 2547: * The following 10 system calls are designed to support features ! 2548: * which are specific to the HFS & HFS Plus volume formats ! 2549: */ ! 2550: ! 2551: ! 2552: /* ! 2553: * Make a complex file. A complex file is one with multiple forks (data streams) ! 2554: */ ! 2555: struct mkcomplex_args { ! 2556: const char *path; /* pathname of the file to be created */ ! 2557: mode_t mode; /* access mode for the newly created file */ ! 2558: u_long type; /* format of the complex file */ ! 2559: }; ! 2560: /* ARGSUSED */ ! 2561: int ! 2562: mkcomplex(p,uap,retval) ! 2563: struct proc *p; ! 2564: register struct mkcomplex_args *uap; ! 2565: register_t *retval; ! 2566: ! 2567: { ! 2568: struct vnode *vp; ! 2569: struct vattr vattr; ! 2570: int error; ! 2571: struct nameidata nd; ! 2572: ! 2573: /* mkcomplex wants the directory vnode locked so do that here */ ! 2574: ! 2575: NDINIT(&nd, CREATE, FOLLOW | LOCKPARENT, UIO_USERSPACE, uap->path, p); ! 2576: if (error = namei(&nd)) ! 2577: return (error); ! 2578: ! 2579: /* Set the attributes as specified by the user */ ! 2580: ! 2581: VATTR_NULL(&vattr); ! 2582: vattr.va_mode = (uap->mode & ACCESSPERMS); ! 2583: error = VOP_MKCOMPLEX(nd.ni_dvp, &vp, &nd.ni_cnd, &vattr, uap->type); ! 2584: ! 2585: /* The mkcomplex call promises to release the parent vnode pointer ! 2586: * even an an error case so don't do it here unless the operation ! 2587: * is not supported. In that case, there isn't anyone to unlock the parent ! 2588: * The vnode pointer to the file will also be released. ! 2589: */ ! 2590: ! 2591: if (error) ! 2592: { ! 2593: if (error == EOPNOTSUPP) ! 2594: vput(nd.ni_dvp); ! 2595: return (error); ! 2596: } ! 2597: ! 2598: return (0); ! 2599: ! 2600: } /* end of mkcomplex system call */ ! 2601: ! 2602: ! 2603: ! 2604: /* ! 2605: * Extended stat call which returns volumeid and vnodeid as well as other info ! 2606: */ ! 2607: struct statv_args { ! 2608: const char *path; /* pathname of the target file */ ! 2609: struct vstat *vsb; /* vstat structure for returned info */ ! 2610: }; ! 2611: /* ARGSUSED */ ! 2612: int ! 2613: statv(p,uap,retval) ! 2614: struct proc *p; ! 2615: register struct statv_args *uap; ! 2616: register_t *retval; ! 2617: ! 2618: { ! 2619: return (EOPNOTSUPP); /* We'll just return an error for now */ ! 2620: ! 2621: } /* end of statv system call */ ! 2622: ! 2623: ! 2624: ! 2625: /* ! 2626: * Extended lstat call which returns volumeid and vnodeid as well as other info ! 2627: */ ! 2628: struct lstatv_args { ! 2629: const char *path; /* pathname of the target file */ ! 2630: struct vstat *vsb; /* vstat structure for returned info */ ! 2631: }; ! 2632: /* ARGSUSED */ ! 2633: int ! 2634: lstatv(p,uap,retval) ! 2635: struct proc *p; ! 2636: register struct lstatv_args *uap; ! 2637: register_t *retval; ! 2638: ! 2639: { ! 2640: return (EOPNOTSUPP); /* We'll just return an error for now */ ! 2641: } /* end of lstatv system call */ ! 2642: ! 2643: ! 2644: ! 2645: /* ! 2646: * Extended fstat call which returns volumeid and vnodeid as well as other info ! 2647: */ ! 2648: struct fstatv_args { ! 2649: int fd; /* file descriptor of the target file */ ! 2650: struct vstat *vsb; /* vstat structure for returned info */ ! 2651: }; ! 2652: /* ARGSUSED */ ! 2653: int ! 2654: fstatv(p,uap,retval) ! 2655: struct proc *p; ! 2656: register struct fstatv_args *uap; ! 2657: register_t *retval; ! 2658: ! 2659: { ! 2660: return (EOPNOTSUPP); /* We'll just return an error for now */ ! 2661: } /* end of fstatv system call */ ! 2662: ! 2663: ! 2664: ! 2665: /* ! 2666: * Obtain attribute information about a file system object ! 2667: */ ! 2668: ! 2669: struct getattrlist_args { ! 2670: const char *path; /* pathname of the target object */ ! 2671: struct attrlist * alist; /* Attributes desired by the user */ ! 2672: void * attributeBuffer; /* buffer to hold returned attributes */ ! 2673: size_t bufferSize; /* size of the return buffer */ ! 2674: }; ! 2675: /* ARGSUSED */ ! 2676: int ! 2677: getattrlist (p,uap,retval) ! 2678: struct proc *p; ! 2679: register struct getattrlist_args *uap; ! 2680: register_t *retval; ! 2681: ! 2682: { ! 2683: int error; ! 2684: struct nameidata nd; ! 2685: struct iovec aiov; ! 2686: struct uio auio; ! 2687: struct attrlist attributelist; ! 2688: ! 2689: /* Get the attributes desire and do our parameter checking */ ! 2690: ! 2691: if (error = copyin((caddr_t)uap->alist, (caddr_t) &attributelist, ! 2692: sizeof (attributelist))) ! 2693: { ! 2694: return(error); ! 2695: } ! 2696: ! 2697: if (attributelist.bitmapcount != ATTR_BIT_MAP_COUNT ! 2698: #if 0 ! 2699: || attributelist.commonattr & ~ATTR_CMN_VALIDMASK || ! 2700: attributelist.volattr & ~ATTR_VOL_VALIDMASK || ! 2701: attributelist.dirattr & ~ATTR_DIR_VALIDMASK || ! 2702: attributelist.fileattr & ~ATTR_FILE_VALIDMASK || ! 2703: attributelist.forkattr & ~ATTR_FORK_VALIDMASK ! 2704: #endif ! 2705: ) ! 2706: { ! 2707: return (EINVAL); ! 2708: } ! 2709: ! 2710: /* Get the vnode for the file we are getting info on. */ ! 2711: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p); ! 2712: ! 2713: if (error = namei(&nd)) ! 2714: return (error); ! 2715: ! 2716: /* Set up the UIO structure for use by the vfs routine */ ! 2717: ! 2718: ! 2719: aiov.iov_base = uap->attributeBuffer; ! 2720: aiov.iov_len = uap->bufferSize; ! 2721: auio.uio_iov = &aiov; ! 2722: auio.uio_iovcnt = 1; ! 2723: auio.uio_offset = 0; ! 2724: auio.uio_rw = UIO_READ; ! 2725: auio.uio_segflg = UIO_USERSPACE; ! 2726: auio.uio_procp = p; ! 2727: auio.uio_resid = uap->bufferSize; ! 2728: ! 2729: ! 2730: error = VOP_GETATTRLIST(nd.ni_vp, &attributelist, &auio, p->p_ucred, p); ! 2731: ! 2732: /* Unlock and release the vnode which will have been locked by namei */ ! 2733: ! 2734: vput(nd.ni_vp); ! 2735: ! 2736: /* return the effort if we got one, otherwise return success */ ! 2737: ! 2738: if (error) ! 2739: { ! 2740: return (error); ! 2741: } ! 2742: ! 2743: return(0); ! 2744: ! 2745: } /* end of getattrlist system call */ ! 2746: ! 2747: ! 2748: ! 2749: /* ! 2750: * Set attribute information about a file system object ! 2751: */ ! 2752: ! 2753: struct setattrlist_args { ! 2754: const char *path; /* pathname of the target object */ ! 2755: struct attrlist * alist; /* Attributes being set by the user */ ! 2756: void * attributeBuffer; /* buffer with attribute values to be set */ ! 2757: size_t bufferSize; /* size of the return buffer */ ! 2758: }; ! 2759: /* ARGSUSED */ ! 2760: int ! 2761: setattrlist (p,uap,retval) ! 2762: struct proc *p; ! 2763: register struct setattrlist_args *uap; ! 2764: register_t *retval; ! 2765: ! 2766: { ! 2767: int error; ! 2768: struct nameidata nd; ! 2769: struct iovec aiov; ! 2770: struct uio auio; ! 2771: struct attrlist attributelist; ! 2772: ! 2773: /* Get the attributes desire and do our parameter checking */ ! 2774: ! 2775: if (error = copyin((caddr_t)uap->alist, (caddr_t) &attributelist, ! 2776: sizeof (attributelist))) ! 2777: { ! 2778: return(error); ! 2779: } ! 2780: ! 2781: if (attributelist.bitmapcount != ATTR_BIT_MAP_COUNT ! 2782: #if 0 ! 2783: || attributelist.commonattr & ~ATTR_CMN_VALIDMASK || ! 2784: attributelist.volattr & ~ATTR_VOL_VALIDMASK || ! 2785: attributelist.dirattr & ~ATTR_DIR_VALIDMASK || ! 2786: attributelist.fileattr & ~ATTR_FILE_VALIDMASK || ! 2787: attributelist.forkattr & ~ATTR_FORK_VALIDMASK ! 2788: #endif ! 2789: ) ! 2790: { ! 2791: return (EINVAL); ! 2792: } ! 2793: ! 2794: /* Get the vnode for the file we are getting info on. */ ! 2795: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p); ! 2796: ! 2797: if (error = namei(&nd)) ! 2798: return (error); ! 2799: ! 2800: /* Set up the UIO structure for use by the vfs routine */ ! 2801: ! 2802: aiov.iov_base = uap->attributeBuffer; ! 2803: aiov.iov_len = uap->bufferSize; ! 2804: auio.uio_iov = &aiov; ! 2805: auio.uio_iovcnt = 1; ! 2806: auio.uio_offset = 0; ! 2807: auio.uio_rw = UIO_WRITE; ! 2808: auio.uio_segflg = UIO_USERSPACE; ! 2809: auio.uio_procp = p; ! 2810: auio.uio_resid = uap->bufferSize; ! 2811: ! 2812: ! 2813: error = VOP_SETATTRLIST(nd.ni_vp,&attributelist, &auio, p->p_ucred, p); ! 2814: ! 2815: /* Unlock and release the vnode which will have been locked by namei */ ! 2816: ! 2817: vput(nd.ni_vp); ! 2818: ! 2819: /* return the error if we got one, otherwise return success */ ! 2820: ! 2821: if (error) ! 2822: { ! 2823: return (error); ! 2824: } ! 2825: ! 2826: return(0); ! 2827: ! 2828: } /* end of setattrlist system call */ ! 2829: ! 2830: ! 2831: /* ! 2832: * Obtain attribute information on objects in a directory while enumerating ! 2833: the directory. This call does not yet support union mounted directories. ! 2834: */ ! 2835: ! 2836: struct getdirentryattr_args { ! 2837: int fd; /* file descriptor */ ! 2838: int *index; /* Cookie from the user */ ! 2839: struct attrlist *alist; /* bit map of requested attributes */ ! 2840: void *attributebuffer; /* buffer to hold returned attribute info */ ! 2841: size_t buffersize; /* size of the return buffer */ ! 2842: }; ! 2843: /* ARGSUSED */ ! 2844: int ! 2845: getdirentryattr (p,uap,retval) ! 2846: struct proc *p; ! 2847: register struct getdirentryattr_args *uap; ! 2848: register_t *retval; ! 2849: ! 2850: { ! 2851: register struct vnode *vp; ! 2852: struct file *fp; ! 2853: struct uio auio; ! 2854: struct iovec aiov; ! 2855: int index; ! 2856: int error, eofflag; ! 2857: struct attrlist attributelist; ! 2858: ! 2859: /* Get the attributes desired and do our parameter checking */ ! 2860: ! 2861: if (error = copyin((caddr_t)uap->alist, (caddr_t) &attributelist, ! 2862: sizeof (attributelist))) ! 2863: { ! 2864: return(error); ! 2865: } ! 2866: ! 2867: if (attributelist.bitmapcount != ATTR_BIT_MAP_COUNT) ! 2868: { ! 2869: return (EINVAL); ! 2870: } ! 2871: ! 2872: if (error = getvnode(p, uap->fd, &fp)) ! 2873: return (error); ! 2874: ! 2875: if ((fp->f_flag & FREAD) == 0) ! 2876: { ! 2877: return(EBADF); ! 2878: } ! 2879: ! 2880: vp = (struct vnode *)fp->f_data; ! 2881: ! 2882: if (vp->v_type != VDIR) ! 2883: { ! 2884: return(EINVAL); ! 2885: } ! 2886: ! 2887: if (error = copyin((caddr_t) uap->index, (caddr_t) &index, sizeof(index))) ! 2888: return(error); ! 2889: ! 2890: /* set up the uio structure which will contain the users return buffer */ ! 2891: ! 2892: aiov.iov_base = uap->attributebuffer; ! 2893: aiov.iov_len = uap->buffersize; ! 2894: auio.uio_iov = &aiov; ! 2895: auio.uio_iovcnt = 1; ! 2896: auio.uio_rw = UIO_READ; ! 2897: auio.uio_segflg = UIO_USERSPACE; ! 2898: auio.uio_procp = p; ! 2899: auio.uio_resid = uap->buffersize; ! 2900: ! 2901: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 2902: error = VOP_READDIRATTR (vp, &attributelist, &auio, &index, &eofflag,((u_long*)0), ((u_long **)0),fp->f_cred); ! 2903: fp->f_offset = auio.uio_offset; ! 2904: ! 2905: if (error) ! 2906: return (error); ! 2907: ! 2908: VOP_UNLOCK(vp, 0, p); ! 2909: ! 2910: if (error = copyout((caddr_t) &index, (caddr_t) uap->index, sizeof(index))) ! 2911: return(error); ! 2912: ! 2913: return (0); ! 2914: ! 2915: } /* end of getdirentryattr system call */ ! 2916: ! 2917: /* ! 2918: * Exchange data between two files ! 2919: */ ! 2920: ! 2921: struct exchangedata_args { ! 2922: const char *path1; /* pathname of the first swapee */ ! 2923: const char *path2; /* pathname of the second swapee */ ! 2924: }; ! 2925: /* ARGSUSED */ ! 2926: int ! 2927: exchangedata (p,uap,retval) ! 2928: struct proc *p; ! 2929: register struct exchangedata_args *uap; ! 2930: register_t *retval; ! 2931: ! 2932: { ! 2933: ! 2934: struct nameidata fnd, snd; ! 2935: struct vnode *fvp, *svp; ! 2936: int error; ! 2937: ! 2938: /* Global lock, to prevent race condition, only one exchange at a time */ ! 2939: lockmgr(&exchangelock, LK_EXCLUSIVE , (struct slock *)0, p); ! 2940: ! 2941: NDINIT(&fnd, LOOKUP,FOLLOW, UIO_USERSPACE, uap->path1, p); ! 2942: ! 2943: if (error = namei(&fnd)) ! 2944: goto out2; ! 2945: ! 2946: fvp = fnd.ni_vp; ! 2947: ! 2948: NDINIT(&snd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path2, p); ! 2949: ! 2950: if (error = namei(&snd)) { ! 2951: vrele(fvp); ! 2952: goto out2; ! 2953: } ! 2954: ! 2955: svp = snd.ni_vp; ! 2956: ! 2957: /* if the files are the same, return an inval error */ ! 2958: if (svp == fvp) { ! 2959: vrele(fvp); ! 2960: vrele(svp); ! 2961: error = EINVAL; ! 2962: goto out2; ! 2963: } ! 2964: ! 2965: vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p); ! 2966: vn_lock(svp, LK_EXCLUSIVE | LK_RETRY, p); ! 2967: ! 2968: error = VOP_ACCESS(fvp, VWRITE, p->p_ucred, p); ! 2969: if (error) goto out; ! 2970: ! 2971: error = VOP_ACCESS(svp, VWRITE, p->p_ucred, p); ! 2972: if (error) goto out; ! 2973: ! 2974: /* Ok, make the call */ ! 2975: error = VOP_EXCHANGE (fvp, svp, p->p_ucred, p); ! 2976: ! 2977: out: ! 2978: vput (svp); ! 2979: vput (fvp); ! 2980: ! 2981: out2: ! 2982: lockmgr(&exchangelock, LK_RELEASE, (struct slock *)0, p); ! 2983: ! 2984: if (error) { ! 2985: return (error); ! 2986: } ! 2987: ! 2988: return (0); ! 2989: ! 2990: } /* end of exchangedata system call */ ! 2991: ! 2992: /* ! 2993: * Check users access to a file ! 2994: */ ! 2995: ! 2996: struct checkuseraccess_args { ! 2997: const char *path; /* pathname of the target file */ ! 2998: uid_t userid; /* user for whom we are checking access */ ! 2999: gid_t *groups; /* Group that we are checking for */ ! 3000: int ngroups; /* Number of groups being checked */ ! 3001: int accessrequired; /* needed access to the file */ ! 3002: }; ! 3003: ! 3004: /* ARGSUSED */ ! 3005: int ! 3006: checkuseraccess (p,uap,retval) ! 3007: struct proc *p; ! 3008: register struct checkuseraccess_args *uap; ! 3009: register_t *retval; ! 3010: ! 3011: { ! 3012: register struct vnode *vp; ! 3013: int error; ! 3014: struct nameidata nd; ! 3015: struct ucred cred; ! 3016: int flags; /*what will actually get passed to access*/ ! 3017: ! 3018: /* Make sure that the number of groups is correct before we do anything */ ! 3019: ! 3020: if (uap->ngroups > NGROUPS) ! 3021: return (EINVAL); ! 3022: ! 3023: /* Verify that the caller is root */ ! 3024: ! 3025: if (error = suser(p->p_ucred, &p->p_acflag)) ! 3026: return(error); ! 3027: ! 3028: /* Fill in the credential structure */ ! 3029: ! 3030: cred.cr_ref = 0; ! 3031: cred.cr_uid = uap->userid; ! 3032: cred.cr_ngroups = uap->ngroups; ! 3033: if (error = copyin((caddr_t) uap->groups, (caddr_t) &(cred.cr_groups), (sizeof(gid_t))*uap->ngroups)) ! 3034: return (error); ! 3035: ! 3036: /* Get our hands on the file */ ! 3037: ! 3038: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->path, p); ! 3039: ! 3040: if (error = namei(&nd)) ! 3041: return (error); ! 3042: vp = nd.ni_vp; ! 3043: ! 3044: /* Flags == 0 means only check for existence. */ ! 3045: ! 3046: flags = 0; ! 3047: ! 3048: if (uap->accessrequired) { ! 3049: if (uap->accessrequired & R_OK) ! 3050: flags |= VREAD; ! 3051: if (uap->accessrequired & W_OK) ! 3052: flags |= VWRITE; ! 3053: if (uap->accessrequired & X_OK) ! 3054: flags |= VEXEC; ! 3055: } ! 3056: error = VOP_ACCESS(vp, flags, &cred, p); ! 3057: ! 3058: vput(vp); ! 3059: ! 3060: if (error) ! 3061: return (error); ! 3062: ! 3063: return (0); ! 3064: ! 3065: } /* end of checkuseraccess system call */ ! 3066: ! 3067: ! 3068: struct searchfs_args { ! 3069: const char *path; ! 3070: struct fssearchblock *searchblock; ! 3071: u_long *nummatches; ! 3072: u_long scriptcode; ! 3073: u_long options; ! 3074: struct searchstate *state; ! 3075: }; ! 3076: /* ARGSUSED */ ! 3077: ! 3078: int ! 3079: searchfs (p,uap,retval) ! 3080: struct proc *p; ! 3081: register struct searchfs_args *uap; ! 3082: register_t *retval; ! 3083: ! 3084: { ! 3085: register struct vnode *vp; ! 3086: int error=0; ! 3087: int fserror = 0; ! 3088: struct nameidata nd; ! 3089: struct fssearchblock searchblock; ! 3090: struct searchstate *state; ! 3091: struct attrlist *returnattrs; ! 3092: void *searchparams1,*searchparams2; ! 3093: struct iovec aiov; ! 3094: struct uio auio; ! 3095: u_long nummatches; ! 3096: int mallocsize; ! 3097: ! 3098: ! 3099: /* Start by copying in fsearchblock paramater list */ ! 3100: ! 3101: if (error = copyin((caddr_t) uap->searchblock, (caddr_t) &searchblock,sizeof(struct fssearchblock))) ! 3102: return(error); ! 3103: ! 3104: /* Now malloc a big bunch of space to hold the search parameters, the attrlists and the search state. */ ! 3105: /* It all has to do into local memory and it's not that big so we might as well put it all together. */ ! 3106: /* Searchparams1 shall be first so we might as well use that to hold the base address of the allocated*/ ! 3107: /* block. */ ! 3108: ! 3109: mallocsize = searchblock.sizeofsearchparams1+searchblock.sizeofsearchparams2 + ! 3110: sizeof(struct attrlist) + sizeof(struct searchstate); ! 3111: ! 3112: MALLOC(searchparams1, void *, mallocsize, M_TEMP, M_WAITOK); ! 3113: ! 3114: /* Now set up the various pointers to the correct place in our newly allocated memory */ ! 3115: ! 3116: searchparams2 = (void *) (((caddr_t) searchparams1) + searchblock.sizeofsearchparams1); ! 3117: returnattrs = (struct attrlist *) (((caddr_t) searchparams2) + searchblock.sizeofsearchparams2); ! 3118: state = (struct searchstate *) (((caddr_t) returnattrs) + sizeof (struct attrlist)); ! 3119: ! 3120: /* Now copy in the stuff given our local variables. */ ! 3121: ! 3122: if (error = copyin((caddr_t) searchblock.searchparams1, searchparams1,searchblock.sizeofsearchparams1)) ! 3123: goto freeandexit; ! 3124: ! 3125: if (error = copyin((caddr_t) searchblock.searchparams2, searchparams2,searchblock.sizeofsearchparams2)) ! 3126: goto freeandexit; ! 3127: ! 3128: if (error = copyin((caddr_t) searchblock.returnattrs, (caddr_t) returnattrs, sizeof(struct attrlist))) ! 3129: goto freeandexit; ! 3130: ! 3131: if (error = copyin((caddr_t) uap->state, (caddr_t) state, sizeof(struct searchstate))) ! 3132: goto freeandexit; ! 3133: ! 3134: /* set up the uio structure which will contain the users return buffer */ ! 3135: ! 3136: aiov.iov_base = searchblock.returnbuffer; ! 3137: aiov.iov_len = searchblock.returnbuffersize; ! 3138: auio.uio_iov = &aiov; ! 3139: auio.uio_iovcnt = 1; ! 3140: auio.uio_rw = UIO_READ; ! 3141: auio.uio_segflg = UIO_USERSPACE; ! 3142: auio.uio_procp = p; ! 3143: auio.uio_resid = searchblock.returnbuffersize; ! 3144: ! 3145: ! 3146: NDINIT(&nd, LOOKUP, FOLLOW|LOCKLEAF, UIO_USERSPACE, uap->path, p); ! 3147: ! 3148: if (error = namei(&nd)) ! 3149: goto freeandexit; ! 3150: ! 3151: vp = nd.ni_vp; ! 3152: ! 3153: /* ! 3154: Allright, we have everything we need, so lets make that call. ! 3155: ! 3156: We keep special track of the return value from the file system: ! 3157: EAGAIN is an acceptable error condition that shouldn't keep us ! 3158: from copying out any results... ! 3159: */ ! 3160: ! 3161: fserror = VOP_SEARCHFS(vp, ! 3162: searchparams1, ! 3163: searchparams2, ! 3164: &searchblock.searchattrs, ! 3165: searchblock.maxmatches, ! 3166: &searchblock.timelimit, ! 3167: returnattrs, ! 3168: &nummatches, ! 3169: uap->scriptcode, ! 3170: uap->options, ! 3171: &auio, ! 3172: state); ! 3173: ! 3174: vput(vp); ! 3175: ! 3176: /* Now copy out the stuff that needs copying out. That means the number of matches, the ! 3177: search state. Everything was already put into he return buffer by the vop call. */ ! 3178: ! 3179: if (error = copyout((caddr_t) state, (caddr_t) uap->state, sizeof(struct searchstate))) ! 3180: goto freeandexit; ! 3181: ! 3182: if (error = copyout((caddr_t) &nummatches, (caddr_t) uap->nummatches, sizeof(u_long))) ! 3183: goto freeandexit; ! 3184: ! 3185: error = fserror; ! 3186: ! 3187: freeandexit: ! 3188: ! 3189: FREE(searchparams1,M_TEMP); ! 3190: ! 3191: return(error); ! 3192: ! 3193: ! 3194: } /* end of searchfs system call */ ! 3195: ! 3196:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.