Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 36f392d0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs 

* 'for-linus' of git://oss.sgi.com/xfs/xfs:
  Long btree pointers are still 64 bit on disk
  [XFS] Remove the rest of the macro-to-function indirections.
  xfs: sanity check attr fork size
  xfs: fix bad_features2 fixups for the root filesystem
  xfs: add a lock class for group/project dquots
  xfs: lockdep annotations for xfs_dqlock2
  xfs: add a separate lock class for the per-mount list of dquots
  xfs: use mnt_want_write in compat_attrmulti ioctl
  xfs: fix dentry aliasing issues in open_by_handle
parents 6c31e7ee 74e2d065

fs/xfs/Kconfig

+1 −0
Original line number Diff line number Diff line 
config XFS_FS

	tristate "XFS filesystem support"

	depends on BLOCK

	select EXPORTFS

	help

	  XFS is a high performance journaling filesystem which originated

	  on the SGI IRIX platform.  It is completely multi-threaded, can

fs/xfs/linux-2.6/xfs_ioctl.c

+137 −168
Original line number Diff line number Diff line
@@ -50,12 +50,14 @@ 
#include "xfs_vnodeops.h"

#include "xfs_quota.h"

#include "xfs_inode_item.h"

#include "xfs_export.h"



#include <linux/capability.h>

#include <linux/dcache.h>

#include <linux/mount.h>

#include <linux/namei.h>

#include <linux/pagemap.h>

#include <linux/exportfs.h>



/*

 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
@@ -164,97 +166,69 @@ xfs_find_handle( 
	return 0;

}





/*

 * Convert userspace handle data into inode.

 *

 * We use the fact that all the fsop_handlereq ioctl calls have a data

 * structure argument whose first component is always a xfs_fsop_handlereq_t,

 * so we can pass that sub structure into this handy, shared routine.

 *

 * If no error, caller must always iput the returned inode.

 * No need to do permission checks on the various pathname components

 * as the handle operations are privileged.

 */

STATIC int

xfs_vget_fsop_handlereq(

	xfs_mount_t		*mp,

	struct inode		*parinode,	/* parent inode pointer    */

	xfs_fsop_handlereq_t	*hreq,

	struct inode		**inode)

xfs_handle_acceptable(

	void			*context,

	struct dentry		*dentry)

{

	return 1;

}



/*

 * Convert userspace handle data into a dentry.

 */

struct dentry *

xfs_handle_to_dentry(

	struct file		*parfilp,

	void __user		*uhandle,

	u32			hlen)

{

	void			__user *hanp;

	size_t			hlen;

	xfs_fid_t		*xfid;

	xfs_handle_t		*handlep;

	xfs_handle_t		handle;

	xfs_inode_t		*ip;

	xfs_ino_t		ino;

	__u32			igen;

	int			error;

	struct xfs_fid64	fid;



	/*

	 * Only allow handle opens under a directory.

	 */

	if (!S_ISDIR(parinode->i_mode))

		return XFS_ERROR(ENOTDIR);

	if (!S_ISDIR(parfilp->f_path.dentry->d_inode->i_mode))

		return ERR_PTR(-ENOTDIR);



	hanp = hreq->ihandle;

	hlen = hreq->ihandlen;

	handlep = &handle;

	if (hlen != sizeof(xfs_handle_t))

		return ERR_PTR(-EINVAL);

	if (copy_from_user(&handle, uhandle, hlen))

		return ERR_PTR(-EFAULT);

	if (handle.ha_fid.fid_len !=

	    sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))

		return ERR_PTR(-EINVAL);



	if (hlen < sizeof(handlep->ha_fsid) || hlen > sizeof(*handlep))

		return XFS_ERROR(EINVAL);

	if (copy_from_user(handlep, hanp, hlen))

		return XFS_ERROR(EFAULT);

	if (hlen < sizeof(*handlep))

		memset(((char *)handlep) + hlen, 0, sizeof(*handlep) - hlen);

	if (hlen > sizeof(handlep->ha_fsid)) {

		if (handlep->ha_fid.fid_len !=

		    (hlen - sizeof(handlep->ha_fsid) -

		            sizeof(handlep->ha_fid.fid_len)) ||

		    handlep->ha_fid.fid_pad)

			return XFS_ERROR(EINVAL);

	}



	/*

	 * Crack the handle, obtain the inode # & generation #

	 */

	xfid = (struct xfs_fid *)&handlep->ha_fid;

	if (xfid->fid_len == sizeof(*xfid) - sizeof(xfid->fid_len)) {

		ino  = xfid->fid_ino;

		igen = xfid->fid_gen;

	} else {

		return XFS_ERROR(EINVAL);

	}

	memset(&fid, 0, sizeof(struct fid));

	fid.ino = handle.ha_fid.fid_ino;

	fid.gen = handle.ha_fid.fid_gen;



	/*

	 * Get the XFS inode, building a Linux inode to go with it.

	 */

	error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0);

	if (error)

		return error;

	if (ip == NULL)

		return XFS_ERROR(EIO);

	if (ip->i_d.di_gen != igen) {

		xfs_iput_new(ip, XFS_ILOCK_SHARED);

		return XFS_ERROR(ENOENT);

	return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,

			FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,

			xfs_handle_acceptable, NULL);

}



	xfs_iunlock(ip, XFS_ILOCK_SHARED);



	*inode = VFS_I(ip);

	return 0;

