ufs_gnodeops.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

					printf("textp = %X gp = %X\n",xp,gp);
					panic("ufs_rwgp: illegal text reuse");
				}
				xuntext(xp);
			}
			if (n == bsize) 
				bp = getblk(dev, bn, size,
					    (struct gnode *) NULL);
			else
				bp = bread(dev, bn, size,
					   (struct gnode *) NULL);
		}
		n = MIN(n, size - bp->b_resid);
		if (bp->b_flags & B_ERROR) {
			error = EIO;
			brelse(bp);
			goto bad;
		}
		u.u_error =
		    uiomove(bp->b_un.b_addr+on, n, rw, uio);

		/* Don't cache non-executable files with the sticky bit on; */
		/* used to avoid cacheing remote swap files */
		if (stickyhack && (ioflag & IO_SYNC) && (gp->g_mode & GSVTX)
		    && (gp->g_mode & execmask) == 0)
		  bp->b_flags |= B_NOCACHE;

		if (rw == UIO_READ) {
			brelse(bp);
		} else {

			/*
			 * If writing a directory, or performing syncronous
			 * writes, then call bwrite to write synchronously.
			 */

			if (
			    ((gp->g_mode & GFMT) == GFDIR) ||
			    (ioflag & IO_SYNC) ||
			    (gp->g_mp->m_flags & M_SYNC)
			   )
				bwrite(bp);
			else if (n + on == bsize) {
				if (delay_wbuffers)
					bdwrite(bp);
				else
					bawrite(bp);
			} else
				bdwrite(bp);
			gp->g_flag |= GUPD|GCHG;
			if (cred->cr_ruid != 0)
				gp->g_mode &= ~(GSUID|GSGID);
		}
	} while (u.u_error == 0 && uio->uio_resid > 0 && n != 0);

	/*
	 * If synchronous write, and on-disk structures
	 * changed, then get gnode out to disk now, else only update
	 * the modification time.
	 */
	if (ioflag & IO_SYNC) {
		if (update_flag)
			(void) ufs_gupdat(gp, timepick, timepick, 1,
					  (struct ucred *) 0);
		else
			(void) ufs_gupdat(gp, timepick, timepick, 0,
					  (struct ucred *) 0);
	}

	if (error == 0)				/* XXX */
		error = u.u_error;		/* XXX */
bad:
	return (error);
}


ufs_fcntl(gp, cmd, arg, flag, cred)
	register struct gnode *gp;
	register int cmd;
	register caddr_t arg;
	register int flag;
	struct ucred *cred;
{
	register int fmt = gp->g_mode & GFMT;
	dev_t dev;

	switch (fmt) {
		case GFREG:
		case GFDIR:
			if (cmd == FIONREAD) {
				*(off_t *)arg = gp->g_size - flag;
				return (0);
			}
			if (cmd == FIONBIO || cmd == FIOASYNC ||
			    cmd == FIOSINUSE || cmd == FIOCINUSE) /* XXX */
				return (0);			/* XXX */
			/* fall into ... */
		default:
			return (ENOTTY);
	}
}

ufs_select(gp, rw, cred)
	register struct gnode *gp;
	register int rw;
	struct ucred *cred;
{ 
  return (1);		/* XXX */
}

ufs_close(gp, flag)
	register struct gnode *gp;
	register int flag;
{
  return;
}

ufs_open(gp, mode)
	register struct gnode *gp;
	register int mode;
{
	return (0);
}

ufs_symlink(ndp, target_name)
	register struct nameidata *ndp;
	register char *target_name;
{
	register int len;
	struct uio auio;
	struct iovec aiov;
	register struct gnode *gp;
	struct gnode *ufs_maknode();
	
	if((gp = ufs_maknode(GFLNK | 0777, (dev_t) 0, ndp)) == NULL) 
		return;

	len = strlen(target_name);
	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	aiov.iov_base = target_name;
	aiov.iov_len = auio.uio_resid = len;
	auio.uio_segflg = UIO_SYSSPACE;
	auio.uio_offset = 0;
	
	u.u_error = ufs_rwgp(gp, &auio, UIO_WRITE, 0,  u.u_cred);
	gput(gp);
}


ufs_readlink(gp, auio)
	register struct gnode *gp;
	register struct uio *auio;
{
	int size, error;

	if (gp->g_size > auio->uio_resid)
	        return(ERANGE);
	if (G_TO_I(gp)->di_flags & OSF_FASTLINK) {
		size = gp->g_size;
		error = uiomove(G_TO_I(gp)->di_db, size, UIO_READ, auio);
		gp->g_flag |= GACC;
		u.u_error = error;
		return(error);
	}
	u.u_error = ufs_rwgp(gp, auio, UIO_READ, 0, u.u_cred);
}

