X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/5485e062213aa576f431ef766f639e248716dfe8..88a7a62ac37860454424240400aa10e0319144c7:/usr/src/sys/ufs/lfs/lfs_vnops.c

diff --git a/usr/src/sys/ufs/lfs/lfs_vnops.c b/usr/src/sys/ufs/lfs/lfs_vnops.c
index c1244b05a4..b5e8dce5e9 100644
--- a/usr/src/sys/ufs/lfs/lfs_vnops.c
+++ b/usr/src/sys/ufs/lfs/lfs_vnops.c
@@ -1,147 +1,278 @@
-/*	lfs_vnops.c	4.18	82/02/27	*/
+/*	lfs_vnops.c	4.57	83/05/27	*/
 
 #include "../h/param.h"
 #include "../h/systm.h"
-#include "../h/mount.h"
-#include "../h/ino.h"
-#include "../h/reg.h"
-#include "../h/buf.h"
-#include "../h/filsys.h"
 #include "../h/dir.h"
 #include "../h/user.h"
-#include "../h/inode.h"
+#include "../h/kernel.h"
 #include "../h/file.h"
-#include "../h/conf.h"
 #include "../h/stat.h"
-#include "../h/inline.h"
+#include "../h/inode.h"
+#include "../h/fs.h"
+#include "../h/buf.h"
+#include "../h/proc.h"
+#include "../h/quota.h"
+#include "../h/uio.h"
 #include "../h/socket.h"
 #include "../h/socketvar.h"
+#include "../h/nami.h"
+#include "../h/mount.h"
+
+extern	struct fileops inodeops;
+struct	file *getinode();
 
 /*
- * the fstat system call.
+ * Change current working directory (``.'').
  */
-fstat()
+chdir()
 {
-	register struct file *fp;
-	register struct a {
-		int	fdes;
-		struct stat *sb;
-	} *uap;
 
-	uap = (struct a *)u.u_ap;
-	fp = getf(uap->fdes);
-	if (fp == NULL)
-		return;
-	if (fp->f_flag & FSOCKET)
-		u.u_error = sostat(fp->f_socket, uap->sb);
-	else
-		stat1(fp->f_inode, uap->sb);
+	chdirec(&u.u_cdir);
 }
 
 /*
- * Stat system call.  This version does not follow links.
+ * Change notion of root (``/'') directory.
  */
-stat()
+chroot()
+{
+
+	if (suser())
+		chdirec(&u.u_rdir);
+}
+
+/*
+ * Common routine for chroot and chdir.
+ */
+chdirec(ipp)
+	register struct inode **ipp;
 {
 	register struct inode *ip;
-	register struct a {
+	struct a {
 		char	*fname;
-		struct stat *sb;
-	} *uap;
+	};
 
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, 0, 0);
+	ip = namei(uchar, LOOKUP, 1);
 	if (ip == NULL)
 		return;
-	stat1(ip, uap->sb);
+	if ((ip->i_mode&IFMT) != IFDIR) {
+		u.u_error = ENOTDIR;
+		goto bad;
+	}
+	if (access(ip, IEXEC))
+		goto bad;
+	iunlock(ip);
+	if (*ipp)
+		irele(*ipp);
+	*ipp = ip;
+	return;
+
+bad:
 	iput(ip);
 }
 
 /*
- * Lstat system call.  This version does follow links.
+ * Open system call.
  */
-lstat()
+open()
 {
-	register struct inode *ip;
-	register struct a {
+	struct a {
 		char	*fname;
-		struct stat *sb;
-	} *uap;
+		int	mode;
+		int	crtmode;
+	} *uap = (struct a *) u.u_ap;
 
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, 0, 1);
-	if (ip == NULL)
+	copen(uap->mode-FOPEN, uap->crtmode);
+}
+
+/*
+ * Creat system call.
+ */
+creat()
+{
+	struct a {
+		char	*fname;
+		int	fmode;
+	} *uap = (struct a *)u.u_ap;
+
+	copen(FWRITE|FCREAT|FTRUNC, uap->fmode);
+}
+
+/*
+ * Common code for open and creat.
+ * Check permissions, allocate an open file structure,
+ * and call the device open routine if any.
+ */
+copen(mode, arg)
+	register int mode;
+	int arg;
+{
+	register struct inode *ip;
+	register struct file *fp;
+	int i;
+
+#ifdef notdef
+	if ((mode&(FREAD|FWRITE)) == 0) {
+		u.u_error = EINVAL;
+		return;
+	}
+#endif
+	if (mode&FCREAT) {
+		ip = namei(uchar, CREATE, 1);
+		if (ip == NULL) {
+			if (u.u_error)
+				return;
+			ip = maknode(arg&07777&(~ISVTX));
+			if (ip == NULL)
+				return;
+			mode &= ~FTRUNC;
+		} else {
+			if (mode&FEXCL) {
+				u.u_error = EEXIST;
+				iput(ip);
+				return;
+			}
+			mode &= ~FCREAT;
+		}
+	} else {
+		ip = namei(uchar, LOOKUP, 1);
+		if (ip == NULL)
+			return;
+	}
+	if ((ip->i_mode & IFMT) == IFSOCK) {
+		u.u_error = EOPNOTSUPP;
+		goto bad;
+	}
+	if ((mode&FCREAT) == 0) {
+		if (mode&FREAD)
+			if (access(ip, IREAD))
+				goto bad;
+		if (mode&FWRITE) {
+			if (access(ip, IWRITE))
+				goto bad;
+			if ((ip->i_mode&IFMT) == IFDIR) {
+				u.u_error = EISDIR;
+				goto bad;
+			}
+		}
+	}
+	fp = falloc();
+	if (fp == NULL)
+		goto bad;
+	if (mode&FTRUNC)
+		itrunc(ip, (u_long)0);
+	iunlock(ip);
+	fp->f_flag = mode&FMASK;
+	fp->f_type = DTYPE_INODE;
+	fp->f_ops = &inodeops;
+	fp->f_data = (caddr_t)ip;
+	i = u.u_r.r_val1;
+#ifdef notdef
+	if (setjmp(&u.u_qsave)) {
+		if (u.u_error == 0)
+			u.u_error = EINTR;
+		u.u_ofile[i] = NULL;
+		closef(fp);
+		return;
+	}
+#endif
+	u.u_error = openi(ip, mode);
+	if (u.u_error == 0)
 		return;
-	stat1(ip, uap->sb, (off_t)0);
+	u.u_ofile[i] = NULL;
+	fp->f_count--;
+	irele(ip);
+	return;
+bad:
 	iput(ip);
 }
 
 /*
- * The basic routine for fstat and stat:
- * get the inode and pass appropriate parts back.
+ * Mknod system call
  */