STATIC struct dentry *

xfs_handlereq_to_dentry(

	struct file		*parfilp,

	xfs_fsop_handlereq_t	*hreq)

{

	return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);

}



int

xfs_open_by_handle(

	xfs_mount_t		*mp,

	xfs_fsop_handlereq_t	*hreq,

	struct file		*parfilp,

	struct inode		*parinode)

	xfs_fsop_handlereq_t	*hreq)

{

	const struct cred	*cred = current_cred();

	int			error;

	int			new_fd;

	int			fd;

	int			permflag;

	struct file		*filp;

	struct inode		*inode;
@@ -263,19 +237,21 @@ xfs_open_by_handle( 
	if (!capable(CAP_SYS_ADMIN))

		return -XFS_ERROR(EPERM);



	error = xfs_vget_fsop_handlereq(mp, parinode, hreq, &inode);

	if (error)

		return -error;

	dentry = xfs_handlereq_to_dentry(parfilp, hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);

	inode = dentry->d_inode;



	/* Restrict xfs_open_by_handle to directories & regular files. */

	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {

		iput(inode);

		return -XFS_ERROR(EINVAL);

		error = -XFS_ERROR(EPERM);

		goto out_dput;

	}



#if BITS_PER_LONG != 32

	hreq->oflags |= O_LARGEFILE;

#endif



	/* Put open permission in namei format. */

	permflag = hreq->oflags;

	if ((permflag+1) & O_ACCMODE)
@@ -285,50 +261,45 @@ xfs_open_by_handle( 


	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&

	    (permflag & FMODE_WRITE) && IS_APPEND(inode)) {

		iput(inode);

		return -XFS_ERROR(EPERM);

		error = -XFS_ERROR(EPERM);

		goto out_dput;

	}



	if ((permflag & FMODE_WRITE) && IS_IMMUTABLE(inode)) {

		iput(inode);

		return -XFS_ERROR(EACCES);

		error = -XFS_ERROR(EACCES);

		goto out_dput;

	}



	/* Can't write directories. */

	if (S_ISDIR(inode->i_mode) && (permflag & FMODE_WRITE)) {

		iput(inode);

		return -XFS_ERROR(EISDIR);

		error = -XFS_ERROR(EISDIR);

		goto out_dput;

	}



	if ((new_fd = get_unused_fd()) < 0) {

		iput(inode);

		return new_fd;

	fd = get_unused_fd();

	if (fd < 0) {

		error = fd;

		goto out_dput;

	}



	dentry = d_obtain_alias(inode);

	if (IS_ERR(dentry)) {

		put_unused_fd(new_fd);

		return PTR_ERR(dentry);

	}



	/* Ensure umount returns EBUSY on umounts while this file is open. */

	mntget(parfilp->f_path.mnt);



	/* Create file pointer. */

	filp = dentry_open(dentry, parfilp->f_path.mnt, hreq->oflags, cred);

	filp = dentry_open(dentry, mntget(parfilp->f_path.mnt),

			   hreq->oflags, cred);

	if (IS_ERR(filp)) {

		put_unused_fd(new_fd);

		return -XFS_ERROR(-PTR_ERR(filp));

		put_unused_fd(fd);

		return PTR_ERR(filp);

	}



	if (inode->i_mode & S_IFREG) {

		/* invisible operation should not change atime */

		filp->f_flags |= O_NOATIME;

		filp->f_mode |= FMODE_NOCMTIME;

	}



	fd_install(new_fd, filp);

	return new_fd;

	fd_install(fd, filp);

	return fd;



 out_dput:

	dput(dentry);

	return error;

}



/*
@@ -359,11 +330,10 @@ do_readlink( 


int

xfs_readlink_by_handle(

	xfs_mount_t		*mp,

	xfs_fsop_handlereq_t	*hreq,

	struct inode		*parinode)

	struct file		*parfilp,

	xfs_fsop_handlereq_t	*hreq)

{

	struct inode		*inode;

	struct dentry		*dentry;

	__u32			olen;

	void			*link;

	int			error;
@@ -371,26 +341,28 @@ xfs_readlink_by_handle( 
	if (!capable(CAP_SYS_ADMIN))

		return -XFS_ERROR(EPERM);



	error = xfs_vget_fsop_handlereq(mp, parinode, hreq, &inode);

	if (error)

		return -error;

	dentry = xfs_handlereq_to_dentry(parfilp, hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	/* Restrict this handle operation to symlinks only. */

	if (!S_ISLNK(inode->i_mode)) {

	if (!S_ISLNK(dentry->d_inode->i_mode)) {

		error = -XFS_ERROR(EINVAL);

		goto out_iput;

		goto out_dput;

	}



	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {

		error = -XFS_ERROR(EFAULT);

		goto out_iput;

		goto out_dput;

	}



	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);

	if (!link)

		goto out_iput;

	if (!link) {

		error = -XFS_ERROR(ENOMEM);

		goto out_dput;

	}



	error = -xfs_readlink(XFS_I(inode), link);

	error = -xfs_readlink(XFS_I(dentry->d_inode), link);

	if (error)

		goto out_kfree;

	error = do_readlink(hreq->ohandle, olen, link);
@@ -399,32 +371,31 @@ xfs_readlink_by_handle( 


 out_kfree:

	kfree(link);

 out_iput:

	iput(inode);

 out_dput:

	dput(dentry);

	return error;

}



STATIC int

xfs_fssetdm_by_handle(

	xfs_mount_t		*mp,

	void			__user *arg,

	struct inode		*parinode)

	struct file		*parfilp,

	void			__user *arg)

{

	int			error;

	struct fsdmidata	fsd;

	xfs_fsop_setdm_handlereq_t dmhreq;

	struct inode		*inode;

	struct dentry		*dentry;



	if (!capable(CAP_MKNOD))

		return -XFS_ERROR(EPERM);

	if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))

		return -XFS_ERROR(EFAULT);



	error = xfs_vget_fsop_handlereq(mp, parinode, &dmhreq.hreq, &inode);

	if (error)

		return -error;

	dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {

	if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {

		error = -XFS_ERROR(EPERM);

		goto out;

	}
@@ -434,24 +405,23 @@ xfs_fssetdm_by_handle( 
		goto out;

	}



	error = -xfs_set_dmattrs(XFS_I(inode), fsd.fsd_dmevmask,

	error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,

				 fsd.fsd_dmstate);



 out:

	iput(inode);

	dput(dentry);

	return error;

}



