4.1cBSD/a/sys/sys/ufs_syscalls.c
/* ufs_syscalls.c 4.53 83/03/22 */
#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"
/*
* 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;
}
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 = 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.
*/
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);
}
/*
* 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);
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_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));
}
/*
* 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 = getf(uap->fd);
if (fp == NULL)
return;
if (fp->f_type == DTYPE_SOCKET) {
u.u_error = EINVAL;
return;
}
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;
if (u.u_gid == ip->i_gid)
goto ok;
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);
}
/*
* 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;
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;
}
ip = fp->f_inode;
if (!suser())
return;
ilock(ip);
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;
/*
* 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
}
/*
* Set IUPD and IACC times on file.
* Can't set ICHG.
*/
outime()
{
register struct a {
char *fname;
time_t *tptr;
} *uap;
register struct inode *ip;
time_t tv[2];
struct timeval tv0, tv1;
uap = (struct a *)u.u_ap;
if ((ip = owner(1)) == NULL)
return;
u.u_error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof(tv));
if (u.u_error == 0) {
ip->i_flag |= IACC|IUPD|ICHG;
tv0.tv_sec = tv[0]; tv0.tv_usec = 0;
tv1.tv_sec = tv[1]; tv1.tv_usec = 0;
iupdat(ip, &tv0, &tv1, 0);
}
iput(ip);
}
/*
* Flush any pending I/O.
*/
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] & (UF_SHLOCK|UF_EXLOCK);
if (cmd&FUNLOCK) {
if (flags == 0) {
u.u_error = EINVAL;
return;
}
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);
}
/*
* 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 = 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;
int error = 0;
uap = (struct a *)u.u_ap;
ip = namei(uchar, DELETE | LOCKPARENT, 0);
if (ip == NULL)
return;
dp = u.u_pdir;
oldparent = 0, doingdirectory = 0;
if ((ip->i_mode&IFMT) == IFDIR) {
register struct direct *d;
d = &u.u_dent;
/*
* Avoid ".", "..", and aliases of "." for obvious reasons.
*/
if ((d->d_namlen == 1 && d->d_name[0] == '.') ||
(d->d_namlen == 2 && bcmp(d->d_name, "..", 2) == 0) ||
(dp == ip)) {
iput(dp);
if (dp == ip)
irele(ip);
else
iput(ip);
u.u_error = EINVAL;
return;
}
oldparent = dp->i_number;
doingdirectory++;
}
iput(dp);
/*
* 1) Bump link count while we're moving stuff
* around. If we crash somewhere before
* completing our work, the link count
* may be wrong, but correctable.
*/
ip->i_nlink++;
ip->i_flag |= ICHG;
iupdat(ip, &time, &time, 1);
iunlock(ip);
/*
* When the target exists, both the directory
* and target inodes are returned locked.
*/
u.u_dirp = (caddr_t)uap->to;
xp = namei(uchar, CREATE | LOCKPARENT, 0);
if (u.u_error) {
error = u.u_error;
goto out;
}
dp = u.u_pdir;
/*
* If ".." must be changed (ie the directory gets a new
* parent) then the user must have write permission.
*/
parentdifferent = oldparent != dp->i_number;
if (doingdirectory && parentdifferent && access(ip, IWRITE))
goto bad;
/*
* 2) If target doesn't exist, link the target
* to the source and unlink the source.
* Otherwise, rewrite the target directory
* entry to reference the source inode and
* expunge the original entry's existence.
*/
if (xp == NULL) {
if (dp->i_dev != ip->i_dev) {
error = EXDEV;
goto bad;
}
/*
* Disallow rename(foo, foo/bar).
*/
if (dp->i_number == ip->i_number) {
error = EEXIST;
goto bad;
}
/*
* Account for ".." in directory.
* When source and destination have the
* same parent we don't fool with the
* link count -- this isn't required
* because we do a similar check below.
*/
if (doingdirectory && parentdifferent) {
dp->i_nlink++;
dp->i_flag |= ICHG;
iupdat(dp, &time, &time, 1);
}
error = direnter(ip);
if (error)
goto out;
} else {
if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) {
error = EXDEV;
goto bad;
}
/*
* Short circuit rename(foo, foo).
*/
if (xp->i_number == ip->i_number)
goto bad;
/*
* Target must be empty if a directory
* and have no links to it.
* Also, insure source and target are
* compatible (both directories, or both
* not directories).
*/
if ((xp->i_mode&IFMT) == IFDIR) {
if (!dirempty(xp) || xp->i_nlink > 2) {
error = ENOTEMPTY;
goto bad;
}
if (!doingdirectory) {
error = ENOTDIR;
goto bad;
}
} else if (doingdirectory) {
error = EISDIR;
goto bad;
}
dirrewrite(dp, ip);
if (u.u_error) {
error = u.u_error;
goto bad1;
}
/*
* Adjust the link count of the target to
* reflect the dirrewrite above. If this is
* a directory it is empty and there are
* no links to it, so we can squash the inode and
* any space associated with it. We disallowed
* renaming over top of a directory with links to
* it above, as we've no way to determine if
* we've got a link or the directory itself, and
* if we get a link, then ".." will be screwed up.
*/
xp->i_nlink--;
if (doingdirectory) {
if (--xp->i_nlink != 0)
panic("rename: linked directory");
itrunc(xp, (u_long)0);
}
xp->i_flag |= ICHG;
iput(xp);
xp = NULL;
}
/*
* 3) Unlink the source.
*/
u.u_dirp = uap->from;
dp = namei(uchar, DELETE, 0);
/*
* Insure directory entry still exists and
* has not changed since the start of all
* this. If either has occured, forget about
* about deleting the original entry and just
* adjust the link count in the inode.
*/
if (dp == NULL || u.u_dent.d_ino != ip->i_number) {
ip->i_nlink--;
ip->i_flag |= ICHG;
} else {
/*
* If source is a directory, must adjust
* link count of parent directory also.
* If target didn't exist and source and
* target have the same parent, then we
* needn't touch the link count, it all
* balances out in the end. Otherwise, we
* must do so to reflect deletion of ".."
* done above.
*/
if (doingdirectory && (xp != NULL || parentdifferent)) {
dp->i_nlink--;
dp->i_flag |= ICHG;
}
if (dirremove()) {
ip->i_nlink--;
ip->i_flag |= ICHG;
}
if (error == 0) /* conservative */
error = u.u_error;
}
irele(ip);
if (dp)
iput(dp);
/*
* 4) Renaming a directory with the parent
* different requires ".." to be rewritten.
* The window is still there for ".." to
* be inconsistent, but this is unavoidable,
* and a lot shorter than when it was done
* in a user process.
*/
if (doingdirectory && parentdifferent && error == 0) {
struct dirtemplate dirbuf;
u.u_dirp = uap->to;
ip = namei(uchar, LOOKUP | LOCKPARENT, 0);
if (ip == NULL) {
printf("rename: .. went away\n");
return;
}
dp = u.u_pdir;
if ((ip->i_mode&IFMT) != IFDIR) {
printf("rename: .. not a directory\n");
goto stuck;
}
error = rdwri(UIO_READ, ip, (caddr_t)&dirbuf,
sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
if (error == 0) {
dirbuf.dotdot_ino = dp->i_number;
(void) rdwri(UIO_WRITE, ip, (caddr_t)&dirbuf,
sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
}
stuck:
irele(dp);
iput(ip);
}
goto done;
bad:
iput(dp);
bad1:
if (xp)
iput(xp);
out:
ip->i_nlink--;
ip->i_flag |= ICHG;
irele(ip);
done:
if (error)
u.u_error = error;
}
/*
* Make a new file.
*/
struct inode *
maknode(mode)
int mode;
{
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);
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);
}