/* * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it would be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * * Further, this software is distributed without any warranty that it is * free of the rightful claim of any third person regarding infringement * or the like.  Any license provided herein, whether implied or * otherwise, applies only to this software file.  Patent licenses, if * any, provided herein do not apply to combinations of this program with * other software, or any other product whatsoever. * * You should have received a copy of the GNU General Public License along * with this program; if not, write the Free Software Foundation, Inc., 59 * Temple Place - Suite 330, Boston MA 02111-1307, USA. * * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, * Mountain View, CA  94043, or: * * http://www.sgi.com * * For further information regarding this notice, see: * * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ */#include "xfs.h"#include "xfs_fs.h"#include "xfs_inum.h"#include "xfs_log.h"#include "xfs_trans.h"#include "xfs_sb.h"#include "xfs_ag.h"#include "xfs_dir.h"#include "xfs_dir2.h"#include "xfs_alloc.h"#include "xfs_dmapi.h"#include "xfs_quota.h"#include "xfs_mount.h"#include "xfs_alloc_btree.h"#include "xfs_bmap_btree.h"#include "xfs_ialloc_btree.h"#include "xfs_btree.h"#include "xfs_ialloc.h"#include "xfs_attr_sf.h"#include "xfs_dir_sf.h"#include "xfs_dir2_sf.h"#include "xfs_dinode.h"#include "xfs_inode.h"#include "xfs_bmap.h"#include "xfs_bit.h"#include "xfs_rtalloc.h"#include "xfs_error.h"#include "xfs_itable.h"#include "xfs_rw.h"#include "xfs_acl.h"#include "xfs_cap.h"#include "xfs_mac.h"#include "xfs_attr.h"#include "xfs_buf_item.h"#include "xfs_utils.h"#include <linux/xattr.h>#include <linux/namei.h>/* * Pull the link count and size up from the xfs inode to the linux inode */STATIC voidvalidate_fields(	struct inode	*ip){	vnode_t		*vp = LINVFS_GET_VP(ip);	vattr_t		va;	int		error;	va.va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;	VOP_GETATTR(vp, &va, ATTR_LAZY, NULL, error);	if (likely(!error)) {		ip->i_nlink = va.va_nlink;		ip->i_blocks = va.va_nblocks;		/* we're under i_sem so i_size can't change under us */		if (i_size_read(ip) != va.va_size)			i_size_write(ip, va.va_size);	}}/* * Determine whether a process has a valid fs_struct (kernel daemons * like knfsd don't have an fs_struct). * * XXX(hch):  nfsd is broken, better fix it instead. */STATIC inline inthas_fs_struct(struct task_struct *task){	return (task->fs != init_task.fs);}STATIC intlinvfs_mknod(	struct inode	*dir,	struct dentry	*dentry,	int		mode,	dev_t		rdev){	struct inode	*ip;	vattr_t		va;	vnode_t		*vp = NULL, *dvp = LINVFS_GET_VP(dir);	xfs_acl_t	*default_acl = NULL;	attrexists_t	test_default_acl = _ACL_DEFAULT_EXISTS;	int		error;	/*	 * Irix uses Missed'em'V split, but doesn't want to see	 * the upper 5 bits of (14bit) major.	 */	if (!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff)		return -EINVAL;	if (test_default_acl && test_default_acl(dvp)) {		if (!_ACL_ALLOC(default_acl))			return -ENOMEM;		if (!_ACL_GET_DEFAULT(dvp, default_acl)) {			_ACL_FREE(default_acl);			default_acl = NULL;		}	}	if (IS_POSIXACL(dir) && !default_acl && has_fs_struct(current))		mode &= ~current->fs->umask;	memset(&va, 0, sizeof(va));	va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;	va.va_type = IFTOVT(mode);	va.va_mode = mode;	switch (mode & S_IFMT) {	case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK:		va.va_rdev = sysv_encode_dev(rdev);		va.va_mask |= XFS_AT_RDEV;		/*FALLTHROUGH*/	case S_IFREG:		VOP_CREATE(dvp, dentry, &va, &vp, NULL, error);		break;	case S_IFDIR:		VOP_MKDIR(dvp, dentry, &va, &vp, NULL, error);		break;	default:		error = EINVAL;		break;	}	if (default_acl) {		if (!error) {			error = _ACL_INHERIT(vp, &va, default_acl);			if (!error) {				VMODIFY(vp);			} else {				struct dentry	teardown = {};				int		err2;				/* Oh, the horror.				 * If we can't add the ACL we must back out.				 * ENOSPC can hit here, among other things.				 */				teardown.d_inode = ip = LINVFS_GET_IP(vp);				teardown.d_name = dentry->d_name;				remove_inode_hash(ip);				make_bad_inode(ip);				if (S_ISDIR(mode))					VOP_RMDIR(dvp, &teardown, NULL, err2);				else					VOP_REMOVE(dvp, &teardown, NULL, err2);				VN_RELE(vp);			}		}		_ACL_FREE(default_acl);	}	if (!error) {		ASSERT(vp);		ip = LINVFS_GET_IP(vp);		if (S_ISCHR(mode) || S_ISBLK(mode))			ip->i_rdev = rdev;		else if (S_ISDIR(mode))			validate_fields(ip);		d_instantiate(dentry, ip);		validate_fields(dir);	}	return -error;}STATIC intlinvfs_create(	struct inode	*dir,	struct dentry	*dentry,	int		mode,	struct nameidata *nd){	return linvfs_mknod(dir, dentry, mode, 0);}STATIC intlinvfs_mkdir(	struct inode	*dir,	struct dentry	*dentry,	int		mode){	return linvfs_mknod(dir, dentry, mode|S_IFDIR, 0);}STATIC struct dentry *linvfs_lookup(	struct inode	*dir,	struct dentry	*dentry,	struct nameidata *nd){	struct inode	*ip = NULL;	vnode_t		*vp, *cvp = NULL;	int		error;	if (dentry->d_name.len >= MAXNAMELEN)		return ERR_PTR(-ENAMETOOLONG);	vp = LINVFS_GET_VP(dir);	VOP_LOOKUP(vp, dentry, &cvp, 0, NULL, NULL, error);	if (!error) {		ASSERT(cvp);		ip = LINVFS_GET_IP(cvp);		if (!ip) {			VN_RELE(cvp);			return ERR_PTR(-EACCES);		}	}	if (error && (error != ENOENT))		return ERR_PTR(-error);	return d_splice_alias(ip, dentry);}STATIC intlinvfs_link(	struct dentry	*old_dentry,	struct inode	*dir,	struct dentry	*dentry){	struct inode	*ip;	/* inode of guy being linked to */	vnode_t		*tdvp;	/* target directory for new name/link */	vnode_t		*vp;	/* vp of name being linked */	int		error;	ip = old_dentry->d_inode;	/* inode being linked to */	if (S_ISDIR(ip->i_mode))		return -EPERM;	tdvp = LINVFS_GET_VP(dir);	vp = LINVFS_GET_VP(ip);	VOP_LINK(tdvp, vp, dentry, NULL, error);	if (!error) {		VMODIFY(tdvp);		VN_HOLD(vp);		validate_fields(ip);		d_instantiate(dentry, ip);	}	return -error;}STATIC intlinvfs_unlink(	struct inode	*dir,	struct dentry	*dentry){	struct inode	*inode;	vnode_t		*dvp;	/* directory containing name to remove */	int		error;	inode = dentry->d_inode;	dvp = LINVFS_GET_VP(dir);	VOP_REMOVE(dvp, dentry, NULL, error);	if (!error) {		validate_fields(dir);	/* For size only */		validate_fields(inode);	}	return -error;}STATIC intlinvfs_symlink(	struct inode	*dir,	struct dentry	*dentry,	const char	*symname){	struct inode	*ip;	vattr_t		va;	vnode_t		*dvp;	/* directory containing name to remove */	vnode_t		*cvp;	/* used to lookup symlink to put in dentry */	int		error;	dvp = LINVFS_GET_VP(dir);	cvp = NULL;	memset(&va, 0, sizeof(va));	va.va_type = VLNK;	va.va_mode = irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO;	va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;	error = 0;	VOP_SYMLINK(dvp, dentry, &va, (char *)symname, &cvp, NULL, error);	if (!error && cvp) {		ASSERT(cvp->v_type == VLNK);		ip = LINVFS_GET_IP(cvp);		d_instantiate(dentry, ip);		validate_fields(dir);		validate_fields(ip); /* size needs update */	}	return -error;}STATIC intlinvfs_rmdir(	struct inode	*dir,	struct dentry	*dentry){	struct inode	*inode = dentry->d_inode;	vnode_t		*dvp = LINVFS_GET_VP(dir);	int		error;	VOP_RMDIR(dvp, dentry, NULL, error);	if (!error) {		validate_fields(inode);		validate_fields(dir);	}	return -error;}STATIC intlinvfs_rename(	struct inode	*odir,	struct dentry	*odentry,	struct inode	*ndir,	struct dentry	*ndentry){	struct inode	*new_inode = ndentry->d_inode;	vnode_t		*fvp;	/* from directory */