STATIC int

xfs_attrlist_by_handle(

	xfs_mount_t		*mp,

	void			__user *arg,

	struct inode		*parinode)

	struct file		*parfilp,

	void			__user *arg)

{

	int			error;

	int			error = -ENOMEM;

	attrlist_cursor_kern_t	*cursor;

	xfs_fsop_attrlist_handlereq_t al_hreq;

	struct inode		*inode;

	struct dentry		*dentry;

	char			*kbuf;



	if (!capable(CAP_SYS_ADMIN))
@@ -467,16 +437,16 @@ xfs_attrlist_by_handle( 
	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))

		return -XFS_ERROR(EINVAL);



	error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);

	if (error)

		goto out;

	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);

	if (!kbuf)

		goto out_vn_rele;

		goto out_dput;



	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;

	error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,

	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,

					al_hreq.flags, cursor);

	if (error)

		goto out_kfree;
@@ -486,10 +456,9 @@ xfs_attrlist_by_handle( 


 out_kfree:

	kfree(kbuf);

 out_vn_rele:

	iput(inode);

 out:

	return -error;

 out_dput:

	dput(dentry);

	return error;

}



int
@@ -564,15 +533,13 @@ xfs_attrmulti_attr_remove( 


STATIC int

xfs_attrmulti_by_handle(

	xfs_mount_t		*mp,

	void			__user *arg,

	struct file		*parfilp,

	struct inode		*parinode)

	void			__user *arg)

