X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/4f083fd7a06675f7d351f02e7d69eb5c7b9fcc8f..18b0bce61728e5c0943caa5386425644f81d9aec:/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 a81a284f0d..016a175485 100644
--- a/usr/src/sys/ufs/ffs/ufs_vnops.c
+++ b/usr/src/sys/ufs/ffs/ufs_vnops.c
@@ -1,22 +1,30 @@
-/*	ufs_vnops.c	4.42	82/11/13	*/
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/kernel.h"
-#include "../h/file.h"
-#include "../h/stat.h"
-#include "../h/inode.h"
-#include "../h/fs.h"
-#include "../h/buf.h"
-#include "../h/proc.h"
-#include "../h/quota.h"
-#include "../h/descrip.h"
-#include "../h/uio.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../h/nami.h"
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *	@(#)ufs_vnops.c	7.4 (Berkeley) %G%
+ */
+
+#include "param.h"
+#include "systm.h"
+#include "dir.h"
+#include "user.h"
+#include "kernel.h"
+#include "file.h"
+#include "stat.h"
+#include "inode.h"
+#include "fs.h"
+#include "buf.h"
+#include "proc.h"
+#include "quota.h"
+#include "uio.h"
+#include "socket.h"
+#include "socketvar.h"
+#include "mount.h"
+
+extern	struct fileops inodeops;
+struct	file *getinode();
 
 /*
  * Change current working directory (``.'').
@@ -46,9 +54,13 @@ chdirec(ipp)
 	register struct inode *ip;
 	struct a {
 		char	*fname;
-	};
+	} *uap = (struct a *)u.u_ap;
+	register struct nameidata *ndp = &u.u_nd;
 
-	ip = namei(uchar, LOOKUP, 1);
+	ndp->ni_nameiop = LOOKUP | FOLLOW;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
 	if (ip == NULL)
 		return;
 	if ((ip->i_mode&IFMT) != IFDIR) {
@@ -57,7 +69,7 @@ chdirec(ipp)
 	}
 	if (access(ip, IEXEC))
 		goto bad;
-	iunlock(ip);
+	IUNLOCK(ip);
 	if (*ipp)
 		irele(*ipp);
 	*ipp = ip;
@@ -72,80 +84,84 @@ bad:
  */
 open()
 {
-	register struct inode *ip;
-	register struct a {
+	struct a {
 		char	*fname;
-		int	flags;
 		int	mode;
-	} *uap;
-	int checkpermissions = 1, flags;
+		int	crtmode;
+	} *uap = (struct a *) u.u_ap;
 
-	uap = (struct a *)u.u_ap;
-	flags = uap->flags + 1;
-	if ((flags&FTRUNCATE) && (flags&FWRITE) == 0) {
-		u.u_error = EINVAL;
-		return;
-	}
-	if (flags&FCREATE) {
-		ip = namei(uchar, CREATE, 1);
-		if (ip == NULL) {
-			if (u.u_error)
-				return;
-			ip = maknode(uap->mode&07777&(~ISVTX));
-			checkpermissions = 0;
-			flags &= ~FTRUNCATE;
-		}
-	} else
-		ip = namei(uchar, LOOKUP, 1);
-	if (ip == NULL)
-		return;
-	open1(ip, flags, checkpermissions);
+	copen(uap->mode-FOPEN, uap->crtmode, uap->fname);
 }
 
-#ifndef NOCOMPAT
 /*
  * Creat system call.
  */
-ocreat()
+creat()
 {
-	register struct inode *ip;
-	register struct a {
+	struct a {
 		char	*fname;
 		int	fmode;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, CREATE, 1);
-	if (ip == NULL) {
-		if (u.u_error)
-			return;
-		ip = maknode(uap->fmode&07777&(~ISVTX));
-		if (ip == NULL)
-			return;
-		open1(ip, FWRITE, 0);
-	} else
-		open1(ip, FWRITE|FTRUNCATE, 1);
+	copen(FWRITE|FCREAT|FTRUNC, uap->fmode, uap->fname);
 }
-#endif
 
 /*
  * Common code for open and creat.
- * Check permissions (if we haven't done so already),
- * allocate an open file structure, and call
- * the device open routine, if any.
+ * Check permissions, allocate an open file structure,
+ * and call the device open routine if any.
  */
-open1(ip, mode, checkpermissions)
-	register struct inode *ip;
-	register mode;
+copen(mode, arg, fname)
+	register int mode;
+	int arg;
+	caddr_t fname;
 {
+	register struct inode *ip;
 	register struct file *fp;
-	int i, flags;
+	register struct nameidata *ndp = &u.u_nd;
+	int indx;
 
-	if (checkpermissions) {
+	fp = falloc();
+	if (fp == NULL)
+		return;
+	indx = u.u_r.r_val1;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = fname;
+	if (mode&FCREAT) {
+		if (mode & FEXCL)
+			ndp->ni_nameiop = CREATE;
+		else
+			ndp->ni_nameiop = CREATE | FOLLOW;
+		ip = namei(ndp);
+		if (ip == NULL) {
+			if (u.u_error)
+				goto bad1;
+			ip = maknode(arg&07777&(~ISVTX), ndp);
+			if (ip == NULL)
+				goto bad1;
+			mode &= ~FTRUNC;
+		} else {
+			if (mode&FEXCL) {
+				u.u_error = EEXIST;
+				goto bad;
+			}
+			mode &= ~FCREAT;
+		}
+	} else {
+		ndp->ni_nameiop = LOOKUP | FOLLOW;
+		ip = namei(ndp);
+		if (ip == NULL)
+			goto bad1;
+	}
+	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 (mode&(FWRITE|FTRUNC)) {
 			if (access(ip, IWRITE))
 				goto bad;
 			if ((ip->i_mode&IFMT) == IFDIR) {
@@ -154,40 +170,29 @@ open1(ip, mode, checkpermissions)
 			}
 		}
 	}
-
-	/*
-	 * Check locking on inode.  Release "inode lock"
-	 * while doing so in case we block inside flocki.
-	 */
-	flags = 0;
-	if (mode&(FSHLOCK|FEXLOCK)) {
-		iunlock(ip);
-		flags = flocki(ip, 0, mode);
-		ilock(ip);
-		if (u.u_error)
-			goto bad;
-	}
-	if (mode&FTRUNCATE)
+	if (mode&FTRUNC)
 		itrunc(ip, (u_long)0);
-	iunlock(ip);
-	if ((fp = falloc()) == NULL)
-		goto out;
-	fp->f_flag = mode & FMODES;
-	fp->f_type = DTYPE_FILE;
-	i = u.u_r.r_val1;
-	fp->f_inode = ip;
-	u.u_error = openi(ip, mode);
-	if (u.u_error == 0) {
-		u.u_pofile[i] = flags;
+	IUNLOCK(ip);
+	fp->f_flag = mode&FMASK;
+	fp->f_type = DTYPE_INODE;
+	fp->f_ops = &inodeops;
+	fp->f_data = (caddr_t)ip;
+	if (setjmp(&u.u_qsave)) {
+		if (u.u_error == 0)
+			u.u_error = EINTR;
+		u.u_ofile[indx] = NULL;
+		closef(fp);
 		return;
 	}
-	u.u_ofile[i] = NULL;
-	fp->f_count--;
-out:
-	irele(ip);
-	return;
+	u.u_error = openi(ip, mode);
+	if (u.u_error == 0)
+		return;
+	ILOCK(ip);
 bad:
 	iput(ip);
+bad1:
+	u.u_ofile[indx] = NULL;
+	fp->f_count--;
 }
 
 /*
@@ -200,28 +205,37 @@ mknod()
 		char	*fname;
 		int	fmode;
 		int	dev;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
+	register struct nameidata *ndp = &u.u_nd;
 
-	uap = (struct a *)u.u_ap;
-	if (suser()) {
-		ip = namei(uchar, CREATE, 0);
-		if (ip != NULL) {
-			u.u_error = EEXIST;
-			goto out;
-		}
+	if (!suser())
+		return;
+	ndp->ni_nameiop = CREATE;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
+	if (ip != NULL) {
+		u.u_error = EEXIST;
+		goto out;
 	}
 	if (u.u_error)
 		return;
-	ip = maknode(uap->fmode);
+	ip = maknode(uap->fmode, ndp);
 	if (ip == NULL)
 		return;
-	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;
+	switch (ip->i_mode & IFMT) {
+
+	case IFMT:	/* used by badsect to flag bad sectors */
+	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:
@@ -237,10 +251,13 @@ link()
 	register struct a {
 		char	*target;
 		char	*linkname;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
+	register struct nameidata *ndp = &u.u_nd;
 
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, LOOKUP, 1); /* well, this routine is doomed anyhow */
+	ndp->ni_nameiop = LOOKUP | FOLLOW;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->target;
+	ip = namei(ndp);	/* well, this routine is doomed anyhow */
 	if (ip == NULL)
 		return;
 	if ((ip->i_mode&IFMT) == IFDIR && !suser()) {
@@ -250,9 +267,11 @@ link()
 	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);
+	IUNLOCK(ip);
+	ndp->ni_nameiop = CREATE;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = (caddr_t)uap->linkname;
+	xp = namei(ndp);
 	if (xp != NULL) {
 		u.u_error = EEXIST;
 		iput(xp);
@@ -260,12 +279,12 @@ link()
 	}
 	if (u.u_error)
 		goto out;
-	if (u.u_pdir->i_dev != ip->i_dev) {
-		iput(u.u_pdir);
+	if (ndp->ni_pdir->i_dev != ip->i_dev) {
+		iput(ndp->ni_pdir);
 		u.u_error = EXDEV;
 		goto out;
 	}
-	direnter(ip);
+	u.u_error = direnter(ip, ndp);
 out:
 	if (u.u_error) {
 		ip->i_nlink--;
@@ -282,12 +301,12 @@ symlink()
 	register struct a {
 		char	*target;
 		char	*linkname;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip;
 	register char *tp;
 	register c, nc;
+	register struct nameidata *ndp = &u.u_nd;
 
-	uap = (struct a *)u.u_ap;
 	tp = uap->target;
 	nc = 0;
 	while (c = fubyte(tp)) {
@@ -298,8 +317,10 @@ symlink()
 		tp++;
 		nc++;
 	}
-	u.u_dirp = uap->linkname;
-	ip = namei(uchar, CREATE, 0);
+	ndp->ni_nameiop = CREATE;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->linkname;
+	ip = namei(ndp);
 	if (ip) {
 		iput(ip);
 		u.u_error = EEXIST;
@@ -307,10 +328,11 @@ symlink()
 	}
 	if (u.u_error)
 		return;
-	ip = maknode(IFLNK | 0777);
+	ip = maknode(IFLNK | 0777, ndp);
 	if (ip == NULL)
 		return;
-	u.u_error = rdwri(UIO_WRITE, ip, uap->target, nc, 0, 0, (int *)0);
+	u.u_error = rdwri(UIO_WRITE, ip, uap->target, nc, (off_t)0, 0,
+	    (int *)0);
 	/* handle u.u_error != 0 */
 	iput(ip);
 }
@@ -324,13 +346,17 @@ unlink()
 {
 	struct a {
 		char	*fname;
-	};
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip, *dp;
+	register struct nameidata *ndp = &u.u_nd;
 
-	ip = namei(uchar, DELETE | LOCKPARENT, 0);
+	ndp->ni_nameiop = DELETE | LOCKPARENT;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
 	if (ip == NULL)
 		return;
-	dp = u.u_pdir;
+	dp = ndp->ni_pdir;
 	if ((ip->i_mode&IFMT) == IFDIR && !suser())
 		goto out;
 	/*
@@ -342,7 +368,7 @@ unlink()
 	}
 	if (ip->i_flag&ITEXT)
 		xrele(ip);	/* try once to free text */
-	if (dirremove()) {
+	if (dirremove(ndp)) {
 		ip->i_nlink--;
 		ip->i_flag |= ICHG;
 	}
@@ -364,22 +390,32 @@ lseek()
 		int	fd;
 		off_t	off;
 		int	sbase;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 
-	uap = (struct a *)u.u_ap;
-	fp = getf(uap->fd);
-	if (fp == NULL)
-		return;
-	if (fp->f_type == DTYPE_SOCKET) {
+	GETF(fp, uap->fd);
+	if (fp->f_type != DTYPE_INODE) {
 		u.u_error = ESPIPE;
 		return;
 	}
-	if (uap->sbase == FSEEK_RELATIVE)
-		uap->off += fp->f_offset;
-	else if (uap->sbase == FSEEK_EOF)
-		uap->off += fp->f_inode->i_size;
-	fp->f_offset = uap->off;
-	u.u_r.r_off = uap->off;
+	switch (uap->sbase) {
+
+	case L_INCR:
+		fp->f_offset += uap->off;
+		break;
+
+	case L_XTND:
+		fp->f_offset = uap->off + ((struct inode *)fp->f_data)->i_size;
+		break;
+
+	case L_SET:
+		fp->f_offset = uap->off;
+		break;
+
+	default:
+		u.u_error = EINVAL;
+		return;
+	}
+	u.u_r.r_off = fp->f_offset;
 }
 
 /*
@@ -392,20 +428,23 @@ saccess()
 	register struct a {
 		char	*fname;
 		int	fmode;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
+	register struct nameidata *ndp = &u.u_nd;
 
-	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);
+	ndp->ni_nameiop = LOOKUP | FOLLOW;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
 	if (ip != NULL) {
-		if ((uap->fmode&FACCESS_READ) && access(ip, IREAD))
+		if ((uap->fmode&R_OK) && access(ip, IREAD))
 			goto done;
-		if ((uap->fmode&FACCESS_WRITE) && access(ip, IWRITE))
+		if ((uap->fmode&W_OK) && access(ip, IWRITE))
 			goto done;
-		if ((uap->fmode&FACCESS_EXECUTE) && access(ip, IEXEC))
+		if ((uap->fmode&X_OK) && access(ip, IEXEC))
 			goto done;
 done:
 		iput(ip);
@@ -414,99 +453,44 @@ done:
 	u.u_gid = svgid;
 }
 
-/*
- * the fstat system call.
- */
-fstat()
-{
-	register struct file *fp;
-	register struct a {
-		int	fd;
-		struct stat *sb;
-	} *uap;
-
-	uap = (struct a *)u.u_ap;
-	fp = getf(uap->fd);
-	if (fp == NULL)
-		return;
-	if (fp->f_type == DTYPE_SOCKET)
-		u.u_error = sostat(fp->f_socket, uap->sb);
-	else
-		stat1(fp->f_inode, uap->sb);
-}
-
 /*
  * Stat system call.  This version follows links.
  */
 stat()
 {
-	register struct inode *ip;
-	register struct a {
-		char	*fname;
-		struct stat *sb;
-	} *uap;
 
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, LOOKUP, 1);
-	if (ip == NULL)
-		return;
-	stat1(ip, uap->sb);
-	iput(ip);
+	stat1(FOLLOW);
 }
 
 /*
  * Lstat system call.  This version does not follow links.
  */
 lstat()
+{
+
+	stat1(NOFOLLOW);
+}
+
+stat1(follow)
+	int follow;
 {
 	register struct inode *ip;
 	register struct a {
 		char	*fname;
-		struct stat *sb;
-	} *uap;
+		struct stat *ub;
+	} *uap = (struct a *)u.u_ap;
+	struct stat sb;
+	register struct nameidata *ndp = &u.u_nd;
 
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, LOOKUP, 0);
+	ndp->ni_nameiop = LOOKUP | follow;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
 	if (ip == NULL)
 		return;
-	stat1(ip, uap->sb);
+	(void) ino_stat(ip, &sb);
 	iput(ip);
-}
-
-/*
- * The basic routine for fstat and stat:
- * get the inode and pass appropriate parts back.
- */
-stat1(ip, ub)
-	register struct inode *ip;
-	struct stat *ub;
-{
-	struct stat ds;
-
-	IUPDAT(ip, &time, &time, 0);
-	/*
-	 * 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_rdev;
-	ds.st_size = ip->i_size;
-	ds.st_atime = ip->i_atime;
-	ds.st_mtime = ip->i_mtime;
-	ds.st_ctime = ip->i_ctime;
-	/* this doesn't belong here */
-	if ((ip->i_mode&IFMT) == IFBLK)
-		ds.st_blksize = BLKDEV_IOSIZE;
-	else if ((ip->i_mode&IFMT) == IFCHR)
-		ds.st_blksize = MAXBSIZE;
-	else
-		ds.st_blksize = ip->i_fs->fs_bsize;
-	if (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0)
-		u.u_error = EFAULT;
+	u.u_error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
 }
 
 /*
@@ -520,16 +504,21 @@ readlink()
 		char	*buf;
 		int	count;
 	} *uap = (struct a *)u.u_ap;
+	register struct nameidata *ndp = &u.u_nd;
 	int resid;
 
-	ip = namei(uchar, LOOKUP, 0);
+	ndp->ni_nameiop = LOOKUP;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->name;
+	ip = namei(ndp);
 	if (ip == NULL)
 		return;
 	if ((ip->i_mode&IFMT) != IFLNK) {
-		u.u_error = ENXIO;
+		u.u_error = EINVAL;
 		goto out;
 	}
-	u.u_error = rdwri(UIO_READ, ip, uap->buf, uap->count, 0, 0, &resid);
+	u.u_error = rdwri(UIO_READ, ip, uap->buf, uap->count, (off_t)0, 0,
+	    &resid);
 out:
 	iput(ip);
 	u.u_r.r_val1 = uap->count - resid;
@@ -544,12 +533,11 @@ chmod()
 	struct a {
 		char	*fname;
 		int	fmode;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 
-	uap = (struct a *)u.u_ap;
-	if ((ip = owner(1)) == NULL)
+	if ((ip = owner(uap->fname, FOLLOW)) == NULL)
 		return;
-	chmod1(ip, uap->fmode);
+	u.u_error = chmod1(ip, uap->fmode);
 	iput(ip);
 }
 
@@ -561,24 +549,19 @@ fchmod()
 	struct a {
 		int	fd;
 		int	fmode;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip;
 	register struct file *fp;
 
-	uap = (struct a *)u.u_ap;
-	fp = getf(uap->fd);
+	fp = getinode(uap->fd);
 	if (fp == NULL)
 		return;
-	if (fp->f_type == DTYPE_SOCKET) {
-		u.u_error = EINVAL;
-		return;
-	}
-	ip = fp->f_inode;
+	ip = (struct inode *)fp->f_data;
 	if (u.u_uid != ip->i_uid && !suser())
 		return;
-	ilock(ip);
-	chmod1(ip, uap->fmode);
-	iunlock(ip);
+	ILOCK(ip);
+	u.u_error = chmod1(ip, uap->fmode);
+	IUNLOCK(ip);
 }
 
 /*
@@ -589,27 +572,21 @@ chmod1(ip, mode)
 	register struct inode *ip;
 	register int mode;
 {
-	register int *gp;
 
+	if (ip->i_fs->fs_ronly)
+		return (EROFS);
 	ip->i_mode &= ~07777;
 	if (u.u_uid) {
-		mode &= ~ISVTX;
-		for (gp = u.u_groups; gp < &u.u_groups[NGROUPS]; gp++)
-			if (*gp == ip->i_gid)
-				goto ok;
-		mode &= ~ISGID;
-ok:
-		;
-#ifdef MUSH
-		if (u.u_quota->q_syflags & QF_UMASK && u.u_uid != 0 &&
-		    (ip->i_mode & IFMT) != IFCHR)
-			mode &= ~u.u_cmask;
-#endif
+		if ((ip->i_mode & IFMT) != IFDIR)
+			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);
+	return (0);
 }
 
 /*
@@ -622,12 +599,16 @@ chown()
 		char	*fname;
 		int	uid;
 		int	gid;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
+	register struct nameidata *ndp = &u.u_nd;
 
-	uap = (struct a *)u.u_ap;
-	if (!suser() || (ip = owner(0)) == NULL)
+	ndp->ni_nameiop = LOOKUP | NOFOLLOW;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
+	if (ip == NULL)
 		return;
-	chown1(ip, uap->uid, uap->gid);
+	u.u_error = chown1(ip, uap->uid, uap->gid);
 	iput(ip);
 }
 
@@ -640,24 +621,17 @@ fchown()
 		int	fd;
 		int	uid;
 		int	gid;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip;
 	register struct file *fp;
 
-	uap = (struct a *)u.u_ap;
-	fp = getf(uap->fd);
+	fp = getinode(uap->fd);
 	if (fp == NULL)
 		return;
-	if (fp->f_type == DTYPE_SOCKET) {
-		u.u_error = EINVAL;
-		return;
-	}
-	ip = fp->f_inode;
-	if (!suser())
-		return;
-	ilock(ip);
-	chown1(ip, uap->uid, uap->gid);
-	iunlock(ip);
+	ip = (struct inode *)fp->f_data;
+	ILOCK(ip);
+	u.u_error = chown1(ip, uap->uid, uap->gid);
+	IUNLOCK(ip);
 }
 
 /*
@@ -670,77 +644,66 @@ chown1(ip, uid, gid)
 {
 #ifdef QUOTA
 	register long change;
+#endif
 
+	if (ip->i_fs->fs_ronly)
+		return (EROFS);
+	if (uid == -1)
+		uid = ip->i_uid;
+	if (gid == -1)
+		gid = ip->i_gid;
 	/*
-	 * This doesn't allow for holes in files (which hopefully don't
-	 * happen often in files that we chown), and is not accurate anyway
-	 * (eg: it totally ignores 3 level indir blk files - but hopefully
-	 * noone who can make a file that big will have a quota)
+	 * If we don't own the file, are trying to change the owner
+	 * of the file, or are not a member of the target group,
+	 * the caller must be superuser or the call fails.
 	 */
-	if (ip->i_uid == uid)
+	if ((u.u_uid != ip->i_uid || uid != ip->i_uid ||
+	    !groupmember((gid_t)gid)) && !suser())
+		return (u.u_error);
+#ifdef QUOTA
+	if (ip->i_uid == uid)		/* this just speeds things a little */
 		change = 0;
-	else {
-		register struct fs *fs = ip->i_fs;
-
-		if (ip->i_size > (change = NDADDR * fs->fs_bsize)) {
-			register off_t size;
-
-			size = blkroundup(fs, ip->i_size) - change;
-			change += size;
-			change += fs->fs_bsize;
-			/* this assumes NIADDR <= 2 */
-			if (size > NINDIR(fs) * fs->fs_bsize)
-				change += fs->fs_bsize;
-		} else
-			change = fragroundup(fs, ip->i_size);
-		change /= DEV_BSIZE;
-	}
-	(void)chkdq(ip, -change, 1);
-	(void)chkiq(ip->i_dev, ip, ip->i_uid, 1);
+	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
-	/*
-	 * keep uid/gid's in sane range -- no err,
-	 * so chown(file, uid, -1) will do something useful
-	 */
-	if (uid >= 0 && uid <= 32767)	/* should have a constant */
-		ip->i_uid = uid;
-	if (gid >= 0 && gid <= 32767)	/* same here */
-		ip->i_gid = gid;
+	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);
+	(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
+	return (0);
 #endif
 }
 
-/*
- * Set IUPD and IACC times on file.
- * Can't set ICHG.
- */
-outime()
+utimes()
 {
 	register struct a {
 		char	*fname;
-		time_t	*tptr;
-	} *uap;
+		struct	timeval *tptr;
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip;
-	time_t tv[2];
-	struct timeval tv0, tv1;
+	struct timeval tv[2];
 
-	uap = (struct a *)u.u_ap;
-	if ((ip = owner(1)) == NULL)
+	if ((ip = owner(uap->fname, FOLLOW)) == NULL)
 		return;
-	if (copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof(tv))) {
-		u.u_error = EFAULT;
-	} else {
+	if (ip->i_fs->fs_ronly) {
+		u.u_error = EROFS;
+		iput(ip);
+		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);
+		iupdat(ip, &tv[0], &tv[1], 0);
 	}
 	iput(ip);
 }
@@ -754,47 +717,6 @@ sync()
 	update();
 }
 
-/*
- * Apply an advisory lock on a file descriptor.
- */
-flock()
-{
-	struct a {
-		int	fd;
-		int	how;
-	} *uap;
-	register struct file *fp;
-	register int cmd, flags;
-
-	uap = (struct a *)u.u_ap;
-	fp = getf(uap->fd);
-	if (fp == NULL)
-		return;
-	if (fp->f_type == DTYPE_SOCKET) {		/* XXX */
-		u.u_error = EINVAL;
-		return;
-	}
-	cmd = uap->how;
-	flags = u.u_pofile[uap->fd] & (SHLOCK|EXLOCK);
-	if (cmd&FUNLOCK) {
-		if (flags == 0) {
-			u.u_error = EINVAL;
-			return;
-		}
-		funlocki(fp->f_inode, flags);
-		u.u_pofile[uap->fd] &= ~(SHLOCK|EXLOCK);
-		return;
-	}
-	/*
-	 * No reason to write lock a file we've already
-	 * write locked, similarly with a read lock.
-	 */
-	if ((flags&EXLOCK) && (cmd&FEXLOCK) ||
-	    (flags&SHLOCK) && (cmd&FSHLOCK))
-		return;
-	u.u_pofile[uap->fd] = flocki(fp->f_inode, u.u_pofile[uap->fd], cmd);
-}
-
 /*
  * Truncate a file given its path name.
  */
@@ -802,11 +724,15 @@ truncate()
 {
 	struct a {
 		char	*fname;
-		u_long	length;
+		off_t	length;
 	} *uap = (struct a *)u.u_ap;
 	struct inode *ip;
+	register struct nameidata *ndp = &u.u_nd;
 
-	ip = namei(uchar, LOOKUP, 1);
+	ndp->ni_nameiop = LOOKUP | FOLLOW;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->fname;
+	ip = namei(ndp);
 	if (ip == NULL)
 		return;
 	if (access(ip, IWRITE))
@@ -815,7 +741,7 @@ truncate()
 		u.u_error = EISDIR;
 		goto bad;
 	}
-	itrunc(ip, uap->length);
+	itrunc(ip, (u_long)uap->length);
 bad:
 	iput(ip);
 }