-stat1(ip, ub)
-	register struct inode *ip;
-	struct stat *ub;
+mknod()
 {
-	register struct dinode *dp;
-	register struct buf *bp;
-	struct stat ds;
+	register struct inode *ip;
+	register struct a {
+		char	*fname;
+		int	fmode;
+		int	dev;
+	} *uap;
 
-	IUPDAT(ip, &time, &time, 0);
-	/*
-	 * First copy from inode table
-	 */
-	ds.st_dev = ip->i_dev;
-	ds.st_ino = ip->i_number;
-	ds.st_mode = ip->i_mode;
-	ds.st_nlink = ip->i_nlink;
-	ds.st_uid = ip->i_uid;
-	ds.st_gid = ip->i_gid;
-	ds.st_rdev = (dev_t)ip->i_un.i_rdev;
-	ds.st_size = ip->i_size;
-	/*
-	 * next the dates in the disk
-	 */
-	bp = bread(ip->i_dev, itod(ip->i_number));
-	dp = bp->b_un.b_dino;
-	dp += itoo(ip->i_number);
-	ds.st_atime = dp->di_atime;
-	ds.st_mtime = dp->di_mtime;
-	ds.st_ctime = dp->di_ctime;
-	brelse(bp);
-	if (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0)
-		u.u_error = EFAULT;
+	uap = (struct a *)u.u_ap;
+	if (!suser())
+		return;
+	ip = namei(uchar, CREATE, 0);
+	if (ip != NULL) {
+		u.u_error = EEXIST;
+		goto out;
+	}
+	if (u.u_error)
+		return;
+	ip = maknode(uap->fmode);
+	if (ip == NULL)
+		return;
+	switch (ip->i_mode & IFMT) {
+
+	case IFCHR:
+	case IFBLK:
+		if (uap->dev) {
+			/*
+			 * Want to be able to use this to make badblock
+			 * inodes, so don't truncate the dev number.
+			 */
+			ip->i_rdev = uap->dev;
+			ip->i_flag |= IACC|IUPD|ICHG;
+		}
+	}
+
+out:
+	iput(ip);
 }
 
 /*
- * Return target name of a symbolic link
+ * link system call
  */
-readlink()
+link()
 {
-	register struct inode *ip;
+	register struct inode *ip, *xp;
 	register struct a {
-		char	*name;
-		char	*buf;
-		int	count;
+		char	*target;
+		char	*linkname;
 	} *uap;
 
-	ip = namei(uchar, 0, 0);
+	uap = (struct a *)u.u_ap;
+	ip = namei(uchar, LOOKUP, 1); /* well, this routine is doomed anyhow */
 	if (ip == NULL)
 		return;
-	if ((ip->i_mode&IFMT) != IFLNK) {
-		u.u_error = ENXIO;
+	if ((ip->i_mode&IFMT) == IFDIR && !suser()) {
+		iput(ip);
+		return;
+	}
+	ip->i_nlink++;
+	ip->i_flag |= ICHG;
+	iupdat(ip, &time, &time, 1);
+	iunlock(ip);
+	u.u_dirp = (caddr_t)uap->linkname;
+	xp = namei(uchar, CREATE, 0);
+	if (xp != NULL) {
+		u.u_error = EEXIST;
+		iput(xp);
 		goto out;
 	}
-	uap = (struct a *)u.u_ap;
-	u.u_offset = 0;
-	u.u_base = uap->buf;
-	u.u_count = uap->count;
-	u.u_segflg = 0;
-	readi(ip);
+	if (u.u_error)
+		goto out;
+	if (u.u_pdir->i_dev != ip->i_dev) {
+		iput(u.u_pdir);
+		u.u_error = EXDEV;
+		goto out;
+	}
+	u.u_error = direnter(ip);
 out:
-	iput(ip);
-	u.u_r.r_val1 = uap->count - u.u_count;
+	if (u.u_error) {
+		ip->i_nlink--;
+		ip->i_flag |= ICHG;
+	}
+	irele(ip);
 }
 
 /*
@@ -169,208 +300,1032 @@ symlink()
 		nc++;
 	}
 	u.u_dirp = uap->linkname;
-	ip = namei(uchar, 1, 0);
+	ip = namei(uchar, CREATE, 0);
 	if (ip) {
 		iput(ip);
 		u.u_error = EEXIST;
 		return;
 	}
+	if (u.u_error)
+		return;
 	ip = maknode(IFLNK | 0777);
 	if (ip == NULL)
 		return;
-	u.u_base = uap->target;
-	u.u_count = nc;
-	u.u_offset = 0;
-	u.u_segflg = 0;
-	writei(ip);
+	u.u_error = rdwri(UIO_WRITE, ip, uap->target, nc, 0, 0, (int *)0);
+	/* handle u.u_error != 0 */
 	iput(ip);
 }
 
 /*
- * the dup system call.
+ * Unlink system call.
+ * Hard to avoid races here, especially
+ * in unlinking directories.
  */