{

	int			error;

	xfs_attr_multiop_t	*ops;

	xfs_fsop_attrmulti_handlereq_t am_hreq;

	struct inode		*inode;

	struct dentry		*dentry;

	unsigned int		i, size;

	char			*attr_name;
@@ -581,19 +548,19 @@ xfs_attrmulti_by_handle( 
	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))

		return -XFS_ERROR(EFAULT);



	error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);

	if (error)

		goto out;

	dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	error = E2BIG;

	size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);

	if (!size || size > 16 * PAGE_SIZE)

		goto out_vn_rele;

		goto out_dput;



	error = ENOMEM;

	ops = kmalloc(size, GFP_KERNEL);

	if (!ops)

		goto out_vn_rele;

		goto out_dput;



	error = EFAULT;

	if (copy_from_user(ops, am_hreq.ops, size))
@@ -615,25 +582,28 @@ xfs_attrmulti_by_handle( 


		switch (ops[i].am_opcode) {

		case ATTR_OP_GET:

			ops[i].am_error = xfs_attrmulti_attr_get(inode,

					attr_name, ops[i].am_attrvalue,

					&ops[i].am_length, ops[i].am_flags);

			ops[i].am_error = xfs_attrmulti_attr_get(

					dentry->d_inode, attr_name,

					ops[i].am_attrvalue, &ops[i].am_length,

					ops[i].am_flags);

			break;

		case ATTR_OP_SET:

			ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);

			if (ops[i].am_error)

				break;

			ops[i].am_error = xfs_attrmulti_attr_set(inode,

					attr_name, ops[i].am_attrvalue,

					ops[i].am_length, ops[i].am_flags);

			ops[i].am_error = xfs_attrmulti_attr_set(

					dentry->d_inode, attr_name,

					ops[i].am_attrvalue, ops[i].am_length,

					ops[i].am_flags);

			mnt_drop_write(parfilp->f_path.mnt);

			break;

		case ATTR_OP_REMOVE:

			ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);

			if (ops[i].am_error)

				break;

			ops[i].am_error = xfs_attrmulti_attr_remove(inode,

					attr_name, ops[i].am_flags);

			ops[i].am_error = xfs_attrmulti_attr_remove(

					dentry->d_inode, attr_name,

					ops[i].am_flags);

			mnt_drop_write(parfilp->f_path.mnt);

			break;

		default:
@@ -647,9 +617,8 @@ xfs_attrmulti_by_handle( 
	kfree(attr_name);

 out_kfree_ops:

	kfree(ops);

 out_vn_rele:

	iput(inode);

 out:

 out_dput:

	dput(dentry);

	return -error;

}
@@ -1440,23 +1409,23 @@ xfs_file_ioctl( 


		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))

			return -XFS_ERROR(EFAULT);

		return xfs_open_by_handle(mp, &hreq, filp, inode);

		return xfs_open_by_handle(filp, &hreq);

	}

	case XFS_IOC_FSSETDM_BY_HANDLE:

		return xfs_fssetdm_by_handle(mp, arg, inode);

		return xfs_fssetdm_by_handle(filp, arg);



	case XFS_IOC_READLINK_BY_HANDLE: {

		xfs_fsop_handlereq_t	hreq;



		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))

			return -XFS_ERROR(EFAULT);

		return xfs_readlink_by_handle(mp, &hreq, inode);

		return xfs_readlink_by_handle(filp, &hreq);

	}

	case XFS_IOC_ATTRLIST_BY_HANDLE:

		return xfs_attrlist_by_handle(mp, arg, inode);

		return xfs_attrlist_by_handle(filp, arg);



	case XFS_IOC_ATTRMULTI_BY_HANDLE:

		return xfs_attrmulti_by_handle(mp, arg, filp, inode);

		return xfs_attrmulti_by_handle(filp, arg);



	case XFS_IOC_SWAPEXT: {

		struct xfs_swapext	sxp;

fs/xfs/linux-2.6/xfs_ioctl.h

+9 −6
Original line number Diff line number Diff line
@@ -34,16 +34,13 @@ xfs_find_handle( 


extern int

xfs_open_by_handle(

	xfs_mount_t		*mp,

	xfs_fsop_handlereq_t	*hreq,

	struct file		*parfilp,

	struct inode		*parinode);

	xfs_fsop_handlereq_t	*hreq);



extern int

xfs_readlink_by_handle(

	xfs_mount_t		*mp,

	xfs_fsop_handlereq_t	*hreq,

	struct inode		*parinode);

	struct file		*parfilp,

	xfs_fsop_handlereq_t	*hreq);