@@ -827,26 +753,22 @@ ftruncate()
 {
 	struct a {
 		int	fd;
-		u_long	length;
+		off_t	length;
 	} *uap = (struct a *)u.u_ap;
 	struct inode *ip;
 	struct file *fp;
 
-	fp = getf(uap->fd);
+	fp = getinode(uap->fd);
 	if (fp == NULL)
 		return;
-	if (fp->f_type == DTYPE_SOCKET) {
-		u.u_error = EINVAL;
-		return;
-	}
 	if ((fp->f_flag&FWRITE) == 0) {
 		u.u_error = EINVAL;
 		return;
 	}
-	ip = fp->f_inode;
-	ilock(ip);
-	itrunc(ip, uap->length);
-	iunlock(ip);
+	ip = (struct inode *)fp->f_data;
+	ILOCK(ip);
+	itrunc(ip, (u_long)uap->length);
+	IUNLOCK(ip);
 }
 
 /*
@@ -860,17 +782,15 @@ fsync()
 	struct inode *ip;
 	struct file *fp;
 
-	fp = getf(uap->fd);
+	fp = getinode(uap->fd);
 	if (fp == NULL)
 		return;
-	if (fp->f_type == DTYPE_SOCKET) {
-		u.u_error = EINVAL;
-		return;
-	}
-	ip = fp->f_inode;
-	ilock(ip);
+	ip = (struct inode *)fp->f_data;
+	ILOCK(ip);
+	if (fp->f_flag&FWRITE)
+		ip->i_flag |= ICHG;
 	syncip(ip);
-	iunlock(ip);
+	IUNLOCK(ip);
 }
 
 /*
@@ -888,11 +808,12 @@ fsync()
  *
  * 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.
+ *    from underneath us while we work (it may be truncated by
+ *    a concurrent `trunc' or `open' for creation).
  * 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
+ * 3) Unlink source reference to inode if still around. If a
+ *    directory was moved and the parent of the destination
  *    is different from the source, patch the ".." entry in the
  *    directory.
  *
@@ -904,35 +825,43 @@ rename()
 	struct a {
 		char	*from;
 		char	*to;
-	} *uap;
+	} *uap = (struct a *)u.u_ap;
 	register struct inode *ip, *xp, *dp;
-	int oldparent, parentdifferent, doingdirectory;
-
-	uap = (struct a *)u.u_ap;
-	ip = namei(uchar, LOOKUP | LOCKPARENT, 0);
+	struct dirtemplate dirbuf;
+	int doingdirectory = 0, oldparent = 0, newparent = 0;
+	register struct nameidata *ndp = &u.u_nd;
+	int error = 0;
+
+	ndp->ni_nameiop = DELETE | LOCKPARENT;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->from;
+	ip = namei(ndp);
 	if (ip == NULL)
 		return;
-	dp = u.u_pdir;
-	oldparent = 0, doingdirectory = 0;
+	dp = ndp->ni_pdir;
 	if ((ip->i_mode&IFMT) == IFDIR) {
 		register struct direct *d;
 
-		d = &u.u_dent;
+		d = &ndp->ni_dent;
 		/*
-		 * Avoid "." and ".." for obvious reasons.
+		 * Avoid ".", "..", and aliases of "." for obvious reasons.
 		 */
