From 3061a7b0e690eb2721920a2b211d0faae5773533 Mon Sep 17 00:00:00 2001 From: CSRG Date: Sat, 26 Mar 1983 23:02:52 -0800 Subject: [PATCH] BSD 4_1c_2 development Work on file a/sys/sys/ufs_syscalls.c Synthesized-from: CSRG/cd1/4.1c.2 --- a/sys/sys/ufs_syscalls.c | 1205 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 1205 insertions(+) create mode 100644 a/sys/sys/ufs_syscalls.c diff --git a/a/sys/sys/ufs_syscalls.c b/a/sys/sys/ufs_syscalls.c new file mode 100644 index 0000000000..3554f53303 --- /dev/null +++ b/a/sys/sys/ufs_syscalls.c @@ -0,0 +1,1205 @@ +/* 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); +} -- 2.20.1