extern int

xfs_attrmulti_attr_get(
@@ -67,6 +64,12 @@ xfs_attrmulti_attr_remove( 
	char			*name,

	__uint32_t		flags);



extern struct dentry *

xfs_handle_to_dentry(

	struct file		*parfilp,

	void __user		*uhandle,

	u32			hlen);



extern long

xfs_file_ioctl(

	struct file		*filp,

fs/xfs/linux-2.6/xfs_ioctl32.c

+58 −126
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
 */

#include <linux/compat.h>

#include <linux/ioctl.h>

#include <linux/mount.h>

#include <asm/uaccess.h>

#include "xfs.h"

#include "xfs_fs.h"
@@ -340,96 +341,24 @@ xfs_compat_handlereq_copyin( 
	return 0;

}



/*

 * Convert userspace handle data into inode.

 *

 * We use the fact that all the fsop_handlereq ioctl calls have a data

 * structure argument whose first component is always a xfs_fsop_handlereq_t,

 * so we can pass that sub structure into this handy, shared routine.

 *

 * If no error, caller must always iput the returned inode.

 */

STATIC int

xfs_vget_fsop_handlereq_compat(

	xfs_mount_t		*mp,

	struct inode		*parinode,	/* parent inode pointer    */

	compat_xfs_fsop_handlereq_t	*hreq,

	struct inode		**inode)

STATIC struct dentry *

xfs_compat_handlereq_to_dentry(

	struct file		*parfilp,

	compat_xfs_fsop_handlereq_t *hreq)

{

	void			__user *hanp;

	size_t			hlen;

	xfs_fid_t		*xfid;

	xfs_handle_t		*handlep;

	xfs_handle_t		handle;

	xfs_inode_t		*ip;

	xfs_ino_t		ino;

	__u32			igen;

	int			error;



	/*

	 * Only allow handle opens under a directory.

	 */

	if (!S_ISDIR(parinode->i_mode))

		return XFS_ERROR(ENOTDIR);



	hanp = compat_ptr(hreq->ihandle);

	hlen = hreq->ihandlen;

	handlep = &handle;



	if (hlen < sizeof(handlep->ha_fsid) || hlen > sizeof(*handlep))

		return XFS_ERROR(EINVAL);

	if (copy_from_user(handlep, hanp, hlen))

		return XFS_ERROR(EFAULT);

	if (hlen < sizeof(*handlep))

		memset(((char *)handlep) + hlen, 0, sizeof(*handlep) - hlen);

	if (hlen > sizeof(handlep->ha_fsid)) {

		if (handlep->ha_fid.fid_len !=

		    (hlen - sizeof(handlep->ha_fsid) -

			    sizeof(handlep->ha_fid.fid_len)) ||

		    handlep->ha_fid.fid_pad)

			return XFS_ERROR(EINVAL);

	}



	/*

	 * Crack the handle, obtain the inode # & generation #

	 */

	xfid = (struct xfs_fid *)&handlep->ha_fid;

	if (xfid->fid_len == sizeof(*xfid) - sizeof(xfid->fid_len)) {

		ino  = xfid->fid_ino;

		igen = xfid->fid_gen;

	} else {

		return XFS_ERROR(EINVAL);

	}



	/*

	 * Get the XFS inode, building a Linux inode to go with it.

	 */

	error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0);

	if (error)

		return error;

	if (ip == NULL)

		return XFS_ERROR(EIO);

	if (ip->i_d.di_gen != igen) {

		xfs_iput_new(ip, XFS_ILOCK_SHARED);

		return XFS_ERROR(ENOENT);

	}



	xfs_iunlock(ip, XFS_ILOCK_SHARED);



	*inode = VFS_I(ip);

	return 0;

	return xfs_handle_to_dentry(parfilp,

			compat_ptr(hreq->ihandle), hreq->ihandlen);

}



STATIC int

xfs_compat_attrlist_by_handle(

	xfs_mount_t		*mp,

	void			__user *arg,

	struct inode		*parinode)

	struct file		*parfilp,

	void			__user *arg)