-		if (d->d_name[0] == '.') {
-			if (d->d_namlen == 1 ||
-			    (d->d_namlen == 2 && d->d_name[1] == '.')) {
-				u.u_error = EINVAL;
+		if ((d->d_namlen == 1 && d->d_name[0] == '.') ||
+		    (d->d_namlen == 2 && bcmp(d->d_name, "..", 2) == 0) ||
+		    (dp == ip) || (ip->i_flag & IRENAME)) {
+			iput(dp);
+			if (dp == ip)
+				irele(ip);
+			else
 				iput(ip);
-				return;
-			}
+			u.u_error = EINVAL;
+			return;
 		}
+		ip->i_flag |= IRENAME;
 		oldparent = dp->i_number;
 		doingdirectory++;
 	}
-	irele(dp);
+	iput(dp);
 
 	/*
 	 * 1) Bump link count while we're moving stuff
@@ -943,17 +872,49 @@ rename()
 	ip->i_nlink++;
 	ip->i_flag |= ICHG;
 	iupdat(ip, &time, &time, 1);
-	iunlock(ip);
+	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)
+	ndp->ni_nameiop = CREATE | LOCKPARENT | NOCACHE;
+	ndp->ni_dirp = (caddr_t)uap->to;
+	xp = namei(ndp);
+	if (u.u_error) {
+		error = u.u_error;
 		goto out;
-	dp = u.u_pdir;
+	}
+	dp = ndp->ni_pdir;
+	/*
+	 * If ".." must be changed (ie the directory gets a new
+	 * parent) then the source directory must not be in the
+	 * directory heirarchy above the target, as this would
+	 * orphan everything below the source directory. Also
+	 * the user must have write permission in the source so
+	 * as to be able to change "..". We must repeat the call 
+	 * to namei, as the parent directory is unlocked by the
+	 * call to checkpath().
+	 */
+	if (oldparent != dp->i_number)
+		newparent = dp->i_number;
+	if (doingdirectory && newparent) {
+		if (access(ip, IWRITE))
+			goto bad;
+		do {
+			dp = ndp->ni_pdir;
+			if (xp != NULL)
+				iput(xp);
+			u.u_error = checkpath(ip, dp);
+			if (u.u_error)
+				goto out;
+			xp = namei(ndp);
+			if (u.u_error) {
+				error = u.u_error;
+				goto out;
+			}
+		} while (dp != ndp->ni_pdir);
+	}
 	/*
 	 * 2) If target doesn't exist, link the target
 	 *    to the source and unlink the source. 
@@ -961,171 +922,193 @@ rename()
 	 *    entry to reference the source inode and
 	 *    expunge the original entry's existence.
 	 */
