4.2 distribution

[unix-history] / usr / src / sys / ufs / ffs / ffs_vnops.c

/*      ffs_vnops.c     6.1     83/07/29        */

#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/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();

/*
* Change current working directory (``.'').
*/
chdir()
{

       chdirec(&u.u_cdir);
}

/*
* Change notion of root (``/'') directory.
*/
chroot()
{

       if (suser())
               chdirec(&u.u_rdir);
}

/*
* Common routine for chroot and chdir.
*/
chdirec(ipp)
       register struct inode **ipp;
{
       register struct inode *ip;
       struct a {
               char    *fname;
       };

       ip = namei(uchar, LOOKUP, 1);
       if (ip == NULL)
               return;
       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);
}

/*
* Open system call.
*/
open()
{
       struct a {
               char    *fname;
               int     mode;
               int     crtmode;
       } *uap = (struct a *) u.u_ap;

       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;
       u.u_ofile[i] = NULL;
       fp->f_count--;
       irele(ip);
       return;
bad:
       iput(ip);
}

/*
* Mknod system call
*/
mknod()
{
       register struct inode *ip;
       register struct a {
               char    *fname;
               int     fmode;
               int     dev;
       } *uap;

       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);
}

/*
* link system call
*/
link()
{
       register struct inode *ip, *xp;
       register struct a {
               char    *target;
               char    *linkname;
       } *uap;

       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) == 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;
       }
       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:
       if (u.u_error) {
               ip->i_nlink--;
               ip->i_flag |= ICHG;
       }
       irele(ip);
}

/*
* symlink -- make a symbolic link
*/
symlink()
{
       register struct a {
               char    *target;
               char    *linkname;
       } *uap;
       register struct inode *ip;
       register char *tp;
       register c, nc;

       uap = (struct a *)u.u_ap;
       tp = uap->target;
       nc = 0;
       while (c = fubyte(tp)) {
               if (c < 0) {
                       u.u_error = EFAULT;
                       return;
               }
               tp++;
               nc++;
       }
       u.u_dirp = uap->linkname;
       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_error = rdwri(UIO_WRITE, ip, uap->target, nc, 0, 0, (int *)0);
       /* handle u.u_error != 0 */
       iput(ip);
}

/*
* Unlink system call.
* Hard to avoid races here, especially
* in unlinking directories.
*/
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     fd;
               off_t   off;
               int     sbase;
       } *uap;

       uap = (struct a *)u.u_ap;
       fp = getinode(uap->fd);
       if (fp == NULL)
               return;
       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;
}

/*
* 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;
}

/*
* Stat system call.  This version follows links.
*/
stat()
{

       stat1(1);
}

/*
* Lstat system call.  This version does not follow links.
*/
lstat()
{

       stat1(0);
}

stat1(follow)
       int follow;
{
       register struct inode *ip;
       register struct a {
               char    *fname;
               struct stat *ub;
       } *uap;
       struct stat sb;

       uap = (struct a *)u.u_ap;
       ip = namei(uchar, LOOKUP, follow);
       if (ip == NULL)
               return;
       (void) ino_stat(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_mode&IFMT) != IFLNK) {
               u.u_error = ENXIO;
               goto out;
       }
       u.u_error = rdwri(UIO_READ, ip, uap->buf, uap->count, 0, 0, &resid);
out:
       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
}

utimes()
{
       register struct a {
               char    *fname;
               struct  timeval *tptr;
       } *uap = (struct a *)u.u_ap;
       register struct inode *ip;
       struct timeval tv[2];

       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;
               iupdat(ip, &tv[0], &tv[1], 0);
       }
       iput(ip);
}

/*
* Flush any pending I/O.
*/
sync()
{

       update();
}

/*
* 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);
}

/*
* 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);
}

/*
* Synch an open file.
*/
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 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().
        */
       parentdifferent = oldparent != dp->i_number;
       if (doingdirectory && parentdifferent) {
               if (access(ip, IWRITE))
                       goto bad;
               do {
                       dp = u.u_pdir;
                       if (xp != NULL)
                               iput(xp);
                       u.u_error = checkpath(ip, dp);
                       if (u.u_error)
                               goto out;
                       u.u_dirp = (caddr_t)uap->to;
                       xp = namei(uchar, CREATE | LOCKPARENT, 0);
                       if (u.u_error) {
                               error = u.u_error;
                               goto out;
                       }
               } while (dp != u.u_pdir);
       }
       /*
        * 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;
               }
               /*
                * 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;
{
       register struct inode *ip;
       ino_t ipref;

       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;
       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);
}

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;
}