{

	int			error;

	attrlist_cursor_kern_t	*cursor;

	compat_xfs_fsop_attrlist_handlereq_t al_hreq;

	struct inode		*inode;

	struct dentry		*dentry;

	char			*kbuf;



	if (!capable(CAP_SYS_ADMIN))
@@ -446,17 +375,17 @@ xfs_compat_attrlist_by_handle( 
	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))

		return -XFS_ERROR(EINVAL);



	error = xfs_vget_fsop_handlereq_compat(mp, parinode, &al_hreq.hreq,

					       &inode);

	if (error)

		goto out;

	dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	error = -ENOMEM;

	kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);

	if (!kbuf)

		goto out_vn_rele;

		goto out_dput;



	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;

	error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,

	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,

					al_hreq.flags, cursor);

	if (error)

		goto out_kfree;
@@ -466,22 +395,20 @@ xfs_compat_attrlist_by_handle( 


 out_kfree:

	kfree(kbuf);

 out_vn_rele:

	iput(inode);

 out:

	return -error;

 out_dput:

	dput(dentry);

	return error;

}



STATIC int

xfs_compat_attrmulti_by_handle(

	xfs_mount_t				*mp,

	void					__user *arg,

	struct inode				*parinode)

	struct file				*parfilp,

	void					__user *arg)

{

	int					error;

	compat_xfs_attr_multiop_t		*ops;

	compat_xfs_fsop_attrmulti_handlereq_t	am_hreq;

	struct inode				*inode;

	struct dentry				*dentry;

	unsigned int				i, size;

	char					*attr_name;
@@ -491,20 +418,19 @@ xfs_compat_attrmulti_by_handle( 
			   sizeof(compat_xfs_fsop_attrmulti_handlereq_t)))

		return -XFS_ERROR(EFAULT);



	error = xfs_vget_fsop_handlereq_compat(mp, parinode, &am_hreq.hreq,

					       &inode);

	if (error)

		goto out;

	dentry = xfs_compat_handlereq_to_dentry(parfilp, &am_hreq.hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	error = E2BIG;

	size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t);

	if (!size || size > 16 * PAGE_SIZE)

		goto out_vn_rele;

		goto out_dput;



	error = ENOMEM;

	ops = kmalloc(size, GFP_KERNEL);

	if (!ops)

		goto out_vn_rele;

		goto out_dput;



	error = EFAULT;

	if (copy_from_user(ops, compat_ptr(am_hreq.ops), size))