-	parentdifferent = oldparent != dp->i_number;
 	if (xp == NULL) {
 		if (dp->i_dev != ip->i_dev) {
-			u.u_error = EXDEV;
+			error = EXDEV;
 			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.
+		 * Account for ".." in new directory.
+		 * When source and destination have the same
+		 * parent we don't fool with the link count.
 		 */
-		if (doingdirectory && parentdifferent) {
+		if (doingdirectory && newparent) {
 			dp->i_nlink++;
 			dp->i_flag |= ICHG;
 			iupdat(dp, &time, &time, 1);
 		}
-		direnter(ip);
-		if (u.u_error)
+		error = direnter(ip, ndp);
+		if (error)
 			goto out;
 	} else {
 		if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) {
-			u.u_error = EXDEV;
+			error = EXDEV;
 			goto bad;
 		}
 		/*
-		 * Target must be empty if a directory.
+		 * Short circuit rename(foo, foo).
+		 */
+		if (xp->i_number == ip->i_number)
+			goto bad;
+		/*
+		 * If the parent directory is "sticky", then the user must
+		 * own the parent directory, or the destination of the rename,
+		 * otherwise the destination may not be changed (except by
+		 * root). This implements append-only directories.
+		 */
+		if ((dp->i_mode & ISVTX) && u.u_uid != 0 &&
+		    u.u_uid != dp->i_uid && xp->i_uid != u.u_uid) {
+			error = EPERM;
+			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)) {
-				u.u_error = EEXIST;	/* XXX */
+			if (!dirempty(xp, dp->i_number) || xp->i_nlink > 2) {
+				error = ENOTEMPTY;
 				goto bad;
 			}
 			if (!doingdirectory) {
-				u.u_error = ENOTDIR;
+				error = ENOTDIR;
 				goto bad;
 			}
+			cacheinval(dp);
 		} else if (doingdirectory) {
-			u.u_error = EISDIR;
+			error = EISDIR;
 			goto bad;
 		}
-		dirrewrite(dp, ip);
-		if (u.u_error)
+		dirrewrite(dp, ip, ndp);
+		if (u.u_error) {
+			error = u.u_error;
 			goto bad1;
+		}
 		/*
-		 * If this is a directory we know it is
-		 * empty and we can squash the inode and
-		 * any space associated with it.  Otherwise,
-		 * we've got a plain file and the link count
-		 * simply needs to be adjusted.
+		 * 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 the remaining link would point to
+		 * a directory without "." or ".." entries.
 		 */
+		xp->i_nlink--;
 		if (doingdirectory) {
-			xp->i_nlink = 0;
+			if (--xp->i_nlink != 0)
+				panic("rename: linked directory");
 			itrunc(xp, (u_long)0);
-		} else
-			xp->i_nlink--;
+		}
 		xp->i_flag |= ICHG;
 		iput(xp);