ufs_stat(gp, sb)
	register struct gnode *gp;
	register struct stat *sb;
{

        gfs_lock(gp);
	if ((gp)->g_flag&(GUPD|GACC|GCHG)) {
		(gp)->g_flag |= GMOD;
		if ((gp)->g_flag&GACC) {
			(gp)->g_atime.tv_sec = timepick->tv_sec;
			(gp)->g_atime.tv_usec = timepick->tv_usec;
		}
		if ((gp)->g_flag&GUPD) {
			(gp)->g_mtime.tv_sec = timepick->tv_sec;
			(gp)->g_mtime.tv_usec = timepick->tv_usec;
		}
		if ((gp)->g_flag&GCHG) {
			(gp)->g_ctime.tv_sec = timepick->tv_sec;
			(gp)->g_ctime.tv_usec = timepick->tv_usec;
		}
		(gp)->g_flag &= ~(GACC|GUPD|GCHG);
	}
	gfs_unlock(gp);

	/*
	 * Copy from gnode table
	 */
	sb->st_dev = gp->g_dev;
	sb->st_ino = gp->g_number;
	sb->st_mode = gp->g_mode;
	sb->st_nlink = gp->g_nlink;
	sb->st_uid = gp->g_uid;
	sb->st_gid = gp->g_gid;
	sb->st_rdev = (dev_t)gp->g_rdev;
	sb->st_size = gp->g_size;
	sb->st_atime = gp->g_atime.tv_sec;
	sb->st_spare1 = gp->g_atime.tv_usec;
	sb->st_mtime = gp->g_mtime.tv_sec;
	sb->st_spare2 = gp->g_mtime.tv_usec;
	sb->st_ctime = gp->g_ctime.tv_sec;
	sb->st_spare3 = gp->g_ctime.tv_usec;
	/* this doesn't belong here */
	if ((gp->g_mode & GFMT) == GFBLK)
		sb->st_blksize = BLKDEV_IOSIZE;
	else if ((gp->g_mode & GFMT) == GFCHR)
		sb->st_blksize = MAXBSIZE;
	else
		sb->st_blksize = FS(gp)->fs_bsize;
	sb->st_blocks = gp->g_blocks;
	sb->st_gennum = gp->g_gennum;
	sb->st_spare4 = 0;
	return (0);
}

struct fs_data *
ufs_getfsdata(mp)
	register struct mount *mp;
{
	register struct fs_data *fs_data = mp->m_fs_data;
	register struct fs *fs;
	
	fs = (struct fs *) mp->m_bufp->b_un.b_fs;
	fs_data->fd_gtot = fs->fs_ncg * fs->fs_ipg;
	fs_data->fd_gfree = fs->fs_cstotal.cs_nifree;
	fs_data->fd_btot = fs->fs_dsize * fs->fs_fsize / FSDUNIT;
	fs_data->fd_bfree = (fs->fs_cstotal.cs_nbfree * fs->fs_frag +
	fs->fs_cstotal.cs_nffree) * fs->fs_fsize / FSDUNIT;
	fs_data->fd_otsize = fs->fs_bsize;
	fs_data->fd_mtsize = MAXBSIZE;
	fs_data->fd_bfreen = freespace(fs, fs->fs_minfree) *
	fs->fs_fsize / FSDUNIT;
	fs_data->fd_dev = mp->m_dev;
	return(fs_data);
}

ufs_getdirent(gp, auio, cred)
	register struct gnode *gp;
	register struct uio *auio;
	register struct ucred *cred;
{

	if(access(gp, GREAD)) {	/* must be able to read the dir */
		u.u_error = EPERM;
		return;
	}

	u.u_error = ufs_rwgp(gp, auio, UIO_READ, 0, cred);

}

int
ufs_rlock(gp, ld, cmd, fp)
	struct gnode *gp;
	struct flock *ld;
	int cmd;
	struct file *fp;
{

	/*
	 *	There are two mechanisms by which ufs Sys-V locking
	 *	are supported.  The default support is kernel based
	 *	and the optional support is daemon based, and requires
	 *	that nfs is configured and that daemon based locking
	 *	has been enabled (via nfssetup).
	 */

	if (kernel_locking) {   /* kernel based locking */

		switch(cmd) {

			case F_GETLK:

				/* get region lock */

				if (u.u_error = getflck (fp, ld)) {
					break;
				}

				break;

			default:

				if (cmd == F_SETLK) {
					u.u_error = setflck (fp, ld, 0);
				} else { 
					u.u_error = setflck (fp, ld, 1);
				}

				break;

		} /* End switch */


	} else {
	
		/* daemon based locking */

		u.u_error = klm_drlock (gp, ld, cmd, fp->f_cred);
	}

	return (u.u_error); 

}