@@ -527,20 +453,29 @@ xfs_compat_attrmulti_by_handle( 


		switch (ops[i].am_opcode) {

		case ATTR_OP_GET:

			ops[i].am_error = xfs_attrmulti_attr_get(inode,

					attr_name,

			ops[i].am_error = xfs_attrmulti_attr_get(

					dentry->d_inode, attr_name,

					compat_ptr(ops[i].am_attrvalue),

					&ops[i].am_length, ops[i].am_flags);

			break;

		case ATTR_OP_SET:

			ops[i].am_error = xfs_attrmulti_attr_set(inode,

					attr_name,

			ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);

			if (ops[i].am_error)

				break;

			ops[i].am_error = xfs_attrmulti_attr_set(

					dentry->d_inode, attr_name,

					compat_ptr(ops[i].am_attrvalue),

					ops[i].am_length, ops[i].am_flags);

			mnt_drop_write(parfilp->f_path.mnt);

			break;

		case ATTR_OP_REMOVE:

			ops[i].am_error = xfs_attrmulti_attr_remove(inode,

					attr_name, ops[i].am_flags);

			ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);

			if (ops[i].am_error)

				break;

			ops[i].am_error = xfs_attrmulti_attr_remove(

					dentry->d_inode, attr_name,

					ops[i].am_flags);

			mnt_drop_write(parfilp->f_path.mnt);

			break;

		default:

			ops[i].am_error = EINVAL;
@@ -553,22 +488,20 @@ xfs_compat_attrmulti_by_handle( 
	kfree(attr_name);

 out_kfree_ops:

	kfree(ops);

 out_vn_rele:

	iput(inode);

 out:

 out_dput:

	dput(dentry);

	return -error;

}



STATIC int

xfs_compat_fssetdm_by_handle(

	xfs_mount_t		*mp,

	void			__user *arg,

	struct inode		*parinode)

	struct file		*parfilp,

	void			__user *arg)

{

	int			error;

	struct fsdmidata	fsd;

	compat_xfs_fsop_setdm_handlereq_t dmhreq;

	struct inode		*inode;

	struct dentry		*dentry;



	if (!capable(CAP_MKNOD))

		return -XFS_ERROR(EPERM);
@@ -576,12 +509,11 @@ xfs_compat_fssetdm_by_handle( 
			   sizeof(compat_xfs_fsop_setdm_handlereq_t)))

		return -XFS_ERROR(EFAULT);



	error = xfs_vget_fsop_handlereq_compat(mp, parinode, &dmhreq.hreq,

					       &inode);

	if (error)

		return -error;

	dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {

	if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {

		error = -XFS_ERROR(EPERM);

		goto out;

	}
@@ -591,11 +523,11 @@ xfs_compat_fssetdm_by_handle( 
		goto out;

	}



	error = -xfs_set_dmattrs(XFS_I(inode), fsd.fsd_dmevmask,

	error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,

				 fsd.fsd_dmstate);



out:

	iput(inode);

	dput(dentry);

	return error;

}
@@ -722,21 +654,21 @@ xfs_file_compat_ioctl( 


		if (xfs_compat_handlereq_copyin(&hreq, arg))

			return -XFS_ERROR(EFAULT);

		return xfs_open_by_handle(mp, &hreq, filp, inode);

		return xfs_open_by_handle(filp, &hreq);

	}

	case XFS_IOC_READLINK_BY_HANDLE_32: {

		struct xfs_fsop_handlereq	hreq;



		if (xfs_compat_handlereq_copyin(&hreq, arg))

			return -XFS_ERROR(EFAULT);

		return xfs_readlink_by_handle(mp, &hreq, inode);

		return xfs_readlink_by_handle(filp, &hreq);

	}

	case XFS_IOC_ATTRLIST_BY_HANDLE_32:

		return xfs_compat_attrlist_by_handle(mp, arg, inode);

		return xfs_compat_attrlist_by_handle(filp, arg);

	case XFS_IOC_ATTRMULTI_BY_HANDLE_32:

		return xfs_compat_attrmulti_by_handle(mp, arg, inode);

		return xfs_compat_attrmulti_by_handle(filp, arg);

	case XFS_IOC_FSSETDM_BY_HANDLE_32:

		return xfs_compat_fssetdm_by_handle(mp, arg, inode);

		return xfs_compat_fssetdm_by_handle(filp, arg);

	default:

		return -XFS_ERROR(ENOIOCTLCMD);

	}

fs/xfs/linux-2.6/xfs_super.c

+16 −1
Original line number Diff line number Diff line
@@ -1197,6 +1197,7 @@ xfs_fs_remount( 
	struct xfs_mount	*mp = XFS_M(sb);

	substring_t		args[MAX_OPT_ARGS];

	char			*p;

	int			error;



	while ((p = strsep(&options, ",")) != NULL) {

		int token;
@@ -1247,11 +1248,25 @@ xfs_fs_remount( 
		}

	}



	/* rw/ro -> rw */

	/* ro -> rw */

	if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {

		mp->m_flags &= ~XFS_MOUNT_RDONLY;

		if (mp->m_flags & XFS_MOUNT_BARRIER)

			xfs_mountfs_check_barriers(mp);



		/*

		 * If this is the first remount to writeable state we

		 * might have some superblock changes to update.

		 */

		if (mp->m_update_flags) {

			error = xfs_mount_log_sb(mp, mp->m_update_flags);

			if (error) {

				cmn_err(CE_WARN,

					"XFS: failed to write sb changes");

				return error;

			}

			mp->m_update_flags = 0;

		}

	}



	/* rw -> ro */