+		xp = NULL;
 	}
 
 	/*
 	 * 3) Unlink the source.
 	 */
-	u.u_dirp = uap->from;
-	dp = namei(uchar, DELETE, 0);
+	ndp->ni_nameiop = DELETE | LOCKPARENT;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->from;
+	xp = namei(ndp);
+	if (xp != NULL)
+		dp = ndp->ni_pdir;
+	else
+		dp = NULL;
 	/*
-	 * 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.
+	 * Insure that the directory entry still exists and has not
+	 * changed while the new name has been entered. If the source is
+	 * a file then the entry may have been unlinked or renamed. In
+	 * either case there is no further work to be done. If the source
+	 * is a directory then it cannot have been rmdir'ed; its link
+	 * count of three would cause a rmdir to fail with ENOTEMPTY.
+	 * The IRENAME flag insures that it cannot be moved by another
+	 * rename.
 	 */
-	if (dp == NULL || u.u_dent.d_ino != ip->i_number) {
-		ip->i_nlink--;
-		ip->i_flag |= ICHG;
+	if (xp != ip) {
+		if (doingdirectory)
+			panic("rename: lost dir entry");
 	} 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 the source is a directory with a
+		 * new parent, the link count of the old
+		 * parent directory must be decremented
+		 * and ".." set to point to the new parent.
 		 */
-		if (doingdirectory && (xp != NULL || parentdifferent)) {
+		if (doingdirectory && newparent) {
 			dp->i_nlink--;
 			dp->i_flag |= ICHG;
+			error = rdwri(UIO_READ, xp, (caddr_t)&dirbuf,
+				sizeof (struct dirtemplate), (off_t)0, 1,
+				(int *)0);
+			if (error == 0) {
+				if (dirbuf.dotdot_namlen != 2 ||
+				    dirbuf.dotdot_name[0] != '.' ||
+				    dirbuf.dotdot_name[1] != '.') {
+					printf("rename: mangled dir\n");
+				} else {
+					dirbuf.dotdot_ino = newparent;
+					(void) rdwri(UIO_WRITE, xp,
+					    (caddr_t)&dirbuf,
+					    sizeof (struct dirtemplate),
+					    (off_t)0, 1, (int *)0);
+					cacheinval(dp);
+				}
+			}
 		}
-		if (dirremove()) {
-			ip->i_nlink--;
-			ip->i_flag |= ICHG;
+		if (dirremove(ndp)) {
+			xp->i_nlink--;
+			xp->i_flag |= ICHG;
 		}
+		xp->i_flag &= ~IRENAME;
+		if (error == 0)		/* XXX 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 && u.u_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;
-		}
-		u.u_error = rdwri(UIO_READ, ip, (caddr_t)&dirbuf,
-			sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
-		if (u.u_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);
-	}
+	if (xp)
+		iput(xp);
+	irele(ip);
+	if (error)
+		u.u_error = error;
 	return;
+
 bad:
-	iput(u.u_pdir);
+	iput(dp);
 bad1:
 	if (xp)
-		irele(xp);
+		iput(xp);
 out:
 	ip->i_nlink--;
 	ip->i_flag |= ICHG;
 	irele(ip);
+	if (error)
+		u.u_error = error;
 }
 
 /*
  * Make a new file.
  */
 struct inode *
-maknode(mode)
+maknode(mode, ndp)
 	int mode;
+	register struct nameidata *ndp;
 {
 	register struct inode *ip;
+	register struct inode *pdir = ndp->ni_pdir;
 	ino_t ipref;
 
 	if ((mode & IFMT) == IFDIR)
-		ipref = dirpref(u.u_pdir->i_fs);
+		ipref = dirpref(pdir->i_fs);
 	else
-		ipref = u.u_pdir->i_number;
-	ip = ialloc(u.u_pdir, ipref, mode);
+		ipref = pdir->i_number;
+	ip = ialloc(pdir, ipref, mode);
 	if (ip == NULL) {
-		iput(u.u_pdir);
+		iput(pdir);
 		return (NULL);
 	}
 #ifdef QUOTA
@@ -1138,7 +1121,9 @@ maknode(mode)
 	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;
+	ip->i_gid = pdir->i_gid;
+	if (ip->i_mode & ISGID && !groupmember(ip->i_gid) && !suser())
+		ip->i_mode &= ~ISGID;
 #ifdef QUOTA
 	ip->i_dquot = inoquota(ip);
 #endif
@@ -1147,11 +1132,11 @@ maknode(mode)
 	 * Make sure inode goes to disk before directory entry.
 	 */
 	iupdat(ip, &time, &time, 1);
-	direnter(ip);
+	u.u_error = direnter(ip, ndp);
 	if (u.u_error) {
 		/*
-		 * write error occurred trying to update directory
-		 * so must deallocate the inode
+		 * Write error occurred trying to update directory
+		 * so must deallocate the inode.
 		 */
 		ip->i_nlink = 0;
 		ip->i_flag |= ICHG;
@@ -1160,3 +1145,235 @@ maknode(mode)
 	}
 	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 = (struct a *)u.u_ap;
+	register struct inode *ip, *dp;
+	struct dirtemplate dirtemplate;
+	register struct nameidata *ndp = &u.u_nd;
+
+	ndp->ni_nameiop = CREATE;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->name;
+	ip = namei(ndp);
+	if (u.u_error)
+		return;
+	if (ip != NULL) {
+		iput(ip);
+		u.u_error = EEXIST;
+		return;
+	}
+	dp = ndp->ni_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;
+	}
+	if (DIRBLKSIZ > ip->i_fs->fs_fsize)
+		panic("mkdir: blksize");     /* XXX - should grow with bmap() */
+	else
+		ip->i_size = DIRBLKSIZ;
+	/*
+	 * Directory all set up, now
+	 * install the entry for it in
+	 * the parent directory.
+	 */
+	u.u_error = direnter(ip, ndp);
+	dp = NULL;
+	if (u.u_error) {
+		ndp->ni_nameiop = LOOKUP | NOCACHE;
+		ndp->ni_segflg = UIO_USERSPACE;
+		ndp->ni_dirp = uap->name;
+		dp = namei(ndp);
+		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;
+	} *uap = (struct a *)u.u_ap;
+	register struct inode *ip, *dp;
+	register struct nameidata *ndp = &u.u_nd;
+
+	ndp->ni_nameiop = DELETE | LOCKPARENT;
+	ndp->ni_segflg = UIO_USERSPACE;
+	ndp->ni_dirp = uap->name;
+	ip = namei(ndp);
+	if (ip == NULL)
+		return;
+	dp = ndp->ni_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, dp->i_number)) {
+		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(ndp) == 0)
+		goto out;
+	dp->i_nlink--;
+	dp->i_flag |= ICHG;
+	cacheinval(dp);
+	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);
+	cacheinval(ip);
+out:
+	if (dp)
+		iput(dp);
+	iput(ip);
+}
+
+struct file *
+getinode(fdes)
+	int fdes;
+{
+	struct file *fp;
+
+	if ((unsigned)fdes >= NOFILE || (fp = u.u_ofile[fdes]) == NULL) {
+		u.u_error = EBADF;
+		return ((struct file *)0);
+	}
+	if (fp->f_type != DTYPE_INODE) {
+		u.u_error = EINVAL;
+		return ((struct file *)0);
+	}
+	return (fp);
+}
+
+/*
+ * mode mask for creation of files
+ */
+umask()
+{
+	register struct a {
+		int	mask;
+	} *uap = (struct a *)u.u_ap;
+
+	u.u_r.r_val1 = u.u_cmask;
+	u.u_cmask = uap->mask & 07777;
+}