-dup()
+unlink()
+{
+	struct a {
+		char	*fname;
+	};
+	register struct inode *ip, *dp;
+
+	ip = namei(uchar, DELETE | LOCKPARENT, 0);
+	if (ip == NULL)
+		return;
+	dp = u.u_pdir;
+	if ((ip->i_mode&IFMT) == IFDIR && !suser())
+		goto out;
+	/*
+	 * Don't unlink a mounted file.
+	 */
+	if (ip->i_dev != dp->i_dev) {
+		u.u_error = EBUSY;
+		goto out;
+	}
+	if (ip->i_flag&ITEXT)
+		xrele(ip);	/* try once to free text */
+	if (dirremove()) {
+		ip->i_nlink--;
+		ip->i_flag |= ICHG;
+	}
+out:
+	if (dp == ip)
+		irele(ip);
+	else
+		iput(ip);
+	iput(dp);
+}
+
+/*
+ * Seek system call
+ */
+lseek()
 {
 	register struct file *fp;
 	register struct a {
-		int	fdes;
-		int	fdes2;
+		int	fd;
+		off_t	off;
+		int	sbase;
 	} *uap;
-	register i, m;
 
 	uap = (struct a *)u.u_ap;
-	m = uap->fdes & ~077;
-	uap->fdes &= 077;
-	fp = getf(uap->fdes);
+	fp = getinode(uap->fd);
 	if (fp == NULL)
 		return;
-	if ((m&0100) == 0) {
-		if ((i = ufalloc()) < 0)
-			return;
-	} else {
-		i = uap->fdes2;
-		if (i<0 || i>=NOFILE) {
-			u.u_error = EBADF;
-			return;
-		}
-		u.u_r.r_val1 = i;
-	}
-	if (i != uap->fdes) {
-		if (u.u_ofile[i]!=NULL)
-			closef(u.u_ofile[i], 0);
-		if (u.u_error)
-			return;
-		u.u_ofile[i] = fp;
-		fp->f_count++;
+	if (uap->sbase == L_INCR)
+		uap->off += fp->f_offset;
+	else if (uap->sbase == L_XTND)
+		uap->off += ((struct inode *)fp->f_data)->i_size;
+	fp->f_offset = uap->off;
+	u.u_r.r_off = uap->off;
+}
+
+/*
+ * Access system call
+ */
+saccess()
+{
+	register svuid, svgid;
+	register struct inode *ip;
+	register struct a {
+		char	*fname;
+		int	fmode;
+	} *uap;
+
+	uap = (struct a *)u.u_ap;
+	svuid = u.u_uid;
+	svgid = u.u_gid;
+	u.u_uid = u.u_ruid;
+	u.u_gid = u.u_rgid;
+	ip = namei(uchar, LOOKUP, 1);
+	if (ip != NULL) {
+		if ((uap->fmode&R_OK) && access(ip, IREAD))
+			goto done;
+		if ((uap->fmode&W_OK) && access(ip, IWRITE))
+			goto done;
+		if ((uap->fmode&X_OK) && access(ip, IEXEC))
+			goto done;
+done:
+		iput(ip);
 	}
+	u.u_uid = svuid;
+	u.u_gid = svgid;
 }
 
 /*
- * Mount system call.
+ * Stat system call.  This version follows links.
  */
-smount()
+stat()
+{
+
+	stat1(1);
+}
+
+/*
+ * Lstat system call.  This version does not follow links.
+ */
+lstat()
+{
+
+	stat1(0);
+}
+
+stat1(follow)
+	int follow;
 {
-	dev_t dev;
 	register struct inode *ip;
-	register struct mount *mp;
-	struct mount *smp;
-	register struct filsys *fp;
-	struct buf *bp;
 	register struct a {
-		char	*fspec;
-		char	*freg;
-		int	ronly;
+		char	*fname;
+		struct stat *ub;
 	} *uap;
-	register char *cp;
+	struct stat sb;
 
 	uap = (struct a *)u.u_ap;
-	dev = getmdev();
-	if (u.u_error)
+	ip = namei(uchar, LOOKUP, follow);
+	if (ip == NULL)
 		return;
-	u.u_dirp = (caddr_t)uap->freg;
-	ip = namei(uchar, 0, 1);
+	(void) statinode(ip, &sb);
+	iput(ip);
+	u.u_error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+}
+
+/*
+ * Return target name of a symbolic link
+ */
+readlink()
+{
+	register struct inode *ip;
+	register struct a {
+		char	*name;
+		char	*buf;
+		int	count;
+	} *uap = (struct a *)u.u_ap;
+	int resid;
+
+	ip = namei(uchar, LOOKUP, 0);
 	if (ip == NULL)
 		return;
-	if (ip->i_count!=1 || (ip->i_mode&IFMT) != IFDIR)
-		goto out;
-	smp = NULL;
-	for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++) {
-		if (mp->m_bufp != NULL) {
-			if (dev == mp->m_dev)
-				goto out;
-		} else
-		if (smp == NULL)
-			smp = mp;
-	}
-	mp = smp;
-	if (mp == NULL)
-		goto out;
-	(*bdevsw[major(dev)].d_open)(dev, !uap->ronly);
-	if (u.u_error)
+	if ((ip->i_mode&IFMT) != IFLNK) {
+		u.u_error = ENXIO;
 		goto out;
-	bp = bread(dev, SUPERB);
-	if (u.u_error) {
-		brelse(bp);
-		goto out1;
-	}
-	mp->m_inodp = ip;
-	mp->m_dev = dev;
-	bp->b_flags |= B_LOCKED;
-	mp->m_bufp = bp;
-	fp = bp->b_un.b_filsys;
-	fp->s_ilock = 0;
-	fp->s_flock = 0;
-	fp->s_ronly = uap->ronly & 1;
-	fp->s_nbehind = 0;
-	fp->s_lasti = 1;
-	u.u_dirp = uap->freg;
-	for (cp = fp->s_fsmnt; cp < &fp->s_fsmnt[sizeof (fp->s_fsmnt) - 1]; )
-		if ((*cp++ = uchar()) == 0)
-			u.u_dirp--;		/* get 0 again */
-	*cp = 0;
-	brelse(bp);
-	ip->i_flag |= IMOUNT;
-	irele(ip);
-	return;
-
+	}
+	u.u_error = rdwri(UIO_READ, ip, uap->buf, uap->count, 0, 0, &resid);
 out:
-	u.u_error = EBUSY;
-out1:
 	iput(ip);
+	u.u_r.r_val1 = uap->count - resid;
+}
+
+/*
+ * Change mode of a file given path name.
+ */
+chmod()
+{
+	struct inode *ip;
+	struct a {
+		char	*fname;
+		int	fmode;
+	} *uap;
+
+	uap = (struct a *)u.u_ap;
+	if ((ip = owner(1)) == NULL)
+		return;
+	chmod1(ip, uap->fmode);
+	iput(ip);
+}
+
+/*
+ * Change mode of a file given a file descriptor.
+ */
+fchmod()
+{
+	struct a {
+		int	fd;
+		int	fmode;
+	} *uap;
+	register struct inode *ip;
+	register struct file *fp;
+
+	uap = (struct a *)u.u_ap;
+	fp = getinode(uap->fd);
+	if (fp == NULL)
+		return;
+	ip = (struct inode *)fp->f_data;
+	if (u.u_uid != ip->i_uid && !suser())
+		return;
+	ilock(ip);
+	chmod1(ip, uap->fmode);
+	iunlock(ip);
+}
+
+/*
+ * Change the mode on a file.
+ * Inode must be locked before calling.
+ */
+chmod1(ip, mode)
+	register struct inode *ip;
+	register int mode;
+{
+
+	ip->i_mode &= ~07777;
+	if (u.u_uid) {
+		mode &= ~ISVTX;
+		if (!groupmember(ip->i_gid))
+			mode &= ~ISGID;
+	}
+	ip->i_mode |= mode&07777;
+	ip->i_flag |= ICHG;
+	if (ip->i_flag&ITEXT && (ip->i_mode&ISVTX)==0)
+		xrele(ip);
+}
+
+/*
+ * Set ownership given a path name.
+ */
+chown()
+{
+	struct inode *ip;
+	struct a {
+		char	*fname;
+		int	uid;
+		int	gid;
+	} *uap;
+
+	uap = (struct a *)u.u_ap;
+	if (!suser() || (ip = owner(0)) == NULL)
+		return;
+	u.u_error = chown1(ip, uap->uid, uap->gid);
+	iput(ip);
+}
+
+/*
+ * Set ownership given a file descriptor.
+ */
+fchown()
+{
+	struct a {
+		int	fd;
+		int	uid;
+		int	gid;
+	} *uap;
+	register struct inode *ip;
+	register struct file *fp;
+
+	uap = (struct a *)u.u_ap;
+	fp = getinode(uap->fd);
+	if (fp == NULL)
+		return;
+	ip = (struct inode *)fp->f_data;
+	if (!suser())
+		return;
+	ilock(ip);
+	u.u_error = chown1(ip, uap->uid, uap->gid);
+	iunlock(ip);
+}
+
+/*
+ * Perform chown operation on inode ip;
+ * inode must be locked prior to call.
+ */
+chown1(ip, uid, gid)
+	register struct inode *ip;
+	int uid, gid;
+{
+#ifdef QUOTA
+	register long change;
+#endif
+
+	if (uid == -1)
+		uid = ip->i_uid;
+	if (gid == -1)
+		gid = 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);
+#endif
+	ip->i_uid = uid;
+	ip->i_gid = gid;
+	ip->i_flag |= ICHG;
+	if (u.u_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, 1);
+	return (u.u_error);		/* should == 0 ALWAYS !! */
+#else
+	return (0);
+#endif
 }
 
+#ifndef NOCOMPAT
 /*
- * the umount system call.
+ * Set IUPD and IACC times on file.
+ * Can't set ICHG.
  */
-sumount()
+outime()
 {
-	dev_t dev;
+	register struct a {
+		char	*fname;
+		time_t	*tptr;
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip;
-	register struct mount *mp;
-	struct buf *bp;
-	int stillopen, flag;
+	time_t tv[2];
+	struct timeval tv0, tv1;
+
+	if ((ip = owner(1)) == NULL)
+		return;
+	u.u_error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
+	if (u.u_error == 0) {
+		ip->i_flag |= IACC|IUPD|ICHG;
+		tv0.tv_sec = tv[0]; tv0.tv_usec = 0;
+		tv1.tv_sec = tv[1]; tv1.tv_usec = 0;
+		iupdat(ip, &tv0, &tv1, 0);
+	}
+	iput(ip);
+}
+#endif
+
+utimes()
+{
 	register struct a {
-		char	*fspec;
-	};
+		char	*fname;
+		struct	timeval *tptr;
+	} *uap = (struct a *)u.u_ap;
+	register struct inode *ip;
+	struct timeval tv[2];
 
-	dev = getmdev();
-	if (u.u_error)
+	if ((ip = owner(1)) == NULL)
 		return;
-	xumount(dev);	/* remove unused sticky files from text table */
-	update(0);
-	for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++)
-		if (mp->m_bufp != NULL && dev == mp->m_dev)
-			goto found;
-	u.u_error = EINVAL;
-	return;
+	u.u_error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
+	if (u.u_error == 0) {
+		ip->i_flag |= IACC|IUPD|ICHG;
+		iupdat(ip, &tv[0], &tv[1], 0);
+	}
+	iput(ip);
+}
+
+/*
+ * Flush any pending I/O.
+ */
+sync()
+{
+
+	update();
+}
+
+/*
+ * Apply an advisory lock on a file descriptor.
+ */
+flock()
+{
+	register struct a {
+		int	fd;
+		int	how;
+	} *uap = (struct a *)u.u_ap;
+	register struct file *fp;
+	register int cmd, flags;
 
-found:
-	stillopen = 0;
-	for (ip = inode; ip < inodeNINODE; ip++)
-		if (ip->i_number != 0 && dev == ip->i_dev) {
-			u.u_error = EBUSY;
+	fp = getinode(uap->fd);
+	if (fp == NULL)
+		return;
+	cmd = uap->how;
+	flags = u.u_pofile[uap->fd] & (UF_SHLOCK|UF_EXLOCK);
+	if (cmd&LOCK_UN) {
+		if (flags == 0) {
+			u.u_error = EINVAL;
 			return;
-		} else if (ip->i_number != 0 && (ip->i_mode&IFMT) == IFBLK &&
-		    ip->i_un.i_rdev == dev)
-			stillopen++;
-	ip = mp->m_inodp;
-	ip->i_flag &= ~IMOUNT;
-	ilock(ip);
+		}
+		funlocki((struct inode *)fp->f_data, flags);
+		u.u_pofile[uap->fd] &= ~(UF_SHLOCK|UF_EXLOCK);
+		return;
+	}
+	/*
+	 * No reason to write lock a file we've already
+	 * write locked, similarly with a read lock.
+	 */
+	if ((flags&UF_EXLOCK) && (cmd&LOCK_EX) ||
+	    (flags&UF_SHLOCK) && (cmd&LOCK_SH))
+		return;
+	u.u_pofile[uap->fd] =
+	    flocki((struct inode *)fp->f_data, u.u_pofile[uap->fd], cmd);
+}
+
+/*
+ * Truncate a file given its path name.
+ */
+truncate()
+{
+	struct a {
+		char	*fname;
+		u_long	length;
+	} *uap = (struct a *)u.u_ap;
+	struct inode *ip;
+
+	ip = namei(uchar, LOOKUP, 1);
+	if (ip == NULL)
+		return;
+	if (access(ip, IWRITE))
+		goto bad;
+	if ((ip->i_mode&IFMT) == IFDIR) {
+		u.u_error = EISDIR;
+		goto bad;
+	}
+	itrunc(ip, uap->length);
+bad:
 	iput(ip);
-	if ((bp = getblk(dev, SUPERB)) != mp->m_bufp)
-		panic("umount");
-	bp->b_flags &= ~B_LOCKED;
-	flag = !bp->b_un.b_filsys->s_ronly;
-	mp->m_bufp = NULL;
-	brelse(bp);
-	mpurge(mp - &mount[0]);
-	if (!stillopen) {
-		(*bdevsw[major(dev)].d_close)(dev, flag);
-		binval(dev);
+}
+
+/*
+ * Truncate a file given a file descriptor.
+ */
+ftruncate()
+{
+	struct a {
+		int	fd;
+		u_long	length;
+	} *uap = (struct a *)u.u_ap;
+	struct inode *ip;
+	struct file *fp;
+
+	fp = getinode(uap->fd);
+	if (fp == NULL)
+		return;
+	if ((fp->f_flag&FWRITE) == 0) {
+		u.u_error = EINVAL;
+		return;
 	}
+	ip = (struct inode *)fp->f_data;
+	ilock(ip);
+	itrunc(ip, uap->length);
+	iunlock(ip);
 }
 
 /*
- * Common code for mount and umount.
- * Check that the user's argument is a reasonable
- * thing on which to mount, and return the device number if so.
+ * Synch an open file.
  */
-dev_t
-getmdev()
+fsync()
+{
+	struct a {
+		int	fd;
+	} *uap = (struct a *)u.u_ap;
+	struct inode *ip;
+	struct file *fp;
+
+	fp = getinode(uap->fd);
+	if (fp == NULL)
+		return;
+	ip = (struct inode *)fp->f_data;
+	ilock(ip);
+	syncip(ip);
+	iunlock(ip);
+}
+
+/*
+ * Rename system call.
+ * 	rename("foo", "bar");
+ * is essentially
+ *	unlink("bar");
+ *	link("foo", "bar");
+ *	unlink("foo");
+ * but ``atomically''.  Can't do full commit without saving state in the
+ * inode on disk which isn't feasible at this time.  Best we can do is
+ * always guarantee the target exists.
+ *
+ * Basic algorithm is:
+ *
+ * 1) Bump link count on source while we're linking it to the
+ *    target.  This also insure the inode won't be deleted out
+ *    from underneath us while we work.
+ * 2) Link source to destination.  If destination already exists,
+ *    delete it first.
+ * 3) Unlink source reference to inode if still around.
+ * 4) If a directory was moved and the parent of the destination
+ *    is different from the source, patch the ".." entry in the
+ *    directory.
+ *
+ * Source and destination must either both be directories, or both
+ * not be directories.  If target is a directory, it must be empty.
+ */
+rename()
+{
+	struct a {
+		char	*from;
+		char	*to;
+	} *uap;
+	register struct inode *ip, *xp, *dp;
+	int oldparent, parentdifferent, doingdirectory;
+	int error = 0;
+
+	uap = (struct a *)u.u_ap;
+	ip = namei(uchar, DELETE | LOCKPARENT, 0);
+	if (ip == NULL)
+		return;
+	dp = u.u_pdir;
+	oldparent = 0, doingdirectory = 0;
+	if ((ip->i_mode&IFMT) == IFDIR) {
+		register struct direct *d;
+
+		d = &u.u_dent;
+		/*
+		 * Avoid ".", "..", and aliases of "." for obvious reasons.
+		 */
+		if ((d->d_namlen == 1 && d->d_name[0] == '.') ||
+		    (d->d_namlen == 2 && bcmp(d->d_name, "..", 2) == 0) ||
+		    (dp == ip)) {
+			iput(dp);
+			if (dp == ip)
+				irele(ip);
+			else
+				iput(ip);
+			u.u_error = EINVAL;
+			return;
+		}
+		oldparent = dp->i_number;
+		doingdirectory++;
+	}
+	iput(dp);
+
+	/*
+	 * 1) Bump link count while we're moving stuff
+	 *    around.  If we crash somewhere before
+	 *    completing our work, the link count
+	 *    may be wrong, but correctable.
+	 */
+	ip->i_nlink++;
+	ip->i_flag |= ICHG;
+	iupdat(ip, &time, &time, 1);
+	iunlock(ip);
+
+	/*
+	 * When the target exists, both the directory
+	 * and target inodes are returned locked.
+	 */
+	u.u_dirp = (caddr_t)uap->to;
+	xp = namei(uchar, CREATE | LOCKPARENT, 0);
+	if (u.u_error) {
+		error = u.u_error;
+		goto out;
+	}
+	dp = u.u_pdir;
+	/*
+	 * If ".." must be changed (ie the directory gets a new
+	 * parent) then the user must have write permission.
+	 */
+	parentdifferent = oldparent != dp->i_number;
+	if (doingdirectory && parentdifferent && access(ip, IWRITE))
+		goto bad;
+	/*
+	 * 2) If target doesn't exist, link the target
+	 *    to the source and unlink the source. 
+	 *    Otherwise, rewrite the target directory
+	 *    entry to reference the source inode and
+	 *    expunge the original entry's existence.
+	 */
+	if (xp == NULL) {
+		if (dp->i_dev != ip->i_dev) {
+			error = EXDEV;
+			goto bad;
+		}
+		/*
+		 * Disallow rename(foo, foo/bar).
+		 */
+		if (dp->i_number == ip->i_number) {
+			error = EEXIST;
+			goto bad;
+		}
+		/*
+		 * Account for ".." in directory.
+		 * When source and destination have the
+		 * same parent we don't fool with the
+		 * link count -- this isn't required
+		 * because we do a similar check below.
+		 */
+		if (doingdirectory && parentdifferent) {
+			dp->i_nlink++;
+			dp->i_flag |= ICHG;
+			iupdat(dp, &time, &time, 1);
+		}
+		error = direnter(ip);
+		if (error)
+			goto out;
+	} else {
+		if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) {
+			error = EXDEV;
+			goto bad;
+		}
+		/*
+		 * Short circuit rename(foo, foo).
+		 */
+		if (xp->i_number == ip->i_number)
+			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).
+		 */
+		if ((xp->i_mode&IFMT) == IFDIR) {
+			if (!dirempty(xp) || xp->i_nlink > 2) {
+				error = ENOTEMPTY;
+				goto bad;
+			}
+			if (!doingdirectory) {
+				error = ENOTDIR;
+				goto bad;
+			}
+		} else if (doingdirectory) {
+			error = EISDIR;
+			goto bad;
+		}
+		dirrewrite(dp, ip);
+		if (u.u_error) {
+			error = u.u_error;
+			goto bad1;
+		}
+		/*
+		 * Adjust the link count of the target to
+		 * reflect the dirrewrite above.  If this is
+		 * a directory it is empty and there are
+		 * no links to it, so we can squash the inode and
+		 * any space associated with it.  We disallowed
+		 * renaming over top of a directory with links to
+		 * it above, as we've no way to determine if
+		 * we've got a link or the directory itself, and
+		 * if we get a link, then ".." will be screwed up.
+		 */
+		xp->i_nlink--;
+		if (doingdirectory) {
+			if (--xp->i_nlink != 0)
+				panic("rename: linked directory");
+			itrunc(xp, (u_long)0);
+		}
+		xp->i_flag |= ICHG;
+		iput(xp);
+		xp = NULL;
+	}
+
+	/*
+	 * 3) Unlink the source.
+	 */
+	u.u_dirp = uap->from;
+	dp = namei(uchar, DELETE, 0);
+	/*
+	 * Insure directory entry still exists and
+	 * has not changed since the start of all
+	 * this.  If either has occured, forget about
+	 * about deleting the original entry and just
+	 * adjust the link count in the inode.
+	 */
+	if (dp == NULL || u.u_dent.d_ino != ip->i_number) {
+		ip->i_nlink--;
+		ip->i_flag |= ICHG;
+	} else {
+		/*
+		 * If source is a directory, must adjust
+		 * link count of parent directory also.
+		 * If target didn't exist and source and
+		 * target have the same parent, then we
+		 * needn't touch the link count, it all
+		 * balances out in the end.  Otherwise, we
+		 * must do so to reflect deletion of ".."
+		 * done above.
+		 */
+		if (doingdirectory && (xp != NULL || parentdifferent)) {
+			dp->i_nlink--;
+			dp->i_flag |= ICHG;
+		}
+		if (dirremove()) {
+			ip->i_nlink--;
+			ip->i_flag |= ICHG;
+		}
+		if (error == 0)		/* conservative */
+			error = u.u_error;
+	}
+	irele(ip);
+	if (dp)
+		iput(dp);
+
+	/*
+	 * 4) Renaming a directory with the parent
+	 *    different requires ".." to be rewritten.
+	 *    The window is still there for ".." to
+	 *    be inconsistent, but this is unavoidable,
+	 *    and a lot shorter than when it was done
+	 *    in a user process.
+	 */
+	if (doingdirectory && parentdifferent && error == 0) {
+		struct dirtemplate dirbuf;
+
+		u.u_dirp = uap->to;
+		ip = namei(uchar, LOOKUP | LOCKPARENT, 0);
+		if (ip == NULL) {
+			printf("rename: .. went away\n");
+			return;
+		}
+		dp = u.u_pdir;
+		if ((ip->i_mode&IFMT) != IFDIR) {
+			printf("rename: .. not a directory\n");
+			goto stuck;
+		}
+		error = rdwri(UIO_READ, ip, (caddr_t)&dirbuf,
+			sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
+		if (error == 0) {
+			dirbuf.dotdot_ino = dp->i_number;
+			(void) rdwri(UIO_WRITE, ip, (caddr_t)&dirbuf,
+			  sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
+		}
+stuck:
+		irele(dp);
+		iput(ip);
+	}
+	goto done;
+
+bad:
+	iput(dp);
+bad1:
+	if (xp)
+		iput(xp);
+out:
+	ip->i_nlink--;
+	ip->i_flag |= ICHG;
+	irele(ip);
+done:
+	if (error)
+		u.u_error = error;
+}
+
+/*
+ * Make a new file.
+ */
+struct inode *
+maknode(mode)
+	int mode;
 {
-	dev_t dev;
 	register struct inode *ip;
+	ino_t ipref;
 
-	if (!suser())
-		return(NODEV);
-	ip = namei(uchar, 0, 1);
+	if ((mode & IFMT) == IFDIR)
+		ipref = dirpref(u.u_pdir->i_fs);
+	else
+		ipref = u.u_pdir->i_number;
+	ip = ialloc(u.u_pdir, ipref, mode);
+	if (ip == NULL) {
+		iput(u.u_pdir);
+		return (NULL);
+	}
+#ifdef QUOTA
+	if (ip->i_dquot != NODQUOT)
+		panic("maknode: dquot");
+#endif
+	ip->i_flag |= IACC|IUPD|ICHG;
+	if ((mode & IFMT) == 0)
+		mode |= IFREG;
+	ip->i_mode = mode & ~u.u_cmask;
+	ip->i_nlink = 1;
+	ip->i_uid = u.u_uid;
+	ip->i_gid = u.u_pdir->i_gid;
+	if (ip->i_mode & ISGID && !groupmember(ip->i_gid))
+		ip->i_mode &= ~ISGID;
+#ifdef QUOTA
+	ip->i_dquot = inoquota(ip);
+#endif
+
+	/*
+	 * Make sure inode goes to disk before directory entry.
+	 */
+	iupdat(ip, &time, &time, 1);
+	u.u_error = direnter(ip);
+	if (u.u_error) {
+		/*
+		 * Write error occurred trying to update directory
+		 * so must deallocate the inode.
+		 */
+		ip->i_nlink = 0;
+		ip->i_flag |= ICHG;
+		iput(ip);
+		return (NULL);
+	}
+	return (ip);
+}
+
+/*
+ * A virgin directory (no blushing please).
+ */
+struct dirtemplate mastertemplate = {
+	0, 12, 1, ".",
+	0, DIRBLKSIZ - 12, 2, ".."
+};
+
+/*
+ * Mkdir system call
+ */
+mkdir()
+{
+	struct a {
+		char	*name;
+		int	dmode;
+	} *uap;
+	register struct inode *ip, *dp;
+	struct dirtemplate dirtemplate;
+
+	uap = (struct a *)u.u_ap;
+	ip = namei(uchar, CREATE, 0);
+	if (u.u_error)
+		return;
+	if (ip != NULL) {
+		iput(ip);
+		u.u_error = EEXIST;
+		return;
+	}
+	dp = u.u_pdir;
+	uap->dmode &= 0777;
+	uap->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.
+	 */
+	ip = ialloc(dp, dirpref(dp->i_fs), uap->dmode);
+	if (ip == NULL) {
+		iput(dp);
+		return;
+	}
+#ifdef QUOTA
+	if (ip->i_dquot != NODQUOT)
+		panic("mkdir: dquot");
+#endif
+	ip->i_flag |= IACC|IUPD|ICHG;
+	ip->i_mode = uap->dmode & ~u.u_cmask;
+	ip->i_nlink = 2;
+	ip->i_uid = u.u_uid;
+	ip->i_gid = dp->i_gid;
+#ifdef QUOTA
+	ip->i_dquot = inoquota(ip);
+#endif
+	iupdat(ip, &time, &time, 1);
+
+	/*
+	 * Bump link count in parent directory
+	 * to reflect work done below.  Should
+	 * be done before reference is created
+	 * so reparation is possible if we crash.
+	 */
+	dp->i_nlink++;
+	dp->i_flag |= ICHG;
+	iupdat(dp, &time, &time, 1);
+
+	/*
+	 * Initialize directory with "."
+	 * and ".." from static template.
+	 */
+	dirtemplate = mastertemplate;
+	dirtemplate.dot_ino = ip->i_number;
+	dirtemplate.dotdot_ino = dp->i_number;
+	u.u_error = rdwri(UIO_WRITE, ip, (caddr_t)&dirtemplate,
+		sizeof (dirtemplate), (off_t)0, 1, (int *)0);
+	if (u.u_error) {
+		dp->i_nlink--;
+		dp->i_flag |= ICHG;
+		goto bad;
+	}
+	/*
+	 * Directory all set up, now
+	 * install the entry for it in
+	 * the parent directory.
+	 */
+	u.u_error = direnter(ip);
+	dp = NULL;
+	if (u.u_error) {
+		u.u_dirp = uap->name;
+		dp = namei(uchar, LOOKUP, 0);
+		if (dp) {
+			dp->i_nlink--;
+			dp->i_flag |= ICHG;
+		}
+	}
+bad:
+	/*
+	 * No need to do an explicit itrunc here,
+	 * irele will do this for us because we set
+	 * the link count to 0.
+	 */
+	if (u.u_error) {
+		ip->i_nlink = 0;
+		ip->i_flag |= ICHG;
+	}
+	if (dp)
+		iput(dp);
+	iput(ip);
+}
+
+/*
+ * Rmdir system call.
+ */
+rmdir()
+{
+	struct a {
+		char	*name;
+	};
+	register struct inode *ip, *dp;
+
+	ip = namei(uchar, DELETE | LOCKPARENT, 0);
 	if (ip == NULL)
-		return(NODEV);
-	if ((ip->i_mode&IFMT) != IFBLK)
-		u.u_error = ENOTBLK;
-	dev = (dev_t)ip->i_un.i_rdev;
-	if (major(dev) >= nblkdev)
-		u.u_error = ENXIO;
+		return;
+	dp = u.u_pdir;
+	/*
+	 * No rmdir "." please.
+	 */
+	if (dp == ip) {
+		irele(dp);
+		iput(ip);
+		u.u_error = EINVAL;
+		return;
+	}
+	if ((ip->i_mode&IFMT) != IFDIR) {
+		u.u_error = ENOTDIR;
+		goto out;
+	}
+	/*
+	 * Don't remove a mounted on directory.
+	 */
+	if (ip->i_dev != dp->i_dev) {
+		u.u_error = EBUSY;
+		goto out;
+	}
+	/*
+	 * Verify the directory is empty (and valid).
+	 * (Rmdir ".." won't be valid since
+	 *  ".." will contain a reference to
+	 *  the current directory and thus be
+	 *  non-empty.)
+	 */
+	if (ip->i_nlink != 2 || !dirempty(ip)) {
+		u.u_error = ENOTEMPTY;
+		goto out;
+	}
+	/*
+	 * Delete reference to directory before purging
+	 * inode.  If we crash in between, the directory
+	 * will be reattached to lost+found,
+	 */
+	if (dirremove() == 0)
+		goto out;
+	dp->i_nlink--;
+	dp->i_flag |= ICHG;
+	iput(dp);
+	dp = NULL;
+	/*
+	 * Truncate inode.  The only stuff left
+	 * in the directory is "." and "..".  The
+	 * "." reference is inconsequential since
+	 * we're quashing it.  The ".." reference
+	 * has already been adjusted above.  We've
+	 * removed the "." reference and the reference
+	 * in the parent directory, but there may be
+	 * other hard links so decrement by 2 and
+	 * worry about them later.
+	 */
+	ip->i_nlink -= 2;
+	itrunc(ip, (u_long)0);
+out:
+	if (dp)
+		iput(dp);
 	iput(ip);
-	return(dev);
+}
+
+struct file *
+getinode(fdes)
+	int fdes;
+{
+	register struct file *fp;
+
+	fp = getf(fdes);
+	if (fp == 0)
+		return (0);
+	if (fp->f_type != DTYPE_INODE) {
+		u.u_error = EINVAL;
+		return (0);
+	}
+	return (fp);
+}
+
+/*
+ * mode mask for creation of files
+ */
+umask()
+{
+	register struct a {
+		int	mask;
+	} *uap;
+
+	uap = (struct a *)u.u_ap;
+	u.u_r.r_val1 = u.u_cmask;
+	u.u_cmask = uap->mask & 07777;
 }