-/* ffs_vnops.c 4.14 81/11/16 */
+/* ffs_vnops.c 4.46 82/12/28 */
#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/descrip.h"
+#include "../h/uio.h"
#include "../h/socket.h"
#include "../h/socketvar.h"
+#include "../h/nami.h"
+
+/*
+ * 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()
+{
+ register struct inode *ip;
+ register struct a {
+ char *fname;
+ int flags;
+ int mode;
+ } *uap;
+ int checkpermissions = 1, flags;
+
+ 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);
+}
+
+#ifndef NOCOMPAT
+/*
+ * Creat system call.
+ */
+ocreat()
+{
+ register struct inode *ip;
+ register struct a {
+ char *fname;
+ int fmode;
+ } *uap;
+
+ 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);
+}
+#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.
+ */
+open1(ip, mode, checkpermissions)
+ register struct inode *ip;
+ register mode;
+{
+ register struct file *fp;
+ int i, flags;
+
+ if (checkpermissions) {
+ 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;
+ }
+ }
+ }
+
+ /*
+ * 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)
+ 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;
+ return;
+ }
+ u.u_ofile[i] = NULL;
+ fp->f_count--;
+out:
+ 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()) {
+ 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;
+ 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;
+ }
+ 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 = getf(uap->fd);
+ if (fp == NULL)
+ return;
+ if (fp->f_type == DTYPE_SOCKET) {
+ 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;
+}
+
+/*
+ * 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&FACCESS_READ) && access(ip, IREAD))
+ goto done;
+ if ((uap->fmode&FACCESS_WRITE) && access(ip, IWRITE))
+ goto done;
+ if ((uap->fmode&FACCESS_EXECUTE) && access(ip, IEXEC))
+ goto done;
+done:
+ iput(ip);
+ }
+ u.u_uid = svuid;
+ u.u_gid = svgid;
+}
/*
* the fstat system call.
{
register struct file *fp;
register struct a {
- int fdes;
+ int fd;
struct stat *sb;
} *uap;
uap = (struct a *)u.u_ap;
- fp = getf(uap->fdes);
+ fp = getf(uap->fd);
if (fp == NULL)
return;
- if (fp->f_flag & FSOCKET)
+ 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.
+ * Stat system call. This version follows links.
*/
stat()
{
} *uap;
uap = (struct a *)u.u_ap;
- ip = namei(uchar, 0);
+ ip = namei(uchar, LOOKUP, 1);
+ if (ip == NULL)
+ return;
+ stat1(ip, uap->sb);
+ iput(ip);
+}
+
+/*
+ * Lstat system call. This version does not follow links.
+ */
+lstat()
+{
+ register struct inode *ip;
+ register struct a {
+ char *fname;
+ struct stat *sb;
+ } *uap;
+
+ uap = (struct a *)u.u_ap;
+ ip = namei(uchar, LOOKUP, 0);
if (ip == NULL)
return;
stat1(ip, uap->sb);
register struct inode *ip;
struct stat *ub;
{
- register struct dinode *dp;
- register struct buf *bp;
struct stat ds;
IUPDAT(ip, &time, &time, 0);
/*
- * First copy from inode table
+ * Copy from inode table
*/
ds.st_dev = ip->i_dev;
ds.st_ino = ip->i_number;
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_rdev = (dev_t)ip->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;
+ ds.st_atime = ip->i_atime;
+ ds.st_spare1 = 0;
+ ds.st_mtime = ip->i_mtime;
+ ds.st_spare2 = 0;
+ ds.st_ctime = ip->i_ctime;
+ ds.st_spare3 = 0;
+ /* 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;
+ ds.st_spare4[0] = ds.st_spare4[1] = ds.st_spare4[2] = 0;
+ u.u_error = copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds));
}
/*
- * Dup system call.
+ * Return target name of a symbolic link
*/
-dup()
+readlink()
{
- register struct file *fp;
+ register struct inode *ip;
register struct a {
- int fdes;
- int fdes2;
+ 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;
- register i, m;
uap = (struct a *)u.u_ap;
- m = uap->fdes & ~077;
- uap->fdes &= 077;
- fp = getf(uap->fdes);
+ 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 = getf(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 (fp->f_type == DTYPE_SOCKET) {
+ u.u_error = EINVAL;
+ return;
}
- if (i != uap->fdes) {
- if (u.u_ofile[i]!=NULL)
- closef(u.u_ofile[i]);
- u.u_ofile[i] = fp;
- fp->f_count++;
+ ip = fp->f_inode;
+ 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;
+{
+ register int *gp;
+
+ 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
}
+ ip->i_mode |= mode&07777;
+ ip->i_flag |= ICHG;
+ if (ip->i_flag&ITEXT && (ip->i_mode&ISVTX)==0)
+ xrele(ip);
}
/*
- * Mount system call.
+ * Set ownership given a path name.
*/
-smount()
+chown()
{
- 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;
+ struct inode *ip;
+ struct a {
+ char *fname;
+ int uid;
+ int gid;
} *uap;
- register char *cp;
uap = (struct a *)u.u_ap;
- dev = getmdev();
- if (u.u_error)
+ if (!suser() || (ip = owner(0)) == NULL)
return;
- u.u_dirp = (caddr_t)uap->freg;
- ip = namei(uchar, 0);
- if (ip == NULL)
+ 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 = getf(uap->fd);
+ if (fp == NULL)
+ return;
+ if (fp->f_type == DTYPE_SOCKET) {
+ u.u_error = EINVAL;
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)
- 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;
+ ip = fp->f_inode;
+ if (!suser())
+ return;
+ ilock(ip);
+ chown1(ip, uap->uid, uap->gid);
+ iunlock(ip);
+}
-out:
- u.u_error = EBUSY;
-out1:
- iput(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;
+
+ /*
+ * 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 (ip->i_uid == uid)
+ 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);
+ 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_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);
+#endif
}
/*
- * the umount system call.
+ * Set IUPD and IACC times on file.
+ * Can't set ICHG.
*/
-sumount()
+outime()
{
- dev_t dev;
- register struct inode *ip;
- register struct mount *mp;
- struct buf *bp;
- int stillopen, flag;
register struct a {
- char *fspec;
- };
+ char *fname;
+ time_t *tptr;
+ } *uap;
+ register struct inode *ip;
+ time_t tv[2];
+ struct timeval tv0, tv1;
- dev = getmdev();
- if (u.u_error)
+ uap = (struct a *)u.u_ap;
+ if ((ip = owner(1)) == NULL)
return;
- xumount(dev); /* remove unused sticky files from text table */
+ 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);
+}
+
+/*
+ * Flush any pending I/O.
+ */
+sync()
+{
+
update();
- for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++)
- if (mp->m_bufp != NULL && dev == mp->m_dev)
- goto found;
- u.u_error = EINVAL;
- return;
+}
-found:
- stillopen = 0;
- for (ip = inode; ip < inodeNINODE; ip++)
- if (ip->i_number != 0 && dev == ip->i_dev) {
- u.u_error = EBUSY;
+/*
+ * 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] & (UF_SHLOCK|UF_EXLOCK);
+ if (cmd&FUNLOCK) {
+ 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);
- 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);
+ }
+ funlocki(fp->f_inode, 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&FEXLOCK) ||
+ (flags&UF_SHLOCK) && (cmd&FSHLOCK))
+ return;
+ u.u_pofile[uap->fd] = flocki(fp->f_inode, u.u_pofile[uap->fd], cmd);
}
/*
- * 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.
+ * Truncate a file given its path name.
*/
-dev_t
-getmdev()
+truncate()
{
- dev_t dev;
- register struct inode *ip;
+ struct a {
+ char *fname;
+ u_long length;
+ } *uap = (struct a *)u.u_ap;
+ struct inode *ip;
- if (!suser())
- return(NODEV);
- ip = namei(uchar, 0);
+ ip = namei(uchar, LOOKUP, 1);
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;
+ 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);
- return(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 = getf(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);
+}
+
+/*
+ * Synch an open file.
+ */
+fsync()
+{
+ struct a {
+ int fd;
+ } *uap = (struct a *)u.u_ap;
+ struct inode *ip;
+ struct file *fp;
+
+ fp = getf(uap->fd);
+ if (fp == NULL)
+ return;
+ if (fp->f_type == DTYPE_SOCKET) {
+ u.u_error = EINVAL;
+ return;
+ }
+ ip = fp->f_inode;
+ 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;
+
+ uap = (struct a *)u.u_ap;
+ ip = namei(uchar, LOOKUP | 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 ".." 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;
+ iput(ip);
+ return;
+ }
+ }
+ oldparent = dp->i_number;
+ doingdirectory++;
+ }
+ irele(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)
+ goto out;
+ 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.
+ */
+ parentdifferent = oldparent != dp->i_number;
+ if (xp == NULL) {
+ if (dp->i_dev != ip->i_dev) {
+ u.u_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);
+ }
+ direnter(ip);
+ if (u.u_error)
+ goto out;
+ } else {
+ if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) {
+ u.u_error = EXDEV;
+ goto bad;
+ }
+ /*
+ * Target must be empty if a directory.
+ * 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 = ENOTEMPTY;
+ goto bad;
+ }
+ if (!doingdirectory) {
+ u.u_error = ENOTDIR;
+ goto bad;
+ }
+ } else if (doingdirectory) {
+ u.u_error = EISDIR;
+ goto bad;
+ }
+ dirrewrite(dp, ip);
+ if (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.
+ */
+ if (doingdirectory) {
+ xp->i_nlink = 0;
+ itrunc(xp, (u_long)0);
+ } else
+ xp->i_nlink--;
+ xp->i_flag |= ICHG;
+ iput(xp);
+ }
+
+ /*
+ * 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;
+ }
+ }
+ 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);
+ }
+ return;
+bad:
+ iput(u.u_pdir);
+bad1:
+ if (xp)
+ irele(xp);
+out:
+ ip->i_nlink--;
+ ip->i_flag |= ICHG;
+ irele(ip);
+}
+
+/*
+ * 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;
+#ifdef QUOTA
+ ip->i_dquot = inoquota(ip);
+#endif
+
+ /*
+ * Make sure inode goes to disk before directory entry.
+ */
+ iupdat(ip, &time, &time, 1);
+ 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);
}