X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/cc1730771008ddc8f1bccc5ed3aa8a987856137e..ad7871609881e73855d0b04da49b486cd93efca7:/usr/src/sys/ufs/ufs/ufs_vnops.c diff --git a/usr/src/sys/ufs/ufs/ufs_vnops.c b/usr/src/sys/ufs/ufs/ufs_vnops.c index 4adf5f9718..71a395e843 100644 --- a/usr/src/sys/ufs/ufs/ufs_vnops.c +++ b/usr/src/sys/ufs/ufs/ufs_vnops.c @@ -1,10 +1,36 @@ /* - * Copyright (c) 1982, 1986, 1989 Regents of the University of California. - * All rights reserved. + * Copyright (c) 1982, 1986, 1989, 1993 + * The Regents of the University of California. All rights reserved. * - * %sccs.include.redist.c% + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. * - * @(#)ufs_vnops.c 7.69 (Berkeley) %G% + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ufs_vnops.c 8.1 (Berkeley) 6/11/93 */ #include @@ -19,9 +45,12 @@ #include #include #include -#include -#include #include +#include + +#include + +#include #include #include @@ -30,33 +59,45 @@ #include #include -static int ufs_chmod __P((struct vnode *, int, struct proc *)); -static int ufs_chown __P((struct vnode *, u_int, u_int, struct proc *)); +static int ufs_chmod __P((struct vnode *, int, struct ucred *, struct proc *)); +static int ufs_chown + __P((struct vnode *, uid_t, gid_t, struct ucred *, struct proc *)); -enum vtype iftovt_tab[16] = { - VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, - VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, -}; -int vttoif_tab[9] = { - 0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFIFO, IFMT, +union _qcvt { + quad_t qcvt; + long val[2]; }; +#define SETHIGH(q, h) { \ + union _qcvt tmp; \ + tmp.qcvt = (q); \ + tmp.val[_QUAD_HIGHWORD] = (h); \ + (q) = tmp.qcvt; \ +} +#define SETLOW(q, l) { \ + union _qcvt tmp; \ + tmp.qcvt = (q); \ + tmp.val[_QUAD_LOWWORD] = (l); \ + (q) = tmp.qcvt; \ +} /* * Create a regular file */ int -ufs_create(ndp, vap, p) - struct nameidata *ndp; - struct vattr *vap; - struct proc *p; +ufs_create(ap) + struct vop_create_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; { - struct vnode *vp; int error; if (error = - ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &vp)) + ufs_makeinode(MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode), + ap->a_dvp, ap->a_vpp, ap->a_cnp)) return (error); - ndp->ni_vp = vp; return (0); } @@ -65,20 +106,24 @@ ufs_create(ndp, vap, p) */ /* ARGSUSED */ int -ufs_mknod(ndp, vap, cred, p) - struct nameidata *ndp; - struct vattr *vap; - struct ucred *cred; - struct proc *p; +ufs_mknod(ap) + struct vop_mknod_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; { + register struct vattr *vap = ap->a_vap; + register struct vnode **vpp = ap->a_vpp; register struct inode *ip; - struct vnode *vp; int error; if (error = - ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &vp)) + ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), + ap->a_dvp, vpp, ap->a_cnp)) return (error); - ip = VTOI(vp); + ip = VTOI(*vpp); ip->i_flag |= IACC|IUPD|ICHG; if (vap->va_rdev != VNOVAL) { /* @@ -92,9 +137,10 @@ ufs_mknod(ndp, vap, cred, p) * checked to see if it is an alias of an existing entry * in the inode cache. */ - vput(vp); - vp->v_type = VNON; - vgone(vp); + vput(*vpp); + (*vpp)->v_type = VNON; + vgone(*vpp); + *vpp = 0; return (0); } @@ -105,13 +151,21 @@ ufs_mknod(ndp, vap, cred, p) */ /* ARGSUSED */ int -ufs_open(vp, mode, cred, p) - struct vnode *vp; - int mode; - struct ucred *cred; - struct proc *p; +ufs_open(ap) + struct vop_open_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { + /* + * Files marked append-only must be opened for appending. + */ + if ((VTOI(ap->a_vp)->i_flags & APPEND) && + (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE) + return (EPERM); return (0); } @@ -122,15 +176,17 @@ ufs_open(vp, mode, cred, p) */ /* ARGSUSED */ int -ufs_close(vp, fflag, cred, p) - struct vnode *vp; - int fflag; - struct ucred *cred; - struct proc *p; +ufs_close(ap) + struct vop_close_args /* { + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { - register struct inode *ip; + register struct vnode *vp = ap->a_vp; + register struct inode *ip = VTOI(vp); - ip = VTOI(vp); if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) ITIMES(ip, &time, &time); return (0); @@ -142,13 +198,18 @@ ufs_close(vp, fflag, cred, p) * super user is granted all permissions. */ int -ufs_access(vp, mode, cred, p) - struct vnode *vp; - register int mode; - struct ucred *cred; - struct proc *p; +ufs_access(ap) + struct vop_access_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { + register struct vnode *vp = ap->a_vp; register struct inode *ip = VTOI(vp); + register struct ucred *cred = ap->a_cred; + mode_t mode = ap->a_mode; register gid_t *gp; int i, error; @@ -167,6 +228,8 @@ ufs_access(vp, mode, cred, p) } } #endif /* QUOTA */ + if ((mode & VWRITE) && (ip->i_flags & IMMUTABLE)) + return (EPERM); /* * If you're the super-user, you always get access. */ @@ -187,22 +250,23 @@ ufs_access(vp, mode, cred, p) found: ; } - if ((ip->i_mode & mode) != 0) - return (0); - return (EACCES); + return ((ip->i_mode & mode) == mode ? 0 : EACCES); } /* ARGSUSED */ int -ufs_getattr(vp, vap, cred, p) - struct vnode *vp; - register struct vattr *vap; - struct ucred *cred; - struct proc *p; +ufs_getattr(ap) + struct vop_getattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { - register struct inode *ip; + register struct vnode *vp = ap->a_vp; + register struct inode *ip = VTOI(vp); + register struct vattr *vap = ap->a_vap; - ip = VTOI(vp); ITIMES(ip, &time, &time); /* * Copy from inode table @@ -214,18 +278,10 @@ ufs_getattr(vp, vap, cred, p) vap->va_uid = ip->i_uid; vap->va_gid = ip->i_gid; vap->va_rdev = (dev_t)ip->i_rdev; -#ifdef tahoe - vap->va_size = ip->i_size; - vap->va_size_rsv = 0; -#else - vap->va_qsize = ip->i_din.di_qsize; -#endif - vap->va_atime.tv_sec = ip->i_atime; - vap->va_atime.tv_usec = 0; - vap->va_mtime.tv_sec = ip->i_mtime; - vap->va_mtime.tv_usec = 0; - vap->va_ctime.tv_sec = ip->i_ctime; - vap->va_ctime.tv_usec = 0; + vap->va_size = ip->i_din.di_size; + vap->va_atime = ip->i_atime; + vap->va_mtime = ip->i_mtime; + vap->va_ctime = ip->i_ctime; vap->va_flags = ip->i_flags; vap->va_gen = ip->i_gen; /* this doesn't belong here */ @@ -236,8 +292,8 @@ ufs_getattr(vp, vap, cred, p) else vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; vap->va_bytes = dbtob(ip->i_blocks); - vap->va_bytes_rsv = 0; vap->va_type = vp->v_type; + vap->va_filerev = ip->i_modrev; return (0); } @@ -245,13 +301,20 @@ ufs_getattr(vp, vap, cred, p) * Set attribute vnode op. called from several syscalls */ int -ufs_setattr(vp, vap, cred, p) - register struct vnode *vp; - register struct vattr *vap; - register struct ucred *cred; - struct proc *p; +ufs_setattr(ap) + struct vop_setattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { - register struct inode *ip; + register struct vattr *vap = ap->a_vap; + register struct vnode *vp = ap->a_vp; + register struct inode *ip = VTOI(vp); + register struct ucred *cred = ap->a_cred; + register struct proc *p = ap->a_p; + struct timeval atimeval, mtimeval; int error; /* @@ -263,46 +326,60 @@ ufs_setattr(vp, vap, cred, p) ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { return (EINVAL); } + if (vap->va_flags != VNOVAL) { + if (cred->cr_uid != ip->i_uid && + (error = suser(cred, &p->p_acflag))) + return (error); + if (cred->cr_uid == 0) { + if ((ip->i_flags & (SF_IMMUTABLE | SF_APPEND)) && + securelevel > 0) + return (EPERM); + ip->i_flags = vap->va_flags; + } else { + if (ip->i_flags & (SF_IMMUTABLE | SF_APPEND)) + return (EPERM); + ip->i_flags &= SF_SETTABLE; + ip->i_flags |= (vap->va_flags & UF_SETTABLE); + } + ip->i_flag |= ICHG; + if (vap->va_flags & (IMMUTABLE | APPEND)) + return (0); + } + if (ip->i_flags & (IMMUTABLE | APPEND)) + return (EPERM); /* * Go through the fields and update iff not VNOVAL. */ - if (vap->va_uid != (u_short)VNOVAL || vap->va_gid != (u_short)VNOVAL) - if (error = ufs_chown(vp, vap->va_uid, vap->va_gid, p)) + if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) + if (error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, p)) return (error); if (vap->va_size != VNOVAL) { if (vp->v_type == VDIR) return (EISDIR); - if (error = VOP_TRUNCATE(vp, vap->va_size, 0)) /* IO_SYNC? */ + if (error = VOP_TRUNCATE(vp, vap->va_size, 0, cred, p)) return (error); } ip = VTOI(vp); - if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { + if (vap->va_atime.ts_sec != VNOVAL || vap->va_mtime.ts_sec != VNOVAL) { if (cred->cr_uid != ip->i_uid && - (error = suser(cred, &p->p_acflag))) + (error = suser(cred, &p->p_acflag)) && + ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || + (error = VOP_ACCESS(vp, VWRITE, cred, p)))) return (error); - if (vap->va_atime.tv_sec != VNOVAL) + if (vap->va_atime.ts_sec != VNOVAL) ip->i_flag |= IACC; - if (vap->va_mtime.tv_sec != VNOVAL) - ip->i_flag |= IUPD; - ip->i_flag |= ICHG; - if (error = VOP_UPDATE(vp, &vap->va_atime, &vap->va_mtime, 1)) + if (vap->va_mtime.ts_sec != VNOVAL) + ip->i_flag |= IUPD | ICHG; + atimeval.tv_sec = vap->va_atime.ts_sec; + atimeval.tv_usec = vap->va_atime.ts_nsec / 1000; + mtimeval.tv_sec = vap->va_mtime.ts_sec; + mtimeval.tv_usec = vap->va_mtime.ts_nsec / 1000; + if (error = VOP_UPDATE(vp, &atimeval, &mtimeval, 1)) return (error); } error = 0; - if (vap->va_mode != (u_short)VNOVAL) - error = ufs_chmod(vp, (int)vap->va_mode, p); - if (vap->va_flags != VNOVAL) { - if (cred->cr_uid != ip->i_uid && - (error = suser(cred, &p->p_acflag))) - return (error); - if (cred->cr_uid == 0) { - ip->i_flags = vap->va_flags; - } else { - ip->i_flags &= 0xffff0000; - ip->i_flags |= (vap->va_flags & 0xffff); - } - ip->i_flag |= ICHG; - } + if (vap->va_mode != (mode_t)VNOVAL) + error = ufs_chmod(vp, (int)vap->va_mode, cred, p); return (error); } @@ -311,12 +388,12 @@ ufs_setattr(vp, vap, cred, p) * Inode must be locked before calling. */ static int -ufs_chmod(vp, mode, p) +ufs_chmod(vp, mode, cred, p) register struct vnode *vp; register int mode; + register struct ucred *cred; struct proc *p; { - register struct ucred *cred = p->p_ucred; register struct inode *ip = VTOI(vp); int error; @@ -342,14 +419,14 @@ ufs_chmod(vp, mode, p) * inode must be locked prior to call. */ static int -ufs_chown(vp, uid, gid, p) +ufs_chown(vp, uid, gid, cred, p) register struct vnode *vp; - u_int uid; - u_int gid; + uid_t uid; + gid_t gid; + struct ucred *cred; struct proc *p; { register struct inode *ip = VTOI(vp); - register struct ucred *cred = p->p_ucred; uid_t ouid; gid_t ogid; int error = 0; @@ -358,9 +435,9 @@ ufs_chown(vp, uid, gid, p) long change; #endif - if (uid == (u_short)VNOVAL) + if (uid == (uid_t)VNOVAL) uid = ip->i_uid; - if (gid == (u_short)VNOVAL) + if (gid == (gid_t)VNOVAL) gid = ip->i_gid; /* * If we don't own the file, are trying to change the owner @@ -446,13 +523,15 @@ good: /* ARGSUSED */ int -ufs_ioctl(vp, com, data, fflag, cred, p) - struct vnode *vp; - int com; - caddr_t data; - int fflag; - struct ucred *cred; - struct proc *p; +ufs_ioctl(ap) + struct vop_ioctl_args /* { + struct vnode *a_vp; + int a_command; + caddr_t a_data; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { return (ENOTTY); @@ -460,11 +539,14 @@ ufs_ioctl(vp, com, data, fflag, cred, p) /* ARGSUSED */ int -ufs_select(vp, which, fflags, cred, p) - struct vnode *vp; - int which, fflags; - struct ucred *cred; - struct proc *p; +ufs_select(ap) + struct vop_select_args /* { + struct vnode *a_vp; + int a_which; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { /* @@ -480,11 +562,13 @@ ufs_select(vp, which, fflags, cred, p) */ /* ARGSUSED */ int -ufs_mmap(vp, fflags, cred, p) - struct vnode *vp; - int fflags; - struct ucred *cred; - struct proc *p; +ufs_mmap(ap) + struct vop_mmap_args /* { + struct vnode *a_vp; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { return (EINVAL); @@ -497,10 +581,13 @@ ufs_mmap(vp, fflags, cred, p) */ /* ARGSUSED */ int -ufs_seek(vp, oldoff, newoff, cred) - struct vnode *vp; - off_t oldoff, newoff; - struct ucred *cred; +ufs_seek(ap) + struct vop_seek_args /* { + struct vnode *a_vp; + off_t a_oldoff; + off_t a_newoff; + struct ucred *a_cred; + } */ *ap; { return (0); @@ -512,25 +599,34 @@ ufs_seek(vp, oldoff, newoff, cred) * in unlinking directories. */ int -ufs_remove(ndp, p) - struct nameidata *ndp; - struct proc *p; +ufs_remove(ap) + struct vop_remove_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; { - register struct inode *ip, *dp; + register struct inode *ip; + register struct vnode *vp = ap->a_vp; + register struct vnode *dvp = ap->a_dvp; int error; - ip = VTOI(ndp->ni_vp); - dp = VTOI(ndp->ni_dvp); - error = ufs_dirremove(ndp); - if (!error) { + ip = VTOI(vp); + if ((ip->i_flags & (IMMUTABLE | APPEND)) || + (VTOI(dvp)->i_flags & APPEND)) { + error = EPERM; + goto out; + } + if ((error = ufs_dirremove(dvp, ap->a_cnp)) == 0) { ip->i_nlink--; ip->i_flag |= ICHG; } - if (dp == ip) - vrele(ITOV(ip)); +out: + if (dvp == vp) + vrele(vp); else - ufs_iput(ip); - ufs_iput(dp); + vput(vp); + vput(dvp); return (error); } @@ -538,41 +634,219 @@ ufs_remove(ndp, p) * link vnode call */ int -ufs_link(vp, ndp, p) - register struct vnode *vp; - register struct nameidata *ndp; - struct proc *p; +ufs_link(ap) + struct vop_link_args /* { + struct vnode *a_vp; + struct vnode *a_tdvp; + struct componentname *a_cnp; + } */ *ap; { + register struct vnode *vp = ap->a_vp; + register struct vnode *tdvp = ap->a_tdvp; + register struct componentname *cnp = ap->a_cnp; register struct inode *ip; + struct timeval tv; int error; -#ifdef DIANOSTIC - if ((ndp->ni_nameiop & HASBUF) == 0) +#ifdef DIAGNOSTIC + if ((cnp->cn_flags & HASBUF) == 0) panic("ufs_link: no name"); #endif - ip = VTOI(vp); - if ((unsigned short)ip->i_nlink >= LINK_MAX) { - free(ndp->ni_pnbuf, M_NAMEI); - return (EMLINK); + if (vp->v_mount != tdvp->v_mount) { + VOP_ABORTOP(vp, cnp); + error = EXDEV; + goto out2; + } + if (vp != tdvp && (error = VOP_LOCK(tdvp))) { + VOP_ABORTOP(vp, cnp); + goto out2; + } + ip = VTOI(tdvp); + if ((nlink_t)ip->i_nlink >= LINK_MAX) { + VOP_ABORTOP(vp, cnp); + error = EMLINK; + goto out1; + } + if (ip->i_flags & (IMMUTABLE | APPEND)) { + VOP_ABORTOP(vp, cnp); + error = EPERM; + goto out1; } - if (ndp->ni_dvp != vp) - ILOCK(ip); ip->i_nlink++; ip->i_flag |= ICHG; - error = VOP_UPDATE(vp, &time, &time, 1); + tv = time; + error = VOP_UPDATE(tdvp, &tv, &tv, 1); if (!error) - error = ufs_direnter(ip, ndp); - if (ndp->ni_dvp != vp) - IUNLOCK(ip); - FREE(ndp->ni_pnbuf, M_NAMEI); - vput(ndp->ni_dvp); + error = ufs_direnter(ip, vp, cnp); if (error) { ip->i_nlink--; ip->i_flag |= ICHG; } + FREE(cnp->cn_pnbuf, M_NAMEI); +out1: + if (vp != tdvp) + VOP_UNLOCK(tdvp); +out2: + vput(vp); + return (error); +} + + + +/* + * relookup - lookup a path name component + * Used by lookup to re-aquire things. + */ +int +relookup(dvp, vpp, cnp) + struct vnode *dvp, **vpp; + struct componentname *cnp; +{ + register struct vnode *dp = 0; /* the directory we are searching */ + struct vnode *tdp; /* saved dp */ + struct mount *mp; /* mount table entry */ + int docache; /* == 0 do not cache last component */ + int wantparent; /* 1 => wantparent or lockparent flag */ + int rdonly; /* lookup read-only flag bit */ + char *cp; /* DEBUG: check name ptr/len */ + int newhash; /* DEBUG: check name hash */ + int error = 0; + + /* + * Setup: break out flag bits into variables. + */ + wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT); + docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE; + if (cnp->cn_nameiop == DELETE || + (wantparent && cnp->cn_nameiop != CREATE)) + docache = 0; + rdonly = cnp->cn_flags & RDONLY; + cnp->cn_flags &= ~ISSYMLINK; + dp = dvp; + VOP_LOCK(dp); + +/* dirloop: */ + /* + * Search a new directory. + * + * The cn_hash value is for use by vfs_cache. + * The last component of the filename is left accessible via + * cnp->cn_nameptr for callers that need the name. Callers needing + * the name set the SAVENAME flag. When done, they assume + * responsibility for freeing the pathname buffer. + */ +#ifdef NAMEI_DIAGNOSTIC + for (newhash = 0, cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++) + newhash += (unsigned char)*cp; + if (newhash != cnp->cn_hash) + panic("relookup: bad hash"); + if (cnp->cn_namelen != cp - cnp->cn_nameptr) + panic ("relookup: bad len"); + if (*cp != 0) + panic("relookup: not last component"); + printf("{%s}: ", cnp->cn_nameptr); +#endif + + /* + * Check for degenerate name (e.g. / or "") + * which is a way of talking about a directory, + * e.g. like "/." or ".". + */ + if (cnp->cn_nameptr[0] == '\0') { + if (cnp->cn_nameiop != LOOKUP || wantparent) { + error = EISDIR; + goto bad; + } + if (dp->v_type != VDIR) { + error = ENOTDIR; + goto bad; + } + if (!(cnp->cn_flags & LOCKLEAF)) + VOP_UNLOCK(dp); + *vpp = dp; + if (cnp->cn_flags & SAVESTART) + panic("lookup: SAVESTART"); + return (0); + } + + if (cnp->cn_flags & ISDOTDOT) + panic ("relookup: lookup on dot-dot"); + + /* + * We now have a segment name to search for, and a directory to search. + */ + if (error = VOP_LOOKUP(dp, vpp, cnp)) { +#ifdef DIAGNOSTIC + if (*vpp != NULL) + panic("leaf should be empty"); +#endif + if (error != EJUSTRETURN) + goto bad; + /* + * If creating and at end of pathname, then can consider + * allowing file to be created. + */ + if (rdonly || (dvp->v_mount->mnt_flag & MNT_RDONLY)) { + error = EROFS; + goto bad; + } + /* ASSERT(dvp == ndp->ni_startdir) */ + if (cnp->cn_flags & SAVESTART) + VREF(dvp); + /* + * We return with ni_vp NULL to indicate that the entry + * doesn't currently exist, leaving a pointer to the + * (possibly locked) directory inode in ndp->ni_dvp. + */ + return (0); + } + dp = *vpp; + +#ifdef DIAGNOSTIC + /* + * Check for symbolic link + */ + if (dp->v_type == VLNK && (cnp->cn_flags & FOLLOW)) + panic ("relookup: symlink found.\n"); +#endif + +nextname: + /* + * Check for read-only file systems. + */ + if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) { + /* + * Disallow directory write attempts on read-only + * file systems. + */ + if (rdonly || (dp->v_mount->mnt_flag & MNT_RDONLY) || + (wantparent && + (dvp->v_mount->mnt_flag & MNT_RDONLY))) { + error = EROFS; + goto bad2; + } + } + /* ASSERT(dvp == ndp->ni_startdir) */ + if (cnp->cn_flags & SAVESTART) + VREF(dvp); + + if (!wantparent) + vrele(dvp); + if ((cnp->cn_flags & LOCKLEAF) == 0) + VOP_UNLOCK(dp); + return (0); + +bad2: + if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN)) + VOP_UNLOCK(dvp); + vrele(dvp); +bad: + vput(dp); + *vpp = NULL; return (error); } + /* * Rename system call. * rename("foo", "bar"); @@ -598,59 +872,115 @@ ufs_link(vp, ndp, p) * directory. */ int -ufs_rename(fndp, tndp, p) - register struct nameidata *fndp, *tndp; - struct proc *p; +ufs_rename(ap) + struct vop_rename_args /* { + struct vnode *a_fdvp; + struct vnode *a_fvp; + struct componentname *a_fcnp; + struct vnode *a_tdvp; + struct vnode *a_tvp; + struct componentname *a_tcnp; + } */ *ap; { + struct vnode *tvp = ap->a_tvp; + register struct vnode *tdvp = ap->a_tdvp; + struct vnode *fvp = ap->a_fvp; + register struct vnode *fdvp = ap->a_fdvp; + register struct componentname *tcnp = ap->a_tcnp; + register struct componentname *fcnp = ap->a_fcnp; register struct inode *ip, *xp, *dp; struct dirtemplate dirbuf; + struct timeval tv; int doingdirectory = 0, oldparent = 0, newparent = 0; int error = 0; + int fdvpneedsrele = 1, tdvpneedsrele = 1; + u_char namlen; -#ifdef DIANOSTIC - if ((tndp->ni_nameiop & HASBUF) == 0 || - (fndp->ni_nameiop & HASBUF) == 0) +#ifdef DIAGNOSTIC + if ((tcnp->cn_flags & HASBUF) == 0 || + (fcnp->cn_flags & HASBUF) == 0) panic("ufs_rename: no name"); #endif - dp = VTOI(fndp->ni_dvp); - ip = VTOI(fndp->ni_vp); + /* + * Check for cross-device rename. + */ + if ((fvp->v_mount != tdvp->v_mount) || + (tvp && (fvp->v_mount != tvp->v_mount))) { + error = EXDEV; +abortit: + VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */ + if (tdvp == tvp) + vrele(tdvp); + else + vput(tdvp); + if (tvp) + vput(tvp); + VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */ + vrele(fdvp); + vrele(fvp); + return (error); + } + /* * Check if just deleting a link name. */ - if (fndp->ni_vp == tndp->ni_vp) { - VOP_ABORTOP(tndp); - vput(tndp->ni_dvp); - vput(tndp->ni_vp); - vrele(fndp->ni_dvp); - if ((ip->i_mode&IFMT) == IFDIR) { - VOP_ABORTOP(fndp); - vrele(fndp->ni_vp); - return (EINVAL); + if (tvp && ((VTOI(tvp)->i_flags & (IMMUTABLE | APPEND)) || + (VTOI(tdvp)->i_flags & APPEND))) { + error = EPERM; + goto abortit; + } + if (fvp == tvp) { + if (fvp->v_type == VDIR) { + error = EINVAL; + goto abortit; } - doingdirectory = 0; - goto unlinkit; + VOP_ABORTOP(fdvp, fcnp); + vrele(fdvp); + vrele(fvp); + vput(tdvp); + vput(tvp); + tcnp->cn_flags &= ~MODMASK; + tcnp->cn_flags |= LOCKPARENT | LOCKLEAF; + if ((tcnp->cn_flags & SAVESTART) == 0) + panic("ufs_rename: lost from startdir"); + tcnp->cn_nameiop = DELETE; + (void) relookup(tdvp, &tvp, tcnp); + return (VOP_REMOVE(tdvp, tvp, tcnp)); + } + if (error = VOP_LOCK(fvp)) + goto abortit; + dp = VTOI(fdvp); + ip = VTOI(fvp); + if ((ip->i_flags & (IMMUTABLE | APPEND)) || (dp->i_flags & APPEND)) { + VOP_UNLOCK(fvp); + error = EPERM; + goto abortit; } - ILOCK(ip); - if ((ip->i_mode&IFMT) == IFDIR) { + if ((ip->i_mode & IFMT) == IFDIR) { /* * Avoid ".", "..", and aliases of "." for obvious reasons. */ - if ((fndp->ni_namelen == 1 && fndp->ni_ptr[0] == '.') || - dp == ip || fndp->ni_isdotdot || (ip->i_flag & IRENAME)) { - VOP_ABORTOP(tndp); - vput(tndp->ni_dvp); - if (tndp->ni_vp) - vput(tndp->ni_vp); - VOP_ABORTOP(fndp); - vrele(fndp->ni_dvp); - vput(fndp->ni_vp); - return (EINVAL); + if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || + dp == ip || (fcnp->cn_flags&ISDOTDOT) || + (ip->i_flag & IRENAME)) { + VOP_UNLOCK(fvp); + error = EINVAL; + goto abortit; } ip->i_flag |= IRENAME; oldparent = dp->i_number; doingdirectory++; } - vrele(fndp->ni_dvp); + vrele(fdvp); + + /* + * When the target exists, both the directory + * and target vnodes are returned locked. + */ + dp = VTOI(tdvp); + xp = NULL; + if (tvp) + xp = VTOI(tvp); /* * 1) Bump link count while we're moving stuff @@ -660,17 +990,12 @@ ufs_rename(fndp, tndp, p) */ ip->i_nlink++; ip->i_flag |= ICHG; - error = VOP_UPDATE(fndp->ni_vp, &time, &time, 1); - IUNLOCK(ip); + tv = time; + if (error = VOP_UPDATE(fvp, &tv, &tv, 1)) { + VOP_UNLOCK(fvp); + goto bad; + } - /* - * When the target exists, both the directory - * and target vnodes are returned locked. - */ - dp = VTOI(tndp->ni_dvp); - xp = NULL; - if (tndp->ni_vp) - xp = VTOI(tndp->ni_vp); /* * If ".." must be changed (ie the directory gets a new * parent) then the source directory must not be in the @@ -681,27 +1006,25 @@ ufs_rename(fndp, tndp, p) * to namei, as the parent directory is unlocked by the * call to checkpath(). */ + error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc); + VOP_UNLOCK(fvp); if (oldparent != dp->i_number) newparent = dp->i_number; if (doingdirectory && newparent) { - VOP_LOCK(fndp->ni_vp); - error = ufs_access(fndp->ni_vp, VWRITE, tndp->ni_cred, p); - VOP_UNLOCK(fndp->ni_vp); - if (error) + if (error) /* write access check above */ goto bad; if (xp != NULL) - ufs_iput(xp); - if (error = ufs_checkpath(ip, dp, tndp->ni_cred)) + vput(tvp); + if (error = ufs_checkpath(ip, dp, tcnp->cn_cred)) goto out; - if ((tndp->ni_nameiop & SAVESTART) == 0) + if ((tcnp->cn_flags & SAVESTART) == 0) panic("ufs_rename: lost to startdir"); - p->p_spare[1]--; - if (error = lookup(tndp, p)) + if (error = relookup(tdvp, &tvp, tcnp)) goto out; - dp = VTOI(tndp->ni_dvp); + dp = VTOI(tdvp); xp = NULL; - if (tndp->ni_vp) - xp = VTOI(tndp->ni_vp); + if (tvp) + xp = VTOI(tvp); } /* * 2) If target doesn't exist, link the target @@ -719,24 +1042,24 @@ ufs_rename(fndp, tndp, p) * parent we don't fool with the link count. */ if (doingdirectory && newparent) { - if ((unsigned short)dp->i_nlink >= LINK_MAX) { + if ((nlink_t)dp->i_nlink >= LINK_MAX) { error = EMLINK; goto bad; } dp->i_nlink++; dp->i_flag |= ICHG; - if (error = VOP_UPDATE(ITOV(dp), &time, &time, 1)) + if (error = VOP_UPDATE(tdvp, &tv, &tv, 1)) goto bad; } - if (error = ufs_direnter(ip, tndp)) { + if (error = ufs_direnter(ip, tdvp, tcnp)) { if (doingdirectory && newparent) { dp->i_nlink--; dp->i_flag |= ICHG; - (void)VOP_UPDATE(ITOV(dp), &time, &time, 1); + (void)VOP_UPDATE(tdvp, &tv, &tv, 1); } goto bad; } - ufs_iput(dp); + vput(tdvp); } else { if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) panic("rename: EXDEV"); @@ -751,9 +1074,9 @@ ufs_rename(fndp, tndp, p) * otherwise the destination may not be changed (except by * root). This implements append-only directories. */ - if ((dp->i_mode & ISVTX) && tndp->ni_cred->cr_uid != 0 && - tndp->ni_cred->cr_uid != dp->i_uid && - xp->i_uid != tndp->ni_cred->cr_uid) { + if ((dp->i_mode & ISVTX) && tcnp->cn_cred->cr_uid != 0 && + tcnp->cn_cred->cr_uid != dp->i_uid && + xp->i_uid != tcnp->cn_cred->cr_uid) { error = EPERM; goto bad; } @@ -763,7 +1086,7 @@ ufs_rename(fndp, tndp, p) * (both directories, or both not directories). */ if ((xp->i_mode&IFMT) == IFDIR) { - if (!ufs_dirempty(xp, dp->i_number, tndp->ni_cred) || + if (!ufs_dirempty(xp, dp->i_number, tcnp->cn_cred) || xp->i_nlink > 2) { error = ENOTEMPTY; goto bad; @@ -772,12 +1095,12 @@ ufs_rename(fndp, tndp, p) error = ENOTDIR; goto bad; } - cache_purge(ITOV(dp)); + cache_purge(tdvp); } else if (doingdirectory) { error = EISDIR; goto bad; } - if (error = ufs_dirrewrite(dp, ip, tndp)) + if (error = ufs_dirrewrite(dp, ip, tcnp)) goto bad; /* * If the target directory is in the same @@ -789,7 +1112,7 @@ ufs_rename(fndp, tndp, p) dp->i_nlink--; dp->i_flag |= ICHG; } - ufs_iput(dp); + vput(tdvp); /* * Adjust the link count of the target to * reflect the dirrewrite above. If this is @@ -804,33 +1127,32 @@ ufs_rename(fndp, tndp, p) if (doingdirectory) { if (--xp->i_nlink != 0) panic("rename: linked directory"); - error = VOP_TRUNCATE(ITOV(xp), (u_long)0, IO_SYNC); + error = VOP_TRUNCATE(tvp, (off_t)0, IO_SYNC, + tcnp->cn_cred, tcnp->cn_proc); } xp->i_flag |= ICHG; - ufs_iput(xp); + vput(tvp); xp = NULL; } /* * 3) Unlink the source. */ -unlinkit: - fndp->ni_nameiop &= ~MODMASK; - fndp->ni_nameiop |= LOCKPARENT | LOCKLEAF; - if ((fndp->ni_nameiop & SAVESTART) == 0) + fcnp->cn_flags &= ~MODMASK; + fcnp->cn_flags |= LOCKPARENT | LOCKLEAF; + if ((fcnp->cn_flags & SAVESTART) == 0) panic("ufs_rename: lost from startdir"); - p->p_spare[1]--; - (void) lookup(fndp, p); - if (fndp->ni_vp != NULL) { - xp = VTOI(fndp->ni_vp); - dp = VTOI(fndp->ni_dvp); + (void) relookup(fdvp, &fvp, fcnp); + if (fvp != NULL) { + xp = VTOI(fvp); + dp = VTOI(fdvp); } else { /* * From name has disappeared. */ if (doingdirectory) panic("rename: lost dir entry"); - vrele(ITOV(ip)); + vrele(ap->a_fvp); return (0); } /* @@ -856,30 +1178,38 @@ unlinkit: if (doingdirectory && newparent) { dp->i_nlink--; dp->i_flag |= ICHG; - error = vn_rdwr(UIO_READ, ITOV(xp), (caddr_t)&dirbuf, + error = vn_rdwr(UIO_READ, fvp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, IO_NODELOCKED, - tndp->ni_cred, (int *)0, (struct proc *)0); + tcnp->cn_cred, (int *)0, (struct proc *)0); if (error == 0) { - if (dirbuf.dotdot_namlen != 2 || +# if (BYTE_ORDER == LITTLE_ENDIAN) + if (fvp->v_mount->mnt_maxsymlinklen <= 0) + namlen = dirbuf.dotdot_type; + else + namlen = dirbuf.dotdot_namlen; +# else + namlen = dirbuf.dotdot_namlen; +# endif + if (namlen != 2 || dirbuf.dotdot_name[0] != '.' || dirbuf.dotdot_name[1] != '.') { - ufs_dirbad(xp, 12, + ufs_dirbad(xp, (doff_t)12, "rename: mangled dir"); } else { dirbuf.dotdot_ino = newparent; - (void) vn_rdwr(UIO_WRITE, ITOV(xp), + (void) vn_rdwr(UIO_WRITE, fvp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_SYNC, - tndp->ni_cred, (int *)0, + tcnp->cn_cred, (int *)0, (struct proc *)0); - cache_purge(ITOV(dp)); + cache_purge(fdvp); } } } - error = ufs_dirremove(fndp); + error = ufs_dirremove(fdvp, fcnp); if (!error) { xp->i_nlink--; xp->i_flag |= ICHG; @@ -887,10 +1217,10 @@ unlinkit: xp->i_flag &= ~IRENAME; } if (dp) - vput(ITOV(dp)); + vput(fdvp); if (xp) - vput(ITOV(xp)); - vrele(ITOV(ip)); + vput(fvp); + vrele(ap->a_fvp); return (error); bad: @@ -898,9 +1228,12 @@ bad: vput(ITOV(xp)); vput(ITOV(dp)); out: - ip->i_nlink--; - ip->i_flag |= ICHG; - vrele(ITOV(ip)); + if (VOP_LOCK(fvp) == 0) { + ip->i_nlink--; + ip->i_flag |= ICHG; + vput(fvp); + } else + vrele(fvp); return (error); } @@ -908,6 +1241,10 @@ out: * A virgin directory (no blushing please). */ static struct dirtemplate mastertemplate = { + 0, 12, DT_DIR, 1, ".", + 0, DIRBLKSIZ - 12, DT_DIR, 2, ".." +}; +static struct odirtemplate omastertemplate = { 0, 12, 1, ".", 0, DIRBLKSIZ - 12, 2, ".." }; @@ -916,59 +1253,60 @@ static struct dirtemplate mastertemplate = { * Mkdir system call */ int -ufs_mkdir(ndp, vap, p) - struct nameidata *ndp; - struct vattr *vap; - struct proc *p; +ufs_mkdir(ap) + struct vop_mkdir_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; { + register struct vnode *dvp = ap->a_dvp; + register struct vattr *vap = ap->a_vap; + register struct componentname *cnp = ap->a_cnp; register struct inode *ip, *dp; struct vnode *tvp; - struct vnode *dvp; - struct dirtemplate dirtemplate; - int error; - int dmode; + struct dirtemplate dirtemplate, *dtp; + struct timeval tv; + int error, dmode; -#ifdef DIANOSTIC - if ((ndp->ni_nameiop & HASBUF) == 0) +#ifdef DIAGNOSTIC + if ((cnp->cn_flags & HASBUF) == 0) panic("ufs_mkdir: no name"); #endif - dvp = ndp->ni_dvp; dp = VTOI(dvp); - if ((unsigned short)dp->i_nlink >= LINK_MAX) { - free(ndp->ni_pnbuf, M_NAMEI); - ufs_iput(dp); - return (EMLINK); + if ((nlink_t)dp->i_nlink >= LINK_MAX) { + error = EMLINK; + goto out; } - dmode = vap->va_mode&0777; + dmode = vap->va_mode & 0777; dmode |= IFDIR; /* - * Must simulate part of maknode here to acquire the inode, but - * not have it entered in the parent directory. The entry is made - * later after writing "." and ".." entries. + * Must simulate part of ufs_makeinode here to acquire the inode, + * but not have it entered in the parent directory. The entry is + * made later after writing "." and ".." entries. */ - if (error = VOP_VALLOC(dvp, dmode, ndp->ni_cred, &tvp)) { - free(ndp->ni_pnbuf, M_NAMEI); - ufs_iput(dp); - return (error); - } + if (error = VOP_VALLOC(dvp, dmode, cnp->cn_cred, &tvp)) + goto out; ip = VTOI(tvp); - ip->i_uid = ndp->ni_cred->cr_uid; + ip->i_uid = cnp->cn_cred->cr_uid; ip->i_gid = dp->i_gid; #ifdef QUOTA if ((error = getinoquota(ip)) || - (error = chkiq(ip, 1, ndp->ni_cred, 0))) { - free(ndp->ni_pnbuf, M_NAMEI); + (error = chkiq(ip, 1, cnp->cn_cred, 0))) { + free(cnp->cn_pnbuf, M_NAMEI); VOP_VFREE(tvp, ip->i_number, dmode); - ufs_iput(ip); - ufs_iput(dp); + vput(tvp); + vput(dvp); return (error); } #endif ip->i_flag |= IACC|IUPD|ICHG; ip->i_mode = dmode; - ITOV(ip)->v_type = VDIR; /* Rest init'd in iget() */ + tvp->v_type = VDIR; /* Rest init'd in iget() */ ip->i_nlink = 2; - error = VOP_UPDATE(ITOV(ip), &time, &time, 1); + tv = time; + error = VOP_UPDATE(tvp, &tv, &tv, 1); /* * Bump link count in parent directory @@ -978,16 +1316,20 @@ ufs_mkdir(ndp, vap, p) */ dp->i_nlink++; dp->i_flag |= ICHG; - if (error = VOP_UPDATE(ITOV(dp), &time, &time, 1)) + if (error = VOP_UPDATE(dvp, &tv, &tv, 1)) goto bad; /* Initialize directory with "." and ".." from static template. */ - dirtemplate = mastertemplate; + if (dvp->v_mount->mnt_maxsymlinklen > 0) + dtp = &mastertemplate; + else + dtp = (struct dirtemplate *)&omastertemplate; + dirtemplate = *dtp; dirtemplate.dot_ino = ip->i_number; dirtemplate.dotdot_ino = dp->i_number; - error = vn_rdwr(UIO_WRITE, ITOV(ip), (caddr_t)&dirtemplate, + error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)&dirtemplate, sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE, - IO_NODELOCKED|IO_SYNC, ndp->ni_cred, (int *)0, (struct proc *)0); + IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (int *)0, (struct proc *)0); if (error) { dp->i_nlink--; dp->i_flag |= ICHG; @@ -1001,7 +1343,7 @@ ufs_mkdir(ndp, vap, p) } /* Directory set up, now install it's entry in the parent directory. */ - if (error = ufs_direnter(ip, ndp)) { + if (error = ufs_direnter(ip, dvp, cnp)) { dp->i_nlink--; dp->i_flag |= ICHG; } @@ -1013,11 +1355,12 @@ bad: if (error) { ip->i_nlink = 0; ip->i_flag |= ICHG; - ufs_iput(ip); + vput(tvp); } else - ndp->ni_vp = ITOV(ip); - FREE(ndp->ni_pnbuf, M_NAMEI); - ufs_iput(dp); + *ap->a_vpp = tvp; +out: + FREE(cnp->cn_pnbuf, M_NAMEI); + vput(dvp); return (error); } @@ -1025,21 +1368,27 @@ bad: * Rmdir system call. */ int -ufs_rmdir(ndp, p) - register struct nameidata *ndp; - struct proc *p; +ufs_rmdir(ap) + struct vop_rmdir_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; { + register struct vnode *vp = ap->a_vp; + register struct vnode *dvp = ap->a_dvp; + register struct componentname *cnp = ap->a_cnp; register struct inode *ip, *dp; int error; - ip = VTOI(ndp->ni_vp); - dp = VTOI(ndp->ni_dvp); + ip = VTOI(vp); + dp = VTOI(dvp); /* * No rmdir "." please. */ if (dp == ip) { - vrele(ndp->ni_dvp); - ufs_iput(ip); + vrele(dvp); + vput(vp); return (EINVAL); } /* @@ -1051,22 +1400,26 @@ ufs_rmdir(ndp, p) */ error = 0; if (ip->i_nlink != 2 || - !ufs_dirempty(ip, dp->i_number, ndp->ni_cred)) { + !ufs_dirempty(ip, dp->i_number, cnp->cn_cred)) { error = ENOTEMPTY; goto out; } + if ((dp->i_flags & APPEND) || (ip->i_flags & (IMMUTABLE | APPEND))) { + error = EPERM; + goto out; + } /* * Delete reference to directory before purging * inode. If we crash in between, the directory * will be reattached to lost+found, */ - if (error = ufs_dirremove(ndp)) + if (error = ufs_dirremove(dvp, cnp)) goto out; dp->i_nlink--; dp->i_flag |= ICHG; - cache_purge(ndp->ni_dvp); - ufs_iput(dp); - ndp->ni_dvp = NULL; + cache_purge(dvp); + vput(dvp); + dvp = NULL; /* * Truncate inode. The only stuff left * in the directory is "." and "..". The @@ -1079,12 +1432,13 @@ ufs_rmdir(ndp, p) * worry about them later. */ ip->i_nlink -= 2; - error = VOP_TRUNCATE(ndp->ni_vp, (u_long)0, IO_SYNC); + error = VOP_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred, + cnp->cn_proc); cache_purge(ITOV(ip)); out: - if (ndp->ni_dvp) - ufs_iput(dp); - ufs_iput(ip); + if (dvp) + vput(dvp); + vput(vp); return (error); } @@ -1092,34 +1446,55 @@ out: * symlink -- make a symbolic link */ int -ufs_symlink(ndp, vap, target, p) - struct nameidata *ndp; - struct vattr *vap; - char *target; - struct proc *p; +ufs_symlink(ap) + struct vop_symlink_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + char *a_target; + } */ *ap; { - struct vnode *vp; - int error; + register struct vnode *vp, **vpp = ap->a_vpp; + register struct inode *ip; + int len, error; - if (error = ufs_makeinode(IFLNK | vap->va_mode, ndp, &vp)) + if (error = ufs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp, + vpp, ap->a_cnp)) return (error); - error = vn_rdwr(UIO_WRITE, vp, target, strlen(target), (off_t)0, - UIO_SYSSPACE, IO_NODELOCKED, ndp->ni_cred, (int *)0, - (struct proc *)0); + vp = *vpp; + len = strlen(ap->a_target); + if (len < vp->v_mount->mnt_maxsymlinklen) { + ip = VTOI(vp); + bcopy(ap->a_target, (char *)ip->i_shortlink, len); + ip->i_size = len; + ip->i_flag |= IUPD|ICHG; + } else + error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0, + UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, (int *)0, + (struct proc *)0); vput(vp); return (error); } /* - * Vnode op for read and write + * Vnode op for reading directories. + * + * The routine below assumes that the on-disk format of a directory + * is the same as that defined by . If the on-disk + * format changes, then it will be necessary to do a conversion + * from the on-disk format that read returns to the format defined + * by . */ int -ufs_readdir(vp, uio, cred, eofflagp) - struct vnode *vp; - register struct uio *uio; - struct ucred *cred; - int *eofflagp; +ufs_readdir(ap) + struct vop_readdir_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + } */ *ap; { + register struct uio *uio = ap->a_uio; int count, lost, error; count = uio->uio_resid; @@ -1129,12 +1504,49 @@ ufs_readdir(vp, uio, cred, eofflagp) return (EINVAL); uio->uio_resid = count; uio->uio_iov->iov_len = count; - error = VOP_READ(vp, uio, 0, cred); +# if (BYTE_ORDER == LITTLE_ENDIAN) + if (ap->a_vp->v_mount->mnt_maxsymlinklen > 0) { + error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); + } else { + struct dirent *dp, *edp; + struct uio auio; + struct iovec aiov; + caddr_t dirbuf; + int readcnt; + u_char tmp; + + auio = *uio; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_segflg = UIO_SYSSPACE; + aiov.iov_len = count; + MALLOC(dirbuf, caddr_t, count, M_TEMP, M_WAITOK); + aiov.iov_base = dirbuf; + error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred); + if (error == 0) { + readcnt = count - auio.uio_resid; + edp = (struct dirent *)&dirbuf[readcnt]; + for (dp = (struct dirent *)dirbuf; dp < edp; ) { + tmp = dp->d_namlen; + dp->d_namlen = dp->d_type; + dp->d_type = tmp; + if (dp->d_reclen > 0) { + dp = (struct dirent *) + ((char *)dp + dp->d_reclen); + } else { + error = EIO; + break; + } + } + if (dp >= edp) + error = uiomove(dirbuf, readcnt, uio); + } + FREE(dirbuf, M_TEMP); + } +# else + error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); +# endif uio->uio_resid += lost; - if ((VTOI(vp)->i_size - uio->uio_offset) <= 0) - *eofflagp = 1; - else - *eofflagp = 0; return (error); } @@ -1142,13 +1554,23 @@ ufs_readdir(vp, uio, cred, eofflagp) * Return target name of a symbolic link */ int -ufs_readlink(vp, uiop, cred) - struct vnode *vp; - struct uio *uiop; - struct ucred *cred; +ufs_readlink(ap) + struct vop_readlink_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + } */ *ap; { + register struct vnode *vp = ap->a_vp; + register struct inode *ip = VTOI(vp); + int isize; - return (VOP_READ(vp, uiop, 0, cred)); + isize = ip->i_size; + if (isize < vp->v_mount->mnt_maxsymlinklen) { + uiomove((char *)ip->i_shortlink, isize, ap->a_uio); + return (0); + } + return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred)); } /* @@ -1157,40 +1579,95 @@ ufs_readlink(vp, uiop, cred) */ /* ARGSUSED */ int -ufs_abortop(ndp) - struct nameidata *ndp; +ufs_abortop(ap) + struct vop_abortop_args /* { + struct vnode *a_dvp; + struct componentname *a_cnp; + } */ *ap; { - - if ((ndp->ni_nameiop & (HASBUF | SAVESTART)) == HASBUF) - FREE(ndp->ni_pnbuf, M_NAMEI); + if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) + FREE(ap->a_cnp->cn_pnbuf, M_NAMEI); return (0); } /* - * Lock an inode. + * Lock an inode. If its already locked, set the WANT bit and sleep. */ int -ufs_lock(vp) - struct vnode *vp; +ufs_lock(ap) + struct vop_lock_args /* { + struct vnode *a_vp; + } */ *ap; { - register struct inode *ip = VTOI(vp); + register struct vnode *vp = ap->a_vp; + register struct inode *ip; + struct proc *p = curproc; /* XXX */ - ILOCK(ip); +start: + while (vp->v_flag & VXLOCK) { + vp->v_flag |= VXWANT; + sleep((caddr_t)vp, PINOD); + } + if (vp->v_tag == VT_NON) + return (ENOENT); + ip = VTOI(vp); + if (ip->i_flag & ILOCKED) { + ip->i_flag |= IWANT; +#ifdef DIAGNOSTIC + if (p) { + if (p->p_pid == ip->i_lockholder) + panic("locking against myself"); + ip->i_lockwaiter = p->p_pid; + } else + ip->i_lockwaiter = -1; +#endif + (void) sleep((caddr_t)ip, PINOD); + goto start; + } +#ifdef DIAGNOSTIC + ip->i_lockwaiter = 0; + if (ip->i_lockholder != 0) + panic("lockholder (%d) != 0", ip->i_lockholder); + if (p && p->p_pid == 0) + printf("locking by process 0\n"); + if (p) + ip->i_lockholder = p->p_pid; + else + ip->i_lockholder = -1; +#endif + ip->i_flag |= ILOCKED; return (0); } /* - * Unlock an inode. + * Unlock an inode. If WANT bit is on, wakeup. */ +int lockcount = 90; int -ufs_unlock(vp) - struct vnode *vp; +ufs_unlock(ap) + struct vop_unlock_args /* { + struct vnode *a_vp; + } */ *ap; { - register struct inode *ip = VTOI(vp); + register struct inode *ip = VTOI(ap->a_vp); + struct proc *p = curproc; /* XXX */ - if (!(ip->i_flag & ILOCKED)) +#ifdef DIAGNOSTIC + if ((ip->i_flag & ILOCKED) == 0) { + vprint("ufs_unlock: unlocked inode", ap->a_vp); panic("ufs_unlock NOT LOCKED"); - IUNLOCK(ip); + } + if (p && p->p_pid != ip->i_lockholder && p->p_pid > -1 && + ip->i_lockholder > -1 && lockcount++ < 100) + panic("unlocker (%d) != lock holder (%d)", + p->p_pid, ip->i_lockholder); + ip->i_lockholder = 0; +#endif + ip->i_flag &= ~ILOCKED; + if (ip->i_flag & IWANT) { + ip->i_flag &= ~IWANT; + wakeup((caddr_t)ip); + } return (0); } @@ -1198,11 +1675,13 @@ ufs_unlock(vp) * Check for a locked inode. */ int -ufs_islocked(vp) - struct vnode *vp; +ufs_islocked(ap) + struct vop_islocked_args /* { + struct vnode *a_vp; + } */ *ap; { - if (VTOI(vp)->i_flag & ILOCKED) + if (VTOI(ap->a_vp)->i_flag & ILOCKED) return (1); return (0); } @@ -1211,23 +1690,28 @@ ufs_islocked(vp) * Calculate the logical to physical mapping if not done already, * then call the device strategy routine. */ -int checkoverlap = 0; - int -ufs_strategy(bp) - register struct buf *bp; +ufs_strategy(ap) + struct vop_strategy_args /* { + struct buf *a_bp; + } */ *ap; { + register struct buf *bp = ap->a_bp; + register struct vnode *vp = bp->b_vp; register struct inode *ip; - struct vnode *vp; int error; - ip = VTOI(bp->b_vp); - if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR) + ip = VTOI(vp); + if (vp->v_type == VBLK || vp->v_type == VCHR) panic("ufs_strategy: spec"); if (bp->b_blkno == bp->b_lblkno) { if (error = - VOP_BMAP(bp->b_vp, bp->b_lblkno, NULL, &bp->b_blkno)) + VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL)) { + bp->b_error = error; + bp->b_flags |= B_ERROR; + biodone(bp); return (error); + } if ((long)bp->b_blkno == -1) clrbuf(bp); } @@ -1235,14 +1719,9 @@ ufs_strategy(bp) biodone(bp); return (0); } -#ifdef DIAGNOSTIC - if (checkoverlap && bp->b_vp->v_mount->mnt_stat.f_type == MOUNT_UFS) - ffs_checkoverlap(bp, ip); -#endif - vp = ip->i_devvp; bp->b_dev = vp->v_rdev; - (vp->v_op->vop_strategy)(bp); + VOCALL (vp->v_op, VOFFSET(vop_strategy), ap); return (0); } @@ -1250,9 +1729,12 @@ ufs_strategy(bp) * Print out the contents of an inode. */ int -ufs_print(vp) - struct vnode *vp; +ufs_print(ap) + struct vop_print_args /* { + struct vnode *a_vp; + } */ *ap; { + register struct vnode *vp = ap->a_vp; register struct inode *ip = VTOI(vp); printf("tag VT_UFS, ino %d, on dev %d, %d", ip->i_number, @@ -1262,11 +1744,11 @@ ufs_print(vp) fifo_printinfo(vp); #endif /* FIFO */ printf("%s\n", (ip->i_flag & ILOCKED) ? " (LOCKED)" : ""); - if (ip->i_spare0 == 0) + if (ip->i_lockholder == 0) return (0); - printf("\towner pid %d", ip->i_spare0); - if (ip->i_spare1) - printf(" waiting pid %d", ip->i_spare1); + printf("\towner pid %d", ip->i_lockholder); + if (ip->i_lockwaiter) + printf(" waiting pid %d", ip->i_lockwaiter); printf("\n"); return (0); } @@ -1275,36 +1757,40 @@ ufs_print(vp) * Read wrapper for special devices. */ int -ufsspec_read(vp, uio, ioflag, cred) - struct vnode *vp; - struct uio *uio; - int ioflag; - struct ucred *cred; +ufsspec_read(ap) + struct vop_read_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; { /* * Set access flag. */ - VTOI(vp)->i_flag |= IACC; - return (spec_read(vp, uio, ioflag, cred)); + VTOI(ap->a_vp)->i_flag |= IACC; + return (VOCALL (spec_vnodeop_p, VOFFSET(vop_read), ap)); } /* * Write wrapper for special devices. */ int -ufsspec_write(vp, uio, ioflag, cred) - struct vnode *vp; - struct uio *uio; - int ioflag; - struct ucred *cred; +ufsspec_write(ap) + struct vop_write_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; { /* * Set update and change flags. */ - VTOI(vp)->i_flag |= IUPD|ICHG; - return (spec_write(vp, uio, ioflag, cred)); + VTOI(ap->a_vp)->i_flag |= IUPD|ICHG; + return (VOCALL (spec_vnodeop_p, VOFFSET(vop_write), ap)); } /* @@ -1313,17 +1799,19 @@ ufsspec_write(vp, uio, ioflag, cred) * Update the times on the inode then do device close. */ int -ufsspec_close(vp, fflag, cred, p) - struct vnode *vp; - int fflag; - struct ucred *cred; - struct proc *p; +ufsspec_close(ap) + struct vop_close_args /* { + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { - register struct inode *ip = VTOI(vp); + register struct inode *ip = VTOI(ap->a_vp); - if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) + if (ap->a_vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) ITIMES(ip, &time, &time); - return (spec_close(vp, fflag, cred, p)); + return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap)); } #ifdef FIFO @@ -1331,36 +1819,42 @@ ufsspec_close(vp, fflag, cred, p) * Read wrapper for fifo's */ int -ufsfifo_read(vp, uio, ioflag, cred) - struct vnode *vp; - struct uio *uio; - int ioflag; - struct ucred *cred; +ufsfifo_read(ap) + struct vop_read_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; { + extern int (**fifo_vnodeop_p)(); /* * Set access flag. */ - VTOI(vp)->i_flag |= IACC; - return (fifo_read(vp, uio, ioflag, cred)); + VTOI(ap->a_vp)->i_flag |= IACC; + return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_read), ap)); } /* * Write wrapper for fifo's. */ int -ufsfifo_write(vp, uio, ioflag, cred) - struct vnode *vp; - struct uio *uio; - int ioflag; - struct ucred *cred; +ufsfifo_write(ap) + struct vop_write_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; { + extern int (**fifo_vnodeop_p)(); /* * Set update and change flags. */ - VTOI(vp)->i_flag |= IUPD|ICHG; - return (fifo_write(vp, uio, ioflag, cred)); + VTOI(ap->a_vp)->i_flag |= IUPD|ICHG; + return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_write), ap)); } /* @@ -1368,32 +1862,74 @@ ufsfifo_write(vp, uio, ioflag, cred) * * Update the times on the inode then do device close. */ -ufsfifo_close(vp, fflag, cred, p) - struct vnode *vp; - int fflag; - struct ucred *cred; - struct proc *p; +ufsfifo_close(ap) + struct vop_close_args /* { + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; { - register struct inode *ip = VTOI(vp); + extern int (**fifo_vnodeop_p)(); + register struct inode *ip = VTOI(ap->a_vp); - if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) + if (ap->a_vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) ITIMES(ip, &time, &time); - return (fifo_close(vp, fflag, cred, p)); + return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap)); } #endif /* FIFO */ +/* + * Return POSIX pathconf information applicable to ufs filesystems. + */ +ufs_pathconf(ap) + struct vop_pathconf_args /* { + struct vnode *a_vp; + int a_name; + int *a_retval; + } */ *ap; +{ + + switch (ap->a_name) { + case _PC_LINK_MAX: + *ap->a_retval = LINK_MAX; + return (0); + case _PC_NAME_MAX: + *ap->a_retval = NAME_MAX; + return (0); + case _PC_PATH_MAX: + *ap->a_retval = PATH_MAX; + return (0); + case _PC_PIPE_BUF: + *ap->a_retval = PIPE_BUF; + return (0); + case _PC_CHOWN_RESTRICTED: + *ap->a_retval = 1; + return (0); + case _PC_NO_TRUNC: + *ap->a_retval = 1; + return (0); + default: + return (EINVAL); + } + /* NOTREACHED */ +} + /* * Advisory record locking support */ int -ufs_advlock(vp, id, op, fl, flags) - struct vnode *vp; - caddr_t id; - int op; - register struct flock *fl; - int flags; +ufs_advlock(ap) + struct vop_advlock_args /* { + struct vnode *a_vp; + caddr_t a_id; + int a_op; + struct flock *a_fl; + int a_flags; + } */ *ap; { - register struct inode *ip = VTOI(vp); + register struct inode *ip = VTOI(ap->a_vp); + register struct flock *fl = ap->a_fl; register struct lockf *lock; off_t start, end; int error; @@ -1402,7 +1938,7 @@ ufs_advlock(vp, id, op, fl, flags) * Avoid the common case of unlocking when inode has no locks. */ if (ip->i_lockf == (struct lockf *)0) { - if (op != F_SETLK) { + if (ap->a_op != F_SETLK) { fl->l_type = F_UNLCK; return (0); } @@ -1440,16 +1976,16 @@ ufs_advlock(vp, id, op, fl, flags) MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, M_WAITOK); lock->lf_start = start; lock->lf_end = end; - lock->lf_id = id; + lock->lf_id = ap->a_id; lock->lf_inode = ip; lock->lf_type = fl->l_type; lock->lf_next = (struct lockf *)0; lock->lf_block = (struct lockf *)0; - lock->lf_flags = flags; + lock->lf_flags = ap->a_flags; /* * Do the requested operation. */ - switch(op) { + switch(ap->a_op) { case F_SETLK: return (lf_setlock(lock)); @@ -1477,10 +2013,11 @@ ufs_advlock(vp, id, op, fl, flags) int ufs_vinit(mntp, specops, fifoops, vpp) struct mount *mntp; - struct vnodeops *specops, *fifoops; + int (**specops)(); + int (**fifoops)(); struct vnode **vpp; { - struct inode *ip, *nip; + struct inode *ip; struct vnode *vp, *nvp; vp = *vpp; @@ -1491,22 +2028,21 @@ ufs_vinit(mntp, specops, fifoops, vpp) vp->v_op = specops; if (nvp = checkalias(vp, ip->i_rdev, mntp)) { /* - * Reinitialize aliased inode. + * Discard unneeded vnode, but save its inode. */ - vp = nvp; - nip = VTOI(vp); - nip->i_vnode = vp; - nip->i_flag = 0; - nip->i_din = ip->i_din; - nip->i_dev = ip->i_dev; - nip->i_number = ip->i_number; - ufs_ihashins(nip); + ufs_ihashrem(ip); + VOP_UNLOCK(vp); + nvp->v_data = vp->v_data; + vp->v_data = NULL; + vp->v_op = spec_vnodeop_p; + vrele(vp); + vgone(vp); /* - * Discard unneeded inode. + * Reinitialize aliased inode. */ - ip->i_mode = 0; - ufs_iput(ip); - ip = nip; + vp = nvp; + ip->i_vnode = vp; + ufs_ihashins(ip); } break; case VFIFO: @@ -1519,6 +2055,11 @@ ufs_vinit(mntp, specops, fifoops, vpp) } if (ip->i_number == ROOTINO) vp->v_flag |= VROOT; + /* + * Initialize modrev times + */ + SETHIGH(ip->i_modrev, mono_time.tv_sec); + SETLOW(ip->i_modrev, mono_time.tv_usec * 4294); *vpp = vp; return (0); } @@ -1527,39 +2068,44 @@ ufs_vinit(mntp, specops, fifoops, vpp) * Allocate a new inode. */ int -ufs_makeinode(mode, ndp, vpp) +ufs_makeinode(mode, dvp, vpp, cnp) int mode; - register struct nameidata *ndp; + struct vnode *dvp; struct vnode **vpp; + struct componentname *cnp; { register struct inode *ip, *pdir; + struct timeval tv; struct vnode *tvp; int error; - pdir = VTOI(ndp->ni_dvp); -#ifdef DIANOSTIC - if ((ndp->ni_nameiop & HASBUF) == 0) + pdir = VTOI(dvp); +#ifdef DIAGNOSTIC + if ((cnp->cn_flags & HASBUF) == 0) panic("ufs_makeinode: no name"); #endif *vpp = NULL; if ((mode & IFMT) == 0) mode |= IFREG; - if (error = VOP_VALLOC(ndp->ni_dvp, mode, ndp->ni_cred, &tvp)) { - free(ndp->ni_pnbuf, M_NAMEI); - ufs_iput(pdir); + if (error = VOP_VALLOC(dvp, mode, cnp->cn_cred, &tvp)) { + free(cnp->cn_pnbuf, M_NAMEI); + vput(dvp); return (error); } ip = VTOI(tvp); - ip->i_uid = ndp->ni_cred->cr_uid; ip->i_gid = pdir->i_gid; + if ((mode & IFMT) == IFLNK) + ip->i_uid = pdir->i_uid; + else + ip->i_uid = cnp->cn_cred->cr_uid; #ifdef QUOTA if ((error = getinoquota(ip)) || - (error = chkiq(ip, 1, ndp->ni_cred, 0))) { - free(ndp->ni_pnbuf, M_NAMEI); + (error = chkiq(ip, 1, cnp->cn_cred, 0))) { + free(cnp->cn_pnbuf, M_NAMEI); VOP_VFREE(tvp, ip->i_number, mode); - ufs_iput(ip); - ufs_iput(pdir); + vput(tvp); + vput(dvp); return (error); } #endif @@ -1567,20 +2113,21 @@ ufs_makeinode(mode, ndp, vpp) ip->i_mode = mode; tvp->v_type = IFTOVT(mode); /* Rest init'd in iget() */ ip->i_nlink = 1; - if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, ndp->ni_cred) && - suser(ndp->ni_cred, NULL)) + if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, cnp->cn_cred) && + suser(cnp->cn_cred, NULL)) ip->i_mode &= ~ISGID; /* * Make sure inode goes to disk before directory entry. */ - if (error = VOP_UPDATE(tvp, &time, &time, 1)) + tv = time; + if (error = VOP_UPDATE(tvp, &tv, &tv, 1)) goto bad; - if (error = ufs_direnter(ip, ndp)) + if (error = ufs_direnter(ip, dvp, cnp)) goto bad; - if ((ndp->ni_nameiop & SAVESTART) == 0) - FREE(ndp->ni_pnbuf, M_NAMEI); - ufs_iput(pdir); + if ((cnp->cn_flags & SAVESTART) == 0) + FREE(cnp->cn_pnbuf, M_NAMEI); + vput(dvp); *vpp = tvp; return (0); @@ -1589,10 +2136,10 @@ bad: * Write error occurred trying to update the inode * or the directory so must deallocate the inode. */ - free(ndp->ni_pnbuf, M_NAMEI); - ufs_iput(pdir); + free(cnp->cn_pnbuf, M_NAMEI); + vput(dvp); ip->i_nlink = 0; ip->i_flag |= ICHG; - ufs_iput(ip); + vput(tvp); return (error); }