X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/79cf21e2d88e134c5ae915d91910aee37c001816..1a3cb1931d9e6b043e0b9d77071d8b4f8e7348b9:/usr/src/sys/ufs/ffs/ufs_vnops.c diff --git a/usr/src/sys/ufs/ffs/ufs_vnops.c b/usr/src/sys/ufs/ffs/ufs_vnops.c index c249c7f072..7ba9d4ee3f 100644 --- a/usr/src/sys/ufs/ffs/ufs_vnops.c +++ b/usr/src/sys/ufs/ffs/ufs_vnops.c @@ -2,125 +2,83 @@ * Copyright (c) 1982, 1986, 1989 Regents of the University of California. * All rights reserved. * - * Redistribution and use in source and binary forms are permitted - * provided that the above copyright notice and this paragraph are - * duplicated in all such forms and that any documentation, - * advertising materials, and other materials related to such - * distribution and use acknowledge that the software was developed - * by the University of California, Berkeley. The name of the - * University may not be used to endorse or promote products derived - * from this software without specific prior written permission. - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * %sccs.include.redist.c% * - * @(#)ufs_vnops.c 7.10 (Berkeley) %G% + * @(#)ufs_vnops.c 7.71 (Berkeley) %G% */ -#include "param.h" -#include "systm.h" -#include "user.h" -#include "kernel.h" -#include "file.h" -#include "stat.h" -#include "buf.h" -#include "proc.h" -#include "uio.h" -#include "socket.h" -#include "socketvar.h" -#include "conf.h" -#include "mount.h" -#include "vnode.h" -#include "../ufs/inode.h" -#include "../ufs/fs.h" -#include "../ufs/quota.h" - -/* - * Global vfs data structures for ufs - */ - -int ufs_lookup(), - ufs_create(), - ufs_mknod(), - ufs_open(), - ufs_close(), - ufs_access(), - ufs_getattr(), - ufs_setattr(), - ufs_read(), - ufs_write(), - ufs_ioctl(), - ufs_select(), - ufs_mmap(), - ufs_fsync(), - ufs_seek(), - ufs_remove(), - ufs_link(), - ufs_rename(), - ufs_mkdir(), - ufs_rmdir(), - ufs_symlink(), - ufs_readdir(), - ufs_readlink(), - ufs_abortop(), - ufs_inactive(), - ufs_lock(), - ufs_unlock(), - ufs_bmap(), - ufs_strategy(); - -struct vnodeops ufs_vnodeops = { - ufs_lookup, - ufs_create, - ufs_mknod, - ufs_open, - ufs_close, - ufs_access, - ufs_getattr, - ufs_setattr, - ufs_read, - ufs_write, - ufs_ioctl, - ufs_select, - ufs_mmap, - ufs_fsync, - ufs_seek, - ufs_remove, - ufs_link, - ufs_rename, - ufs_mkdir, - ufs_rmdir, - ufs_symlink, - ufs_readdir, - ufs_readlink, - ufs_abortop, - ufs_inactive, - ufs_lock, - ufs_unlock, - ufs_bmap, - ufs_strategy, +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +int ufs_chmod __P((struct vnode *, int, struct proc *)); +int ufs_chown __P((struct vnode *, u_int, u_int, struct proc *)); + +enum vtype iftovt_tab[16] = { + VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, + VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, }; - -enum vtype iftovt_tab[8] = { - VNON, VCHR, VDIR, VBLK, VREG, VLNK, VSOCK, VBAD, +int vttoif_tab[9] = { + 0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFIFO, IFMT, }; -int vttoif_tab[8] = { - 0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFMT, + +#ifdef _NOQUAD +#define SETHIGH(q, h) (q).val[_QUAD_HIGHWORD] = (h) +#define SETLOW(q, l) (q).val[_QUAD_LOWWORD] = (l) +#else /* QUAD */ +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; \ +} +#endif /* QUAD */ /* * Create a regular file */ -ufs_create(ndp, vap) +int +ufs_create(ndp, vap, p) struct nameidata *ndp; struct vattr *vap; + struct proc *p; { - struct inode *ip; + struct vnode *vp; int error; - if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip)) + if (error = + ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &vp)) return (error); - ndp->ni_vp = ITOV(ip); + ndp->ni_vp = vp; return (0); } @@ -128,33 +86,37 @@ ufs_create(ndp, vap) * Mknod vnode call */ /* ARGSUSED */ -ufs_mknod(ndp, vap, cred) +int +ufs_mknod(ndp, vap, cred, p) struct nameidata *ndp; - struct ucred *cred; struct vattr *vap; + struct ucred *cred; + struct proc *p; { - struct inode *ip; + register struct inode *ip; + struct vnode *vp; int error; - if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip)) + if (error = + ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &vp)) return (error); - if (vap->va_rdev) { + ip = VTOI(vp); + ip->i_flag |= IACC|IUPD|ICHG; + if (vap->va_rdev != VNOVAL) { /* * Want to be able to use this to make badblock * inodes, so don't truncate the dev number. */ - ITOV(ip)->v_rdev = ip->i_rdev = vap->va_rdev; - ip->i_flag |= IACC|IUPD|ICHG; + ip->i_rdev = vap->va_rdev; } - iput(ip); /* * Remove inode so that it will be reloaded by iget and * checked to see if it is an alias of an existing entry * in the inode cache. */ - remque(ip); - ip->i_forw = ip; - ip->i_back = ip; + vput(vp); + vp->v_type = VNON; + vgone(vp); return (0); } @@ -164,10 +126,12 @@ ufs_mknod(ndp, vap, cred) * Nothing to do. */ /* ARGSUSED */ -ufs_open(vp, mode, cred) +int +ufs_open(vp, mode, cred, p) struct vnode *vp; int mode; struct ucred *cred; + struct proc *p; { return (0); @@ -179,35 +143,88 @@ ufs_open(vp, mode, cred) * Update the times on the inode. */ /* ARGSUSED */ -ufs_close(vp, fflag, cred) +int +ufs_close(vp, fflag, cred, p) struct vnode *vp; int fflag; struct ucred *cred; + struct proc *p; { - register struct inode *ip = VTOI(vp); + register struct inode *ip; - if (vp->v_count > 1 && !(ip->i_flag & ILOCKED)) + ip = VTOI(vp); + if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) ITIMES(ip, &time, &time); return (0); } -ufs_access(vp, mode, cred) +/* + * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC. + * The mode is shifted to select the owner/group/other fields. The + * super user is granted all permissions. + */ +int +ufs_access(vp, mode, cred, p) struct vnode *vp; - int mode; + register int mode; struct ucred *cred; + struct proc *p; { + register struct inode *ip = VTOI(vp); + register gid_t *gp; + int i, error; - return (iaccess(VTOI(vp), mode, cred)); +#ifdef DIAGNOSTIC + if (!VOP_ISLOCKED(vp)) { + vprint("ufs_access: not locked", vp); + panic("ufs_access: not locked"); + } +#endif +#ifdef QUOTA + if (mode & VWRITE) { + switch (vp->v_type) { + case VREG: case VDIR: case VLNK: + if (error = getinoquota(ip)) + return (error); + } + } +#endif /* QUOTA */ + /* + * If you're the super-user, you always get access. + */ + if (cred->cr_uid == 0) + return (0); + /* + * Access check is based on only one of owner, group, public. + * If not owner, then check group. If not a member of the + * group, then check public access. + */ + if (cred->cr_uid != ip->i_uid) { + mode >>= 3; + gp = cred->cr_groups; + for (i = 0; i < cred->cr_ngroups; i++, gp++) + if (ip->i_gid == *gp) + goto found; + mode >>= 3; +found: + ; + } + if ((ip->i_mode & mode) != 0) + return (0); + return (EACCES); } /* ARGSUSED */ -ufs_getattr(vp, vap, cred) +int +ufs_getattr(vp, vap, cred, p) struct vnode *vp; register struct vattr *vap; struct ucred *cred; + struct proc *p; { - register struct inode *ip = VTOI(vp); + register struct inode *ip; + ip = VTOI(vp); ITIMES(ip, &time, &time); /* * Copy from inode table @@ -219,76 +236,98 @@ ufs_getattr(vp, vap, cred) vap->va_uid = ip->i_uid; vap->va_gid = ip->i_gid; vap->va_rdev = (dev_t)ip->i_rdev; - vap->va_size = ip->i_ic.ic_size.val[0]; - vap->va_size1 = ip->i_ic.ic_size.val[1]; +#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_flags = ip->i_flags; + vap->va_gen = ip->i_gen; /* this doesn't belong here */ if (vp->v_type == VBLK) vap->va_blocksize = BLKDEV_IOSIZE; else if (vp->v_type == VCHR) vap->va_blocksize = MAXBSIZE; else - vap->va_blocksize = ip->i_fs->fs_bsize; - /* - * XXX THIS IS NOT CORRECT!!, but be sure to change vn_stat() - * if you change it. - */ - vap->va_bytes = ip->i_blocks; - vap->va_bytes1 = -1; + vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; + vap->va_bytes = dbtob(ip->i_blocks); +#ifdef _NOQUAD + vap->va_bytes_rsv = 0; +#endif vap->va_type = vp->v_type; + vap->va_filerev = ip->i_modrev; return (0); } /* * Set attribute vnode op. called from several syscalls */ -ufs_setattr(vp, vap, cred) +int +ufs_setattr(vp, vap, cred, p) register struct vnode *vp; register struct vattr *vap; register struct ucred *cred; + struct proc *p; { - register struct inode *ip = VTOI(vp); - int error = 0; + register struct inode *ip; + int error; /* - * Check for unsetable attributes. + * Check for unsettable attributes. */ if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || - ((int)vap->va_bytes != VNOVAL)) { + ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { return (EINVAL); } /* * Go through the fields and update iff not VNOVAL. */ if (vap->va_uid != (u_short)VNOVAL || vap->va_gid != (u_short)VNOVAL) - if (error = chown1(vp, vap->va_uid, vap->va_gid, cred)) + if (error = ufs_chown(vp, vap->va_uid, vap->va_gid, p)) return (error); if (vap->va_size != VNOVAL) { if (vp->v_type == VDIR) return (EISDIR); - if (error = iaccess(ip, IWRITE, cred)) - return (error); - if (error = itrunc(ip, vap->va_size)) + if (error = VOP_TRUNCATE(vp, vap->va_size, 0)) /* IO_SYNC? */ return (error); } + ip = VTOI(vp); if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { if (cred->cr_uid != ip->i_uid && - (error = suser(cred, &u.u_acflag))) + (error = suser(cred, &p->p_acflag))) return (error); if (vap->va_atime.tv_sec != VNOVAL) ip->i_flag |= IACC; if (vap->va_mtime.tv_sec != VNOVAL) ip->i_flag |= IUPD; ip->i_flag |= ICHG; - if (error = iupdat(ip, &vap->va_atime, &vap->va_mtime, 1)) + if (error = VOP_UPDATE(vp, &vap->va_atime, &vap->va_mtime, 1)) return (error); } + error = 0; if (vap->va_mode != (u_short)VNOVAL) - error = chmod1(vp, (int)vap->va_mode, cred); + 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; + } return (error); } @@ -296,28 +335,30 @@ ufs_setattr(vp, vap, cred) * Change the mode on a file. * Inode must be locked before calling. */ -chmod1(vp, mode, cred) +static int +ufs_chmod(vp, mode, p) register struct vnode *vp; register int mode; - struct ucred *cred; + struct proc *p; { + register struct ucred *cred = p->p_ucred; register struct inode *ip = VTOI(vp); int error; if (cred->cr_uid != ip->i_uid && - (error = suser(cred, &u.u_acflag))) + (error = suser(cred, &p->p_acflag))) return (error); - ip->i_mode &= ~07777; if (cred->cr_uid) { - if (vp->v_type != VDIR) - mode &= ~ISVTX; - if (!groupmember(ip->i_gid, cred)) - mode &= ~ISGID; + if (vp->v_type != VDIR && (mode & ISVTX)) + return (EFTYPE); + if (!groupmember(ip->i_gid, cred) && (mode & ISGID)) + return (EPERM); } + ip->i_mode &= ~07777; ip->i_mode |= mode & 07777; ip->i_flag |= ICHG; if ((vp->v_flag & VTEXT) && (ip->i_mode & ISVTX) == 0) - xrele(vp); + (void) vnode_pager_uncache(vp); return (0); } @@ -325,17 +366,22 @@ chmod1(vp, mode, cred) * Perform chown operation on inode ip; * inode must be locked prior to call. */ -chown1(vp, uid, gid, cred) +static int +ufs_chown(vp, uid, gid, p) register struct vnode *vp; - uid_t uid; - gid_t gid; - struct ucred *cred; + u_int uid; + u_int gid; + 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; #ifdef QUOTA - register long change; + register int i; + long change; #endif - int error; if (uid == (u_short)VNOVAL) uid = ip->i_uid; @@ -348,54 +394,108 @@ chown1(vp, uid, gid, cred) */ if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid || !groupmember((gid_t)gid, cred)) && - (error = suser(cred, &u.u_acflag))) + (error = suser(cred, &p->p_acflag))) return (error); + ouid = ip->i_uid; + ogid = ip->i_gid; #ifdef QUOTA - if (ip->i_uid == uid) /* this just speeds things a little */ - change = 0; - else - change = ip->i_blocks; - (void) chkdq(ip, -change, 1); - (void) chkiq(ip->i_dev, ip, ip->i_uid, 1); - dqrele(ip->i_dquot); + if (error = getinoquota(ip)) + return (error); + if (ouid == uid) { + dqrele(vp, ip->i_dquot[USRQUOTA]); + ip->i_dquot[USRQUOTA] = NODQUOT; + } + if (ogid == gid) { + dqrele(vp, ip->i_dquot[GRPQUOTA]); + ip->i_dquot[GRPQUOTA] = NODQUOT; + } + change = ip->i_blocks; + (void) chkdq(ip, -change, cred, CHOWN); + (void) chkiq(ip, -1, cred, CHOWN); + for (i = 0; i < MAXQUOTAS; i++) { + dqrele(vp, ip->i_dquot[i]); + ip->i_dquot[i] = NODQUOT; + } #endif ip->i_uid = uid; ip->i_gid = gid; - ip->i_flag |= ICHG; - if (cred->cr_ruid != 0) - ip->i_mode &= ~(ISUID|ISGID); #ifdef QUOTA - ip->i_dquot = inoquota(ip); - (void) chkdq(ip, change, 1); - (void) chkiq(ip->i_dev, (struct inode *)NULL, (uid_t)uid, 1); - return (u.u_error); /* should == 0 ALWAYS !! */ -#else + if ((error = getinoquota(ip)) == 0) { + if (ouid == uid) { + dqrele(vp, ip->i_dquot[USRQUOTA]); + ip->i_dquot[USRQUOTA] = NODQUOT; + } + if (ogid == gid) { + dqrele(vp, ip->i_dquot[GRPQUOTA]); + ip->i_dquot[GRPQUOTA] = NODQUOT; + } + if ((error = chkdq(ip, change, cred, CHOWN)) == 0) { + if ((error = chkiq(ip, 1, cred, CHOWN)) == 0) + goto good; + else + (void) chkdq(ip, -change, cred, CHOWN|FORCE); + } + for (i = 0; i < MAXQUOTAS; i++) { + dqrele(vp, ip->i_dquot[i]); + ip->i_dquot[i] = NODQUOT; + } + } + ip->i_uid = ouid; + ip->i_gid = ogid; + if (getinoquota(ip) == 0) { + if (ouid == uid) { + dqrele(vp, ip->i_dquot[USRQUOTA]); + ip->i_dquot[USRQUOTA] = NODQUOT; + } + if (ogid == gid) { + dqrele(vp, ip->i_dquot[GRPQUOTA]); + ip->i_dquot[GRPQUOTA] = NODQUOT; + } + (void) chkdq(ip, change, cred, FORCE|CHOWN); + (void) chkiq(ip, 1, cred, FORCE|CHOWN); + (void) getinoquota(ip); + } + return (error); +good: + if (getinoquota(ip)) + panic("chown: lost quota"); +#endif /* QUOTA */ + if (ouid != uid || ogid != gid) + ip->i_flag |= ICHG; + if (ouid != uid && cred->cr_uid != 0) + ip->i_mode &= ~ISUID; + if (ogid != gid && cred->cr_uid != 0) + ip->i_mode &= ~ISGID; return (0); -#endif } /* ARGSUSED */ -ufs_ioctl(vp, com, data, fflag, cred) +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; { - printf("ufs_ioctl called with type %d\n", vp->v_type); return (ENOTTY); } /* ARGSUSED */ -ufs_select(vp, which, cred) +int +ufs_select(vp, which, fflags, cred, p) struct vnode *vp; - int which; + int which, fflags; struct ucred *cred; + struct proc *p; { - printf("ufs_select called with type %d\n", vp->v_type); - return (1); /* XXX */ + /* + * We should really check to see if I/O is possible. + */ + return (1); } /* @@ -404,41 +504,24 @@ ufs_select(vp, which, cred) * NB Currently unsupported. */ /* ARGSUSED */ -ufs_mmap(vp, fflags, cred) +int +ufs_mmap(vp, fflags, cred, p) struct vnode *vp; int fflags; struct ucred *cred; + struct proc *p; { return (EINVAL); } -/* - * Synch an open file. - */ -/* ARGSUSED */ -ufs_fsync(vp, fflags, cred) - struct vnode *vp; - int fflags; - struct ucred *cred; -{ - register struct inode *ip = VTOI(vp); - int error; - - ILOCK(ip); - if (fflags&FWRITE) - ip->i_flag |= ICHG; - error = syncip(ip); - IUNLOCK(ip); - return (error); -} - /* * Seek on a file * * Nothing to do, so just return. */ /* ARGSUSED */ +int ufs_seek(vp, oldoff, newoff, cred) struct vnode *vp; off_t oldoff, newoff; @@ -453,15 +536,17 @@ ufs_seek(vp, oldoff, newoff, cred) * Hard to avoid races here, especially * in unlinking directories. */ -ufs_remove(ndp) +int +ufs_remove(ndp, p) struct nameidata *ndp; + struct proc *p; { register struct inode *ip, *dp; int error; ip = VTOI(ndp->ni_vp); dp = VTOI(ndp->ni_dvp); - error = dirremove(ndp); + error = ufs_dirremove(ndp); if (!error) { ip->i_nlink--; ip->i_flag |= ICHG; @@ -469,35 +554,43 @@ ufs_remove(ndp) if (dp == ip) vrele(ITOV(ip)); else - iput(ip); - iput(dp); + ufs_iput(ip); + ufs_iput(dp); return (error); } /* * link vnode call */ -ufs_link(vp, ndp) +int +ufs_link(vp, ndp, p) register struct vnode *vp; register struct nameidata *ndp; + struct proc *p; { - register struct inode *ip = VTOI(vp); + register struct inode *ip; int error; +#ifdef DIANOSTIC + if ((ndp->ni_nameiop & 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 (ndp->ni_dvp != vp) ILOCK(ip); - if (ip->i_nlink == LINK_MAX - 1) { - error = EMLINK; - goto out; - } ip->i_nlink++; ip->i_flag |= ICHG; - error = iupdat(ip, &time, &time, 1); + error = VOP_UPDATE(vp, &time, &time, 1); if (!error) - error = direnter(ip, ndp); -out: + error = ufs_direnter(ip, ndp); if (ndp->ni_dvp != vp) IUNLOCK(ip); + FREE(ndp->ni_pnbuf, M_NAMEI); + vput(ndp->ni_dvp); if (error) { ip->i_nlink--; ip->i_flag |= ICHG; @@ -529,28 +622,53 @@ out: * is different from the source, patch the ".." entry in the * directory. */ -ufs_rename(fndp, tndp) +int +ufs_rename(fndp, tndp, p) register struct nameidata *fndp, *tndp; + struct proc *p; { register struct inode *ip, *xp, *dp; struct dirtemplate dirbuf; int doingdirectory = 0, oldparent = 0, newparent = 0; int error = 0; +#ifdef DIANOSTIC + if ((tndp->ni_nameiop & HASBUF) == 0 || + (fndp->ni_nameiop & HASBUF) == 0) + panic("ufs_rename: no name"); +#endif dp = VTOI(fndp->ni_dvp); ip = VTOI(fndp->ni_vp); + /* + * 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); + } + doingdirectory = 0; + goto unlinkit; + } ILOCK(ip); if ((ip->i_mode&IFMT) == IFDIR) { - register struct direct *d = &fndp->ni_dent; - /* * Avoid ".", "..", and aliases of "." for obvious reasons. */ - if ((d->d_namlen == 1 && d->d_name[0] == '.') || dp == ip || - fndp->ni_isdotdot || (ip->i_flag & IRENAME)) { - IUNLOCK(ip); - ufs_abortop(fndp); - ufs_abortop(tndp); + 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); } ip->i_flag |= IRENAME; @@ -567,7 +685,7 @@ ufs_rename(fndp, tndp) */ ip->i_nlink++; ip->i_flag |= ICHG; - error = iupdat(ip, &time, &time, 1); + error = VOP_UPDATE(fndp->ni_vp, &time, &time, 1); IUNLOCK(ip); /* @@ -591,21 +709,24 @@ ufs_rename(fndp, tndp) if (oldparent != dp->i_number) newparent = dp->i_number; if (doingdirectory && newparent) { - if (error = iaccess(ip, IWRITE, tndp->ni_cred)) + VOP_LOCK(fndp->ni_vp); + error = ufs_access(fndp->ni_vp, VWRITE, tndp->ni_cred, p); + VOP_UNLOCK(fndp->ni_vp); + if (error) goto bad; - tndp->ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE; - do { - dp = VTOI(tndp->ni_dvp); - if (xp != NULL) - iput(xp); - if (error = checkpath(ip, dp, tndp->ni_cred)) - goto out; - if (error = namei(tndp)) - goto out; - xp = NULL; - if (tndp->ni_vp) - xp = VTOI(tndp->ni_vp); - } while (dp != VTOI(tndp->ni_dvp)); + if (xp != NULL) + ufs_iput(xp); + if (error = ufs_checkpath(ip, dp, tndp->ni_cred)) + goto out; + if ((tndp->ni_nameiop & SAVESTART) == 0) + panic("ufs_rename: lost to startdir"); + p->p_spare[1]--; + if (error = lookup(tndp, p)) + goto out; + dp = VTOI(tndp->ni_dvp); + xp = NULL; + if (tndp->ni_vp) + xp = VTOI(tndp->ni_vp); } /* * 2) If target doesn't exist, link the target @@ -623,12 +744,24 @@ ufs_rename(fndp, tndp) * parent we don't fool with the link count. */ if (doingdirectory && newparent) { + if ((unsigned short)dp->i_nlink >= LINK_MAX) { + error = EMLINK; + goto bad; + } dp->i_nlink++; dp->i_flag |= ICHG; - error = iupdat(dp, &time, &time, 1); + if (error = VOP_UPDATE(ITOV(dp), &time, &time, 1)) + goto bad; } - if (error = direnter(ip, tndp)) - goto out; + if (error = ufs_direnter(ip, tndp)) { + if (doingdirectory && newparent) { + dp->i_nlink--; + dp->i_flag |= ICHG; + (void)VOP_UPDATE(ITOV(dp), &time, &time, 1); + } + goto bad; + } + ufs_iput(dp); } else { if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) panic("rename: EXDEV"); @@ -650,14 +783,12 @@ ufs_rename(fndp, tndp) goto bad; } /* - * Target must be empty if a directory - * and have no links to it. - * Also, insure source and target are - * compatible (both directories, or both - * not directories). + * Target must be empty if a directory and have no links + * to it. Also, ensure source and target are compatible + * (both directories, or both not directories). */ if ((xp->i_mode&IFMT) == IFDIR) { - if (!dirempty(xp, dp->i_number, tndp->ni_cred) || + if (!ufs_dirempty(xp, dp->i_number, tndp->ni_cred) || xp->i_nlink > 2) { error = ENOTEMPTY; goto bad; @@ -671,9 +802,19 @@ ufs_rename(fndp, tndp) error = EISDIR; goto bad; } - if (error = dirrewrite(dp, ip, tndp)) + if (error = ufs_dirrewrite(dp, ip, tndp)) goto bad; - vput(ITOV(dp)); + /* + * If the target directory is in the same + * directory as the source directory, + * decrement the link count on the parent + * of the target directory. + */ + if (doingdirectory && !newparent) { + dp->i_nlink--; + dp->i_flag |= ICHG; + } + ufs_iput(dp); /* * Adjust the link count of the target to * reflect the dirrewrite above. If this is @@ -688,26 +829,34 @@ ufs_rename(fndp, tndp) if (doingdirectory) { if (--xp->i_nlink != 0) panic("rename: linked directory"); - error = itrunc(xp, (u_long)0); + error = VOP_TRUNCATE(ITOV(xp), (u_long)0, IO_SYNC); } xp->i_flag |= ICHG; - vput(ITOV(xp)); + ufs_iput(xp); xp = NULL; } /* * 3) Unlink the source. */ - fndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF; - (void)namei(fndp); +unlinkit: + fndp->ni_nameiop &= ~MODMASK; + fndp->ni_nameiop |= LOCKPARENT | LOCKLEAF; + if ((fndp->ni_nameiop & 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); } else { - if (fndp->ni_dvp != NULL) - vput(fndp->ni_dvp); - xp = NULL; - dp = NULL; + /* + * From name has disappeared. + */ + if (doingdirectory) + panic("rename: lost dir entry"); + vrele(ITOV(ip)); + return (0); } /* * Ensure that the directory entry still exists and has not @@ -732,26 +881,30 @@ ufs_rename(fndp, tndp) if (doingdirectory && newparent) { dp->i_nlink--; dp->i_flag |= ICHG; - error = rdwri(UIO_READ, xp, (caddr_t)&dirbuf, + error = vn_rdwr(UIO_READ, ITOV(xp), (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, - UIO_SYSSPACE, tndp->ni_cred, (int *)0); + UIO_SYSSPACE, IO_NODELOCKED, + tndp->ni_cred, (int *)0, (struct proc *)0); if (error == 0) { if (dirbuf.dotdot_namlen != 2 || dirbuf.dotdot_name[0] != '.' || dirbuf.dotdot_name[1] != '.') { - printf("rename: mangled dir\n"); + ufs_dirbad(xp, 12, + "rename: mangled dir"); } else { dirbuf.dotdot_ino = newparent; - (void) rdwri(UIO_WRITE, xp, + (void) vn_rdwr(UIO_WRITE, ITOV(xp), (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, - tndp->ni_cred, (int *)0); + IO_NODELOCKED|IO_SYNC, + tndp->ni_cred, (int *)0, + (struct proc *)0); cache_purge(ITOV(dp)); } } } - error = dirremove(fndp); + error = ufs_dirremove(fndp); if (!error) { xp->i_nlink--; xp->i_flag |= ICHG; @@ -779,7 +932,7 @@ out: /* * A virgin directory (no blushing please). */ -struct dirtemplate mastertemplate = { +static struct dirtemplate mastertemplate = { 0, 12, 1, ".", 0, DIRBLKSIZ - 12, 2, ".." }; @@ -787,48 +940,60 @@ struct dirtemplate mastertemplate = { /* * Mkdir system call */ -ufs_mkdir(ndp, vap) +int +ufs_mkdir(ndp, vap, p) struct nameidata *ndp; struct vattr *vap; + struct proc *p; { register struct inode *ip, *dp; - struct inode *tip; + struct vnode *tvp; struct vnode *dvp; struct dirtemplate dirtemplate; int error; int dmode; +#ifdef DIANOSTIC + if ((ndp->ni_nameiop & 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); + } dmode = vap->va_mode&0777; dmode |= IFDIR; /* - * Must simulate part of maknode here - * in order to acquire the inode, but - * not have it entered in the parent - * directory. The entry is made later - * after writing "." and ".." entries out. + * 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. */ - error = ialloc(dp, dirpref(dp->i_fs), dmode, &tip); - if (error) { - iput(dp); + if (error = VOP_VALLOC(dvp, dmode, ndp->ni_cred, &tvp)) { + free(ndp->ni_pnbuf, M_NAMEI); + ufs_iput(dp); return (error); } - ip = tip; + ip = VTOI(tvp); + ip->i_uid = ndp->ni_cred->cr_uid; + ip->i_gid = dp->i_gid; #ifdef QUOTA - if (ip->i_dquot != NODQUOT) - panic("mkdir: dquot"); + if ((error = getinoquota(ip)) || + (error = chkiq(ip, 1, ndp->ni_cred, 0))) { + free(ndp->ni_pnbuf, M_NAMEI); + VOP_VFREE(tvp, ip->i_number, dmode); + ufs_iput(ip); + ufs_iput(dp); + return (error); + } #endif ip->i_flag |= IACC|IUPD|ICHG; ip->i_mode = dmode; ITOV(ip)->v_type = VDIR; /* Rest init'd in iget() */ ip->i_nlink = 2; - ip->i_uid = ndp->ni_cred->cr_uid; - ip->i_gid = dp->i_gid; -#ifdef QUOTA - ip->i_dquot = inoquota(ip); -#endif - error = iupdat(ip, &time, &time, 1); + error = VOP_UPDATE(ITOV(ip), &time, &time, 1); /* * Bump link count in parent directory @@ -838,67 +1003,59 @@ ufs_mkdir(ndp, vap) */ dp->i_nlink++; dp->i_flag |= ICHG; - error = iupdat(dp, &time, &time, 1); + if (error = VOP_UPDATE(ITOV(dp), &time, &time, 1)) + goto bad; - /* - * Initialize directory with "." - * and ".." from static template. - */ + /* Initialize directory with "." and ".." from static template. */ dirtemplate = mastertemplate; dirtemplate.dot_ino = ip->i_number; dirtemplate.dotdot_ino = dp->i_number; - error = rdwri(UIO_WRITE, ip, (caddr_t)&dirtemplate, - sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE, - ndp->ni_cred, (int *)0); + error = vn_rdwr(UIO_WRITE, ITOV(ip), (caddr_t)&dirtemplate, + sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE, + IO_NODELOCKED|IO_SYNC, ndp->ni_cred, (int *)0, (struct proc *)0); if (error) { dp->i_nlink--; dp->i_flag |= ICHG; goto bad; } - if (DIRBLKSIZ > dp->i_fs->fs_fsize) - panic("mkdir: blksize"); /* XXX - should grow w/balloc() */ - else + if (DIRBLKSIZ > VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize) + panic("ufs_mkdir: blksize"); /* XXX should grow with balloc() */ + else { ip->i_size = DIRBLKSIZ; - /* - * Directory all set up, now - * install the entry for it in - * the parent directory. - */ - error = direnter(ip, ndp); - dp = NULL; - if (error) { - ndp->ni_nameiop = LOOKUP | NOCACHE; - error = namei(ndp); - if (!error) { - dp = VTOI(ndp->ni_vp); - dp->i_nlink--; - dp->i_flag |= ICHG; - } + ip->i_flag |= ICHG; + } + + /* Directory set up, now install it's entry in the parent directory. */ + if (error = ufs_direnter(ip, ndp)) { + dp->i_nlink--; + dp->i_flag |= ICHG; } bad: /* - * No need to do an explicit itrunc here, - * vrele will do this for us because we set - * the link count to 0. + * No need to do an explicit VOP_TRUNCATE here, vrele will do this + * for us because we set the link count to 0. */ if (error) { ip->i_nlink = 0; ip->i_flag |= ICHG; - } - iput(ip); - if (dp) - iput(dp); + ufs_iput(ip); + } else + ndp->ni_vp = ITOV(ip); + FREE(ndp->ni_pnbuf, M_NAMEI); + ufs_iput(dp); return (error); } /* * Rmdir system call. */ -ufs_rmdir(ndp) +int +ufs_rmdir(ndp, p) register struct nameidata *ndp; + struct proc *p; { register struct inode *ip, *dp; - int error = 0; + int error; ip = VTOI(ndp->ni_vp); dp = VTOI(ndp->ni_dvp); @@ -906,8 +1063,8 @@ ufs_rmdir(ndp) * No rmdir "." please. */ if (dp == ip) { - vrele(ITOV(dp)); - iput(ip); + vrele(ndp->ni_dvp); + ufs_iput(ip); return (EINVAL); } /* @@ -917,7 +1074,9 @@ ufs_rmdir(ndp) * the current directory and thus be * non-empty.) */ - if (ip->i_nlink != 2 || !dirempty(ip, dp->i_number, ndp->ni_cred)) { + error = 0; + if (ip->i_nlink != 2 || + !ufs_dirempty(ip, dp->i_number, ndp->ni_cred)) { error = ENOTEMPTY; goto out; } @@ -926,12 +1085,12 @@ ufs_rmdir(ndp) * inode. If we crash in between, the directory * will be reattached to lost+found, */ - if (error = dirremove(ndp)) + if (error = ufs_dirremove(ndp)) goto out; dp->i_nlink--; dp->i_flag |= ICHG; - cache_purge(ITOV(dp)); - iput(dp); + cache_purge(ndp->ni_dvp); + ufs_iput(dp); ndp->ni_dvp = NULL; /* * Truncate inode. The only stuff left @@ -945,100 +1104,97 @@ ufs_rmdir(ndp) * worry about them later. */ ip->i_nlink -= 2; - error = itrunc(ip, (u_long)0); + error = VOP_TRUNCATE(ndp->ni_vp, (u_long)0, IO_SYNC); cache_purge(ITOV(ip)); out: if (ndp->ni_dvp) - iput(dp); - iput(ip); + ufs_iput(dp); + ufs_iput(ip); return (error); } /* * symlink -- make a symbolic link */ -ufs_symlink(ndp, vap, target) +int +ufs_symlink(ndp, vap, target, p) struct nameidata *ndp; struct vattr *vap; char *target; + struct proc *p; { - struct inode *ip; + struct vnode *vp; int error; - error = maknode(IFLNK | vap->va_mode, ndp, &ip); - if (error) + if (error = ufs_makeinode(IFLNK | vap->va_mode, ndp, &vp)) return (error); - error = rdwri(UIO_WRITE, ip, target, strlen(target), (off_t)0, - UIO_SYSSPACE, ndp->ni_cred, (int *)0); - iput(ip); + error = vn_rdwr(UIO_WRITE, vp, target, strlen(target), (off_t)0, + UIO_SYSSPACE, IO_NODELOCKED, ndp->ni_cred, (int *)0, + (struct proc *)0); + vput(vp); return (error); } /* * Vnode op for read and write */ -ufs_readdir(vp, uio, offp, cred) +int +ufs_readdir(vp, uio, cred, eofflagp) struct vnode *vp; register struct uio *uio; - off_t *offp; struct ucred *cred; + int *eofflagp; { - register struct inode *ip = VTOI(vp); - int count, error; + int count, lost, error; - ILOCK(ip); - uio->uio_offset = *offp; count = uio->uio_resid; count &= ~(DIRBLKSIZ - 1); - if (vp->v_type != VDIR || uio->uio_iovcnt != 1 || - (count < DIRBLKSIZ) || (uio->uio_offset & (DIRBLKSIZ -1))) { - IUNLOCK(ip); + lost = uio->uio_resid - count; + if (count < DIRBLKSIZ || (uio->uio_offset & (DIRBLKSIZ -1))) return (EINVAL); - } uio->uio_resid = count; uio->uio_iov->iov_len = count; - error = readip(ip, uio, cred); - *offp += count - uio->uio_resid; - IUNLOCK(ip); + error = VOP_READ(vp, uio, 0, cred); + uio->uio_resid += lost; + if ((VTOI(vp)->i_size - uio->uio_offset) <= 0) + *eofflagp = 1; + else + *eofflagp = 0; return (error); } /* * Return target name of a symbolic link */ +int ufs_readlink(vp, uiop, cred) struct vnode *vp; struct uio *uiop; struct ucred *cred; { - return (readip(VTOI(vp), uiop, cred)); + return (VOP_READ(vp, uiop, 0, cred)); } /* * Ufs abort op, called after namei() when a CREATE/DELETE isn't actually - * done. Iff ni_vp/ni_dvp not null and locked, unlock. + * done. If a buffer has been saved in anticipation of a CREATE, delete it. */ +/* ARGSUSED */ +int ufs_abortop(ndp) - register struct nameidata *ndp; + struct nameidata *ndp; { - register struct inode *ip; - if (ndp->ni_vp) { - ip = VTOI(ndp->ni_vp); - if (ip->i_flag & ILOCKED) - IUNLOCK(ip); - vrele(ndp->ni_vp); - } - if (ndp->ni_dvp) { - ip = VTOI(ndp->ni_dvp); - if (ip->i_flag & ILOCKED) - IUNLOCK(ip); - vrele(ndp->ni_dvp); - } - return; + if ((ndp->ni_nameiop & (HASBUF | SAVESTART)) == HASBUF) + FREE(ndp->ni_pnbuf, M_NAMEI); + return (0); } +/* + * Lock an inode. + */ +int ufs_lock(vp) struct vnode *vp; { @@ -1048,6 +1204,10 @@ ufs_lock(vp) return (0); } +/* + * Unlock an inode. + */ +int ufs_unlock(vp) struct vnode *vp; { @@ -1060,91 +1220,409 @@ ufs_unlock(vp) } /* - * Get access to bmap + * Check for a locked inode. */ -ufs_bmap(vp, bn, vpp, bnp) +int +ufs_islocked(vp) struct vnode *vp; - daddr_t bn; - struct vnode **vpp; - daddr_t *bnp; { - struct inode *ip = VTOI(vp); - if (vpp != NULL) - *vpp = ip->i_devvp; - if (bnp == NULL) - return (0); - return (bmap(ip, bn, bnp, (daddr_t *)0, (int *)0)); + if (VTOI(vp)->i_flag & ILOCKED) + return (1); + return (0); } /* - * Just call the device strategy routine + * 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; { - (*bdevsw[major(bp->b_dev)].d_strategy)(bp); + 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) + 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)) + return (error); + if ((long)bp->b_blkno == -1) + clrbuf(bp); + } + if ((long)bp->b_blkno == -1) { + 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); return (0); } /* - * Make a new file. + * Print out the contents of an inode. */ -maknode(mode, ndp, ipp) +int +ufs_print(vp) + struct vnode *vp; +{ + register struct inode *ip = VTOI(vp); + + printf("tag VT_UFS, ino %d, on dev %d, %d", ip->i_number, + major(ip->i_dev), minor(ip->i_dev)); +#ifdef FIFO + if (vp->v_type == VFIFO) + fifo_printinfo(vp); +#endif /* FIFO */ + printf("%s\n", (ip->i_flag & ILOCKED) ? " (LOCKED)" : ""); + if (ip->i_lockholder == 0) + return (0); + printf("\towner pid %d", ip->i_lockholder); + if (ip->i_lockwaiter) + printf(" waiting pid %d", ip->i_lockwaiter); + printf("\n"); + return (0); +} + +/* + * Read wrapper for special devices. + */ +int +ufsspec_read(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + + /* + * Set access flag. + */ + VTOI(vp)->i_flag |= IACC; + return (spec_read(vp, uio, ioflag, cred)); +} + +/* + * Write wrapper for special devices. + */ +int +ufsspec_write(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + + /* + * Set update and change flags. + */ + VTOI(vp)->i_flag |= IUPD|ICHG; + return (spec_write(vp, uio, ioflag, cred)); +} + +/* + * Close wrapper for special devices. + * + * 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; +{ + register struct inode *ip = VTOI(vp); + + if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) + ITIMES(ip, &time, &time); + return (spec_close(vp, fflag, cred, p)); +} + +#ifdef FIFO +/* + * Read wrapper for fifo's + */ +int +ufsfifo_read(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + + /* + * Set access flag. + */ + VTOI(vp)->i_flag |= IACC; + return (fifo_read(vp, uio, ioflag, cred)); +} + +/* + * Write wrapper for fifo's. + */ +int +ufsfifo_write(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + + /* + * Set update and change flags. + */ + VTOI(vp)->i_flag |= IUPD|ICHG; + return (fifo_write(vp, uio, ioflag, cred)); +} + +/* + * Close wrapper for fifo's. + * + * 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; +{ + register struct inode *ip = VTOI(vp); + + if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) + ITIMES(ip, &time, &time); + return (fifo_close(vp, fflag, cred, p)); +} +#endif /* FIFO */ + +/* + * 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; +{ + register struct inode *ip = VTOI(vp); + register struct lockf *lock; + off_t start, end; + int error; + + /* + * Avoid the common case of unlocking when inode has no locks. + */ + if (ip->i_lockf == (struct lockf *)0) { + if (op != F_SETLK) { + fl->l_type = F_UNLCK; + return (0); + } + } + /* + * Convert the flock structure into a start and end. + */ + switch (fl->l_whence) { + + case SEEK_SET: + case SEEK_CUR: + /* + * Caller is responsible for adding any necessary offset + * when SEEK_CUR is used. + */ + start = fl->l_start; + break; + + case SEEK_END: + start = ip->i_size + fl->l_start; + break; + + default: + return (EINVAL); + } + if (start < 0) + return (EINVAL); + if (fl->l_len == 0) + end = -1; + else + end = start + fl->l_len - 1; + /* + * Create the lockf structure + */ + MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, M_WAITOK); + lock->lf_start = start; + lock->lf_end = end; + lock->lf_id = 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; + /* + * Do the requested operation. + */ + switch(op) { + case F_SETLK: + return (lf_setlock(lock)); + + case F_UNLCK: + error = lf_clearlock(lock); + FREE(lock, M_LOCKF); + return (error); + + case F_GETLK: + error = lf_getlock(lock, fl); + FREE(lock, M_LOCKF); + return (error); + + default: + free(lock, M_LOCKF); + return (EINVAL); + } + /* NOTREACHED */ +} + +/* + * Initialize the vnode associated with a new inode, handle aliased + * vnodes. + */ +int +ufs_vinit(mntp, specops, fifoops, vpp) + struct mount *mntp; + struct vnodeops *specops, *fifoops; + struct vnode **vpp; +{ + struct inode *ip, *nip; + struct vnode *vp, *nvp; + extern struct vnodeops spec_vnodeops; + + vp = *vpp; + ip = VTOI(vp); + switch(vp->v_type = IFTOVT(ip->i_mode)) { + case VCHR: + case VBLK: + vp->v_op = specops; + if (nvp = checkalias(vp, ip->i_rdev, mntp)) { + /* + * Discard unneeded vnode, but save its inode. + */ + remque(ip); + IUNLOCK(ip); + nvp->v_data = vp->v_data; + vp->v_data = NULL; + vp->v_op = &spec_vnodeops; + vrele(vp); + vgone(vp); + /* + * Reinitialize aliased inode. + */ + vp = nvp; + ip->i_vnode = vp; + ufs_ihashins(ip); + } + break; + case VFIFO: +#ifdef FIFO + vp->v_op = fifoops; + break; +#else + return (EOPNOTSUPP); +#endif + } + 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); +} + +/* + * Allocate a new inode. + */ +int +ufs_makeinode(mode, ndp, vpp) int mode; register struct nameidata *ndp; - struct inode **ipp; + struct vnode **vpp; { - register struct inode *ip; - struct inode *tip; - register struct inode *pdir = VTOI(ndp->ni_dvp); - ino_t ipref; + register struct inode *ip, *pdir; + struct vnode *tvp; int error; - *ipp = 0; - if ((mode & IFMT) == IFDIR) - ipref = dirpref(pdir->i_fs); - else - ipref = pdir->i_number; - error = ialloc(pdir, ipref, mode, &tip); - if (error) { - iput(pdir); + pdir = VTOI(ndp->ni_dvp); +#ifdef DIANOSTIC + if ((ndp->ni_nameiop & 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); return (error); } - ip = tip; + ip = VTOI(tvp); + ip->i_uid = ndp->ni_cred->cr_uid; + ip->i_gid = pdir->i_gid; #ifdef QUOTA - if (ip->i_dquot != NODQUOT) - panic("maknode: dquot"); + if ((error = getinoquota(ip)) || + (error = chkiq(ip, 1, ndp->ni_cred, 0))) { + free(ndp->ni_pnbuf, M_NAMEI); + VOP_VFREE(tvp, ip->i_number, mode); + ufs_iput(ip); + ufs_iput(pdir); + return (error); + } #endif ip->i_flag |= IACC|IUPD|ICHG; - if ((mode & IFMT) == 0) - mode |= IFREG; ip->i_mode = mode; - ITOV(ip)->v_type = IFTOVT(mode); /* Rest init'd in iget() */ + tvp->v_type = IFTOVT(mode); /* Rest init'd in iget() */ ip->i_nlink = 1; - ip->i_uid = ndp->ni_cred->cr_uid; - ip->i_gid = pdir->i_gid; if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, ndp->ni_cred) && suser(ndp->ni_cred, NULL)) ip->i_mode &= ~ISGID; -#ifdef QUOTA - ip->i_dquot = inoquota(ip); -#endif /* * Make sure inode goes to disk before directory entry. */ - if ((error = iupdat(ip, &time, &time, 1)) || - (error = direnter(ip, ndp))) { - /* - * Write error occurred trying to update the inode - * or the directory so must deallocate the inode. - */ - ip->i_nlink = 0; - ip->i_flag |= ICHG; - iput(ip); - return (error); - } - *ipp = ip; + if (error = VOP_UPDATE(tvp, &time, &time, 1)) + goto bad; + if (error = ufs_direnter(ip, ndp)) + goto bad; + if ((ndp->ni_nameiop & SAVESTART) == 0) + FREE(ndp->ni_pnbuf, M_NAMEI); + ufs_iput(pdir); + *vpp = tvp; return (0); + +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); + ip->i_nlink = 0; + ip->i_flag |= ICHG; + ufs_iput(ip); + return (error); }