remove inode_setattr

Replace inode_setattr with opencoded variants of it in all callers. This moves the remaining call to vmtruncate into the filesystem methods where it can be replaced with the proper truncate sequence. In a few cases it was obvious that we would never end up calling vmtruncate so it was left out in the opencoded variant: spufs: explicitly checks for ATTR_SIZE earlier btrfs,hugetlbfs,logfs,dlmfs: explicitly clears ATTR_SIZE earlier ufs: contains an opencoded simple_seattr + truncate that sets the filesize just above In addition to that ncpfs called inode_setattr with handcrafted iattrs, which allowed to trim down the opencoded variant. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

remove inode_setattr
Replace inode_setattr with opencoded variants of it in all callers. This moves the remaining call to vmtruncate into the filesystem methods where it can be replaced with the proper truncate sequence. In a few cases it was obvious that we would never end up calling vmtruncate so it was left out in the opencoded variant: spufs: explicitly checks for ATTR_SIZE earlier btrfs,hugetlbfs,logfs,dlmfs: explicitly clears ATTR_SIZE earlier ufs: contains an opencoded simple_seattr + truncate that sets the filesize just above In addition to that ncpfs called inode_setattr with handcrafted iattrs, which allowed to trim down the opencoded variant. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Christoph Hellwig · Al Viro
1 parent eef2380c18
Showing 35 changed files with 416 additions and 194 deletions Side-by-side Diff
arch/powerpc/platforms/cell/spufs/inode.c
drivers/staging/pohmelfs/inode.c
fs/9p/vfs_inode.c
fs/affs/inode.c
fs/attr.c
fs/btrfs/inode.c
fs/cifs/inode.c
fs/exofs/inode.c
fs/ext3/inode.c
fs/ext4/inode.c
fs/gfs2/inode.c
fs/gfs2/ops_inode.c
fs/gfs2/xattr.c
fs/hfs/inode.c
fs/hfsplus/inode.c
fs/hostfs/hostfs_kern.c
fs/hpfs/inode.c
fs/hugetlbfs/inode.c
fs/jfs/file.c
fs/logfs/file.c
@@ -110,7 +110,9 @@
 	if ((attr->ia_valid & ATTR_SIZE) &&
 	    (attr->ia_size != inode->i_size))
 		return -EINVAL;
-	return inode_setattr(inode, attr);
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
  
@@ -968,11 +968,17 @@
 		goto err_out_exit;
 	}
  
-	err = inode_setattr(inode, attr);
-	if (err) {
-		dprintk("%s: ino: %llu, failed to set the attributes.\n", __func__, POHMELFS_I(inode)->ino);
-		goto err_out_exit;
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		err = vmtruncate(inode, attr->ia_size);
+		if (err) {
+			dprintk("%s: ino: %llu, failed to set the attributes.\n", __func__, POHMELFS_I(inode)->ino);
+			goto err_out_exit;
+		}
 	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
  
 	dprintk("%s: ino: %llu, mode: %o -> %o, uid: %u -> %u, gid: %u -> %u, size: %llu -> %llu.\n",
 			__func__, POHMELFS_I(inode)->ino, inode->i_mode, attr->ia_mode,
@@ -896,10 +896,19 @@
 	}
  
 	retval = p9_client_wstat(fid, &wstat);
-	if (retval >= 0)
-		retval = inode_setattr(dentry->d_inode, iattr);
+	if (retval < 0)
+		return retval;
  
-	return retval;
+	if ((iattr->ia_valid & ATTR_SIZE) &&
+	    iattr->ia_size != i_size_read(dentry->d_inode)) {
+		retval = vmtruncate(dentry->d_inode, iattr->ia_size);
+		if (retval)
+			return retval;
+	}
+
+	setattr_copy(dentry->d_inode, iattr);
+	mark_inode_dirty(dentry->d_inode);
+	return 0;
 }
  
 /**
@@ -235,8 +235,17 @@
 		goto out;
 	}
  
-	error = inode_setattr(inode, attr);
-	if (!error && (attr->ia_valid & ATTR_MODE))
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+
+	if (attr->ia_valid & ATTR_MODE)
 		mode_to_prot(inode);
 out:
 	return error;
@@ -146,31 +146,6 @@
 }
 EXPORT_SYMBOL(setattr_copy);
  
-/*
- * note this function is deprecated, the new truncate sequence should be
- * used instead -- see eg. simple_setsize, setattr_copy.
- */
-int inode_setattr(struct inode *inode, const struct iattr *attr)
-{
-	unsigned int ia_valid = attr->ia_valid;
-
-	if (ia_valid & ATTR_SIZE &&
-	    attr->ia_size != i_size_read(inode)) {
-		int error;
-
-		error = vmtruncate(inode, attr->ia_size);
-		if (error)
-			return error;
-	}
-
-	setattr_copy(inode, attr);
-
-	mark_inode_dirty(inode);
-
-	return 0;
-}
-EXPORT_SYMBOL(inode_setattr);
-
 int notify_change(struct dentry * dentry, struct iattr * attr)
 {
 	struct inode *inode = dentry->d_inode;
@@ -3656,13 +3656,15 @@
 		if (err)
 			return err;
 	}
-	attr->ia_valid &= ~ATTR_SIZE;
  
-	if (attr->ia_valid)
-		err = inode_setattr(inode, attr);
+	if (attr->ia_valid) {
+		setattr_copy(inode, attr);
+		mark_inode_dirty(inode);
  
-	if (!err && ((attr->ia_valid & ATTR_MODE)))
-		err = btrfs_acl_chmod(inode);
+		if (attr->ia_valid & ATTR_MODE)
+			err = btrfs_acl_chmod(inode);
+	}
+
 	return err;
 }
  
@@ -1889,18 +1889,27 @@
 					CIFS_MOUNT_MAP_SPECIAL_CHR);
 	}
  
-	if (!rc) {
-		rc = inode_setattr(inode, attrs);
+	if (rc)
+		goto out;
  
-		/* force revalidate when any of these times are set since some
-		   of the fs types (eg ext3, fat) do not have fine enough
-		   time granularity to match protocol, and we do not have a
-		   a way (yet) to query the server fs's time granularity (and
-		   whether it rounds times down).
-		*/
-		if (!rc && (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME)))
-			cifsInode->time = 0;
+	if ((attrs->ia_valid & ATTR_SIZE) &&
+	    attrs->ia_size != i_size_read(inode)) {
+		rc = vmtruncate(inode, attrs->ia_size);
+		if (rc)
+			goto out;
 	}
+
+	setattr_copy(inode, attrs);
+	mark_inode_dirty(inode);
+
+	/* force revalidate when any of these times are set since some
+	   of the fs types (eg ext3, fat) do not have fine enough
+	   time granularity to match protocol, and we do not have a
+	   a way (yet) to query the server fs's time granularity (and
+	   whether it rounds times down).
+	*/
+	if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
+		cifsInode->time = 0;
 out:
 	kfree(args);
 	kfree(full_path);
@@ -2040,8 +2049,20 @@
  
 	/* do not need local check to inode_check_ok since the server does
 	   that */
-	if (!rc)
-		rc = inode_setattr(inode, attrs);
+	if (rc)
+		goto cifs_setattr_exit;
+
+	if ((attrs->ia_valid & ATTR_SIZE) &&
+	    attrs->ia_size != i_size_read(inode)) {
+		rc = vmtruncate(inode, attrs->ia_size);
+		if (rc)
+			goto cifs_setattr_exit;
+	}
+
+	setattr_copy(inode, attrs);
+	mark_inode_dirty(inode);
+	return 0;
+
 cifs_setattr_exit:
 	kfree(full_path);
 	FreeXid(xid);
@@ -887,8 +887,18 @@
 	if (error)
 		return error;
  
-	error = inode_setattr(inode, iattr);
-	return error;
+	if ((iattr->ia_valid & ATTR_SIZE) &&
+	    iattr->ia_size != i_size_read(inode)) {
+		int error;
+
+		error = vmtruncate(inode, iattr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, iattr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static const struct osd_attr g_attr_inode_file_layout = ATTR_DEF(
@@ -3208,9 +3208,17 @@
 		ext3_journal_stop(handle);
 	}
  
-	rc = inode_setattr(inode, attr);
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		rc = vmtruncate(inode, attr->ia_size);
+		if (rc)
+			goto err_out;
+	}
  
-	if (!rc && (ia_valid & ATTR_MODE))
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+
+	if (ia_valid & ATTR_MODE)
 		rc = ext3_acl_chmod(inode);
  
 err_out:
@@ -5539,11 +5539,19 @@
 			ext4_truncate(inode);
 	}
  
-	rc = inode_setattr(inode, attr);
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode))
+		rc = vmtruncate(inode, attr->ia_size);
  
-	/* If inode_setattr's call to ext4_truncate failed to get a
-	 * transaction handle at all, we need to clean up the in-core
-	 * orphan list manually. */
+	if (!rc) {
+		setattr_copy(inode, attr);
+		mark_inode_dirty(inode);
+	}
+
+	/*
+	 * If the call to ext4_truncate failed to get a transaction handle at
+	 * all, we need to clean up the in-core orphan list manually.
+	 */
 	if (inode->i_nlink)
 		ext4_orphan_del(NULL, inode);
  
@@ -991,18 +991,29 @@
  
 static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
 {
+	struct inode *inode = &ip->i_inode;
 	struct buffer_head *dibh;
 	int error;
  
 	error = gfs2_meta_inode_buffer(ip, &dibh);
-	if (!error) {
-		error = inode_setattr(&ip->i_inode, attr);
-		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
-		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-		gfs2_dinode_out(ip, dibh->b_data);
-		brelse(dibh);
+	if (error)
+		return error;
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
 	}
-	return error;
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+
+	gfs2_assert_warn(GFS2_SB(inode), !error);
+	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+	gfs2_dinode_out(ip, dibh->b_data);
+	brelse(dibh);
+	return 0;
 }
  
 /**
@@ -1136,8 +1136,16 @@
 	if (error)
 		goto out_end_trans;
  
-	error = inode_setattr(inode, attr);
-	gfs2_assert_warn(sdp, !error);
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		int error;
+
+		error = vmtruncate(inode, attr->ia_size);
+		gfs2_assert_warn(sdp, !error);
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
  
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_dinode_out(ip, dibh->b_data);
@@ -1296,6 +1296,7 @@
  
 int gfs2_xattr_acl_chmod(struct gfs2_inode *ip, struct iattr *attr, char *data)
 {
+	struct inode *inode = &ip->i_inode;
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	struct gfs2_ea_location el;
 	struct buffer_head *dibh;
  
@@ -1321,14 +1322,25 @@
 		return error;
  
 	error = gfs2_meta_inode_buffer(ip, &dibh);
-	if (!error) {
-		error = inode_setattr(&ip->i_inode, attr);
-		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
-		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-		gfs2_dinode_out(ip, dibh->b_data);
-		brelse(dibh);
+	if (error)
+		goto out_trans_end;
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		int error;
+
+		error = vmtruncate(inode, attr->ia_size);
+		gfs2_assert_warn(GFS2_SB(inode), !error);
 	}
  
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+
+	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+	gfs2_dinode_out(ip, dibh->b_data);
+	brelse(dibh);
+
+out_trans_end:
 	gfs2_trans_end(sdp);
 	return error;
 }
@@ -612,10 +612,16 @@
 			attr->ia_mode = inode->i_mode & ~S_IWUGO;
 		attr->ia_mode &= S_ISDIR(inode->i_mode) ? ~hsb->s_dir_umask: ~hsb->s_file_umask;
 	}
-	error = inode_setattr(inode, attr);
-	if (error)
-		return error;
  
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
 	return 0;
 }
  
@@ -298,7 +298,17 @@
 	error = inode_change_ok(inode, attr);
 	if (error)
 		return error;
-	return inode_setattr(inode, attr);
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static const struct inode_operations hfsplus_file_inode_operations = {
@@ -849,13 +849,14 @@
  
 int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
+	struct inode *inode = dentry->d_inode;
 	struct hostfs_iattr attrs;
 	char *name;
 	int err;
  
-	int fd = HOSTFS_I(dentry->d_inode)->fd;
+	int fd = HOSTFS_I(inode)->fd;
  
-	err = inode_change_ok(dentry->d_inode, attr);
+	err = inode_change_ok(inode, attr);
 	if (err)
 		return err;
  
@@ -905,7 +906,18 @@
 	if (err)
 		return err;
  
-	return inode_setattr(dentry->d_inode, attr);
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		int error;
+
+		error = vmtruncate(inode, attr->ia_size);
+		if (err)
+			return err;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static const struct inode_operations hostfs_iops = {
@@ -277,9 +277,15 @@
 	if (error)
 		goto out_unlock;
  
-	error = inode_setattr(inode, attr);
-	if (error)
-		goto out_unlock;
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
  
 	hpfs_write_inode(inode);
  
@@ -448,19 +448,20 @@
  
 	error = inode_change_ok(inode, attr);
 	if (error)
-		goto out;
+		return error;
  
 	if (ia_valid & ATTR_SIZE) {
 		error = -EINVAL;
-		if (!(attr->ia_size & ~huge_page_mask(h)))
-			error = hugetlb_vmtruncate(inode, attr->ia_size);
+		if (attr->ia_size & ~huge_page_mask(h))
+			return -EINVAL;
+		error = hugetlb_vmtruncate(inode, attr->ia_size);
 		if (error)
-			goto out;
-		attr->ia_valid &= ~ATTR_SIZE;
+			return error;
 	}
-	error = inode_setattr(inode, attr);
-out:
-	return error;
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static struct inode *hugetlbfs_get_inode(struct super_block *sb, uid_t uid, 
@@ -17,6 +17,7 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  
+#include <linux/mm.h>
 #include <linux/fs.h>
 #include <linux/quotaops.h>
 #include "jfs_incore.h"
  
  
@@ -107,11 +108,18 @@
 			return rc;
 	}
  
-	rc = inode_setattr(inode, iattr);
+	if ((iattr->ia_valid & ATTR_SIZE) &&
+	    iattr->ia_size != i_size_read(inode)) {
+		rc = vmtruncate(inode, iattr->ia_size);
+		if (rc)
+			return rc;
+	}
  
-	if (!rc && (iattr->ia_valid & ATTR_MODE))
-		rc = jfs_acl_chmod(inode);
+	setattr_copy(inode, iattr);
+	mark_inode_dirty(inode);
  
+	if (iattr->ia_valid & ATTR_MODE)
+		rc = jfs_acl_chmod(inode);
 	return rc;
 }
  
@@ -232,15 +232,19 @@
 	struct inode *inode = dentry->d_inode;
 	int err = 0;
  
-	if (attr->ia_valid & ATTR_SIZE)
+	if (attr->ia_valid & ATTR_SIZE) {
 		err = logfs_truncate(inode, attr->ia_size);
-	attr->ia_valid &= ~ATTR_SIZE;
+		if (err)
+			return err;
+	}
  
-	if (!err)
-		err = inode_change_ok(inode, attr);
-	if (!err)
-		err = inode_setattr(inode, attr);
-	return err;
+	err = inode_change_ok(inode, attr);
+	if (err)
+		return err;
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 const struct inode_operations logfs_reg_iops = {
@@ -31,7 +31,17 @@
 	error = inode_change_ok(inode, attr);
 	if (error)
 		return error;
-	return inode_setattr(inode, attr);
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 const struct inode_operations minix_file_inode_operations = {
@@ -924,9 +924,8 @@
 				tmpattr.ia_valid = ATTR_MODE;
 				tmpattr.ia_mode = attr->ia_mode;
  
-				result = inode_setattr(inode, &tmpattr);
-				if (result)
-					goto out;
+				setattr_copy(inode, &tmpattr);
+				mark_inode_dirty(inode);
 			}
 		}
 #endif
  
@@ -954,15 +953,12 @@
 		result = ncp_make_closed(inode);
 		if (result)
 			goto out;
-		{
-			struct iattr tmpattr;
-			
-			tmpattr.ia_valid = ATTR_SIZE;
-			tmpattr.ia_size = attr->ia_size;
-			
-			result = inode_setattr(inode, &tmpattr);
+
+		if (attr->ia_size != i_size_read(inode)) {
+			result = vmtruncate(inode, attr->ia_size);
 			if (result)
 				goto out;
+			mark_inode_dirty(inode);
 		}
 	}
 	if ((attr->ia_valid & ATTR_CTIME) != 0) {
@@ -1002,8 +998,12 @@
 			NCP_FINFO(inode)->nwattr = info.attributes;
 #endif
 	}
-	if (!result)
-		result = inode_setattr(inode, attr);
+	if (result)
+		goto out;
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+
 out:
 	unlock_kernel();
 	return result;
@@ -656,14 +656,27 @@
 	err = nilfs_transaction_begin(sb, &ti, 0);
 	if (unlikely(err))
 		return err;
-	err = inode_setattr(inode, iattr);
-	if (!err && (iattr->ia_valid & ATTR_MODE))
+
+	if ((iattr->ia_valid & ATTR_SIZE) &&
+	    iattr->ia_size != i_size_read(inode)) {
+		err = vmtruncate(inode, iattr->ia_size);
+		if (unlikely(err))
+			goto out_err;
+	}
+
+	setattr_copy(inode, iattr);
+	mark_inode_dirty(inode);
+
+	if (iattr->ia_valid & ATTR_MODE) {
 		err = nilfs_acl_chmod(inode);
-	if (likely(!err))
-		err = nilfs_transaction_commit(sb);
-	else
-		nilfs_transaction_abort(sb);
+		if (unlikely(err))
+			goto out_err;
+	}
  
+	return nilfs_transaction_commit(sb);
+
+out_err:
+	nilfs_transaction_abort(sb);
 	return err;
 }
  
@@ -2879,9 +2879,6 @@
  *
  * Called with ->i_mutex held.  For the ATTR_SIZE (i.e. ->truncate) case, also
  * called with ->i_alloc_sem held for writing.
- *
- * Basically this is a copy of generic notify_change() and inode_setattr()
- * functionality, except we intercept and abort changes in i_size.
  */
 int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
@@ -214,10 +214,12 @@
  
 	attr->ia_valid &= ~ATTR_SIZE;
 	error = inode_change_ok(inode, attr);
-	if (!error)
-		error = inode_setattr(inode, attr);
+	if (error)
+		return error;
  
-	return error;
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static unsigned int dlmfs_file_poll(struct file *file, poll_table *wait)
@@ -1238,12 +1238,20 @@
 	 * Otherwise, we could get into problems with truncate as
 	 * ip_alloc_sem is used there to protect against i_size
 	 * changes.
+	 *
+	 * XXX: this means the conditional below can probably be removed.
 	 */
-	status = inode_setattr(inode, attr);
-	if (status < 0) {
-		mlog_errno(status);
-		goto bail_commit;
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		status = vmtruncate(inode, attr->ia_size);
+		if (status) {
+			mlog_errno(status);
+			goto bail_commit;
+		}
 	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
  
 	status = ocfs2_mark_inode_dirty(handle, inode, bh);
 	if (status < 0)
@@ -349,7 +349,17 @@
 	error = inode_change_ok(inode, attr);
 	if (error)
 		return error;
-	return inode_setattr(inode, attr);
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 const struct inode_operations omfs_file_inops = {
@@ -561,9 +561,19 @@
 		return -EPERM;
  
 	error = inode_change_ok(inode, attr);
-	if (!error)
-		error = inode_setattr(inode, attr);
-	return error;
+	if (error)
+		return error;
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static const struct inode_operations proc_def_inode_operations = {
@@ -12,6 +12,7 @@
 #include <linux/time.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
+#include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mount.h>
  
  
@@ -258,17 +259,22 @@
  
 	error = inode_change_ok(inode, iattr);
 	if (error)
-		goto out;
+		return error;
  
-	error = inode_setattr(inode, iattr);
-	if (error)
-		goto out;
+	if ((iattr->ia_valid & ATTR_SIZE) &&
+	    iattr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, iattr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, iattr);
+	mark_inode_dirty(inode);
  
 	de->uid = inode->i_uid;
 	de->gid = inode->i_gid;
 	de->mode = inode->i_mode;
-out:
-	return error;
+	return 0;
 }
  
 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
@@ -329,10 +329,19 @@
 		return -EPERM;
  
 	error = inode_change_ok(inode, attr);
-	if (!error)
-		error = inode_setattr(inode, attr);
+	if (error)
+		return error;
  
-	return error;
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
@@ -3134,54 +3134,61 @@
 	}
  
 	error = inode_change_ok(inode, attr);
-	if (!error) {
-		if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
-		    (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
-			error = reiserfs_chown_xattrs(inode, attr);
+	if (error)
+		goto out;
  
-			if (!error) {
-				struct reiserfs_transaction_handle th;
-				int jbegin_count =
-				    2 *
-				    (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
-				     REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
-				    2;
+	if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
+	    (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
+		struct reiserfs_transaction_handle th;
+		int jbegin_count =
+		    2 *
+		    (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
+		     REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
+		    2;
  
-				/* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
-				error =
-				    journal_begin(&th, inode->i_sb,
-						  jbegin_count);
-				if (error)
-					goto out;
-				error = dquot_transfer(inode, attr);
-				if (error) {
-					journal_end(&th, inode->i_sb,
-						    jbegin_count);
-					goto out;
-				}
-				/* Update corresponding info in inode so that everything is in
-				 * one transaction */
-				if (attr->ia_valid & ATTR_UID)
-					inode->i_uid = attr->ia_uid;
-				if (attr->ia_valid & ATTR_GID)
-					inode->i_gid = attr->ia_gid;
-				mark_inode_dirty(inode);
-				error =
-				    journal_end(&th, inode->i_sb, jbegin_count);
-			}
+		error = reiserfs_chown_xattrs(inode, attr);
+
+		if (error)
+			return error;
+
+		/* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
+		error = journal_begin(&th, inode->i_sb, jbegin_count);
+		if (error)
+			goto out;
+		error = dquot_transfer(inode, attr);
+		if (error) {
+			journal_end(&th, inode->i_sb, jbegin_count);
+			goto out;
 		}
-		if (!error) {
-			/*
-			 * Relax the lock here, as it might truncate the
-			 * inode pages and wait for inode pages locks.
-			 * To release such page lock, the owner needs the
-			 * reiserfs lock
-			 */
-			reiserfs_write_unlock_once(inode->i_sb, depth);
-			error = inode_setattr(inode, attr);
-			depth = reiserfs_write_lock_once(inode->i_sb);
-		}
+
+		/* Update corresponding info in inode so that everything is in
+		 * one transaction */
+		if (attr->ia_valid & ATTR_UID)
+			inode->i_uid = attr->ia_uid;
+		if (attr->ia_valid & ATTR_GID)
+			inode->i_gid = attr->ia_gid;
+		mark_inode_dirty(inode);
+		error = journal_end(&th, inode->i_sb, jbegin_count);
+		if (error)
+			goto out;
 	}
+
+	/*
+	 * Relax the lock here, as it might truncate the
+	 * inode pages and wait for inode pages locks.
+	 * To release such page lock, the owner needs the
+	 * reiserfs lock
+	 */
+	reiserfs_write_unlock_once(inode->i_sb, depth);
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode))
+		error = vmtruncate(inode, attr->ia_size);
+
+	if (!error) {
+		setattr_copy(inode, attr);
+		mark_inode_dirty(inode);
+	}
+	depth = reiserfs_write_lock_once(inode->i_sb);
  
 	if (!error && reiserfs_posixacl(inode->i_sb)) {
 		if (attr->ia_valid & ATTR_MODE)
@@ -38,7 +38,17 @@
 	error = inode_change_ok(inode, attr);
 	if (error)
 		return error;
-	return inode_setattr(inode, attr);
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 const struct inode_operations sysv_file_inode_operations = {
@@ -236,7 +236,17 @@
 	error = inode_change_ok(inode, attr);
 	if (error)
 		return error;
-	return inode_setattr(inode, attr);
+
+	if ((attr->ia_valid & ATTR_SIZE) &&
+	    attr->ia_size != i_size_read(inode)) {
+		error = vmtruncate(inode, attr->ia_size);
+		if (error)
+			return error;
+	}
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 const struct inode_operations udf_file_inode_operations = {
@@ -525,7 +525,10 @@
 		if (error)
 			return error;
 	}
-	return inode_setattr(inode, attr);
+
+	setattr_copy(inode, attr);
+	mark_inode_dirty(inode);
+	return 0;
 }
  
 const struct inode_operations ufs_file_inode_operations = {
@@ -2392,7 +2392,6 @@
  
 extern int inode_change_ok(const struct inode *, struct iattr *);
 extern int inode_newsize_ok(const struct inode *, loff_t offset);
-extern int __must_check inode_setattr(struct inode *, const struct iattr *);
 extern void setattr_copy(struct inode *inode, const struct iattr *attr);
  
 extern void file_update_time(struct file *file);
...	...	@@ -110,7 +110,9 @@
110	110	if ((attr->ia_valid & ATTR_SIZE) &&
111	111	(attr->ia_size != inode->i_size))
112	112	return -EINVAL;
113		- return inode_setattr(inode, attr);
	113	+ setattr_copy(inode, attr);
	114	+ mark_inode_dirty(inode);
	115	+ return 0;
114	116	}
115	117
116	118
...	...	@@ -968,11 +968,17 @@
968	968	goto err_out_exit;
969	969	}
970	970
971		- err = inode_setattr(inode, attr);
972		- if (err) {
973		- dprintk("%s: ino: %llu, failed to set the attributes.\n", __func__, POHMELFS_I(inode)->ino);
974		- goto err_out_exit;
	971	+ if ((attr->ia_valid & ATTR_SIZE) &&
	972	+ attr->ia_size != i_size_read(inode)) {
	973	+ err = vmtruncate(inode, attr->ia_size);
	974	+ if (err) {
	975	+ dprintk("%s: ino: %llu, failed to set the attributes.\n", __func__, POHMELFS_I(inode)->ino);
	976	+ goto err_out_exit;
	977	+ }
975	978	}
	979	+
	980	+ setattr_copy(inode, attr);
	981	+ mark_inode_dirty(inode);
976	982
977	983	dprintk("%s: ino: %llu, mode: %o -> %o, uid: %u -> %u, gid: %u -> %u, size: %llu -> %llu.\n",
978	984	__func__, POHMELFS_I(inode)->ino, inode->i_mode, attr->ia_mode,
...	...	@@ -896,10 +896,19 @@
896	896	}
897	897
898	898	retval = p9_client_wstat(fid, &wstat);
899		- if (retval >= 0)
900		- retval = inode_setattr(dentry->d_inode, iattr);
	899	+ if (retval < 0)
	900	+ return retval;
901	901
902		- return retval;
	902	+ if ((iattr->ia_valid & ATTR_SIZE) &&
	903	+ iattr->ia_size != i_size_read(dentry->d_inode)) {
	904	+ retval = vmtruncate(dentry->d_inode, iattr->ia_size);
	905	+ if (retval)
	906	+ return retval;
	907	+ }
	908	+
	909	+ setattr_copy(dentry->d_inode, iattr);
	910	+ mark_inode_dirty(dentry->d_inode);
	911	+ return 0;
903	912	}
904	913
905	914	/**
...	...	@@ -235,8 +235,17 @@
235	235	goto out;
236	236	}
237	237
238		- error = inode_setattr(inode, attr);
239		- if (!error && (attr->ia_valid & ATTR_MODE))
	238	+ if ((attr->ia_valid & ATTR_SIZE) &&
	239	+ attr->ia_size != i_size_read(inode)) {
	240	+ error = vmtruncate(inode, attr->ia_size);
	241	+ if (error)
	242	+ return error;
	243	+ }
	244	+
	245	+ setattr_copy(inode, attr);
	246	+ mark_inode_dirty(inode);
	247	+
	248	+ if (attr->ia_valid & ATTR_MODE)
240	249	mode_to_prot(inode);
241	250	out:
242	251	return error;
...	...	@@ -146,31 +146,6 @@
146	146	}
147	147	EXPORT_SYMBOL(setattr_copy);
148	148
149		-/*
150		- * note this function is deprecated, the new truncate sequence should be
151		- * used instead -- see eg. simple_setsize, setattr_copy.
152		- */
153		-int inode_setattr(struct inode inode, const struct iattr attr)
154		-{
155		- unsigned int ia_valid = attr->ia_valid;
156		-
157		- if (ia_valid & ATTR_SIZE &&
158		- attr->ia_size != i_size_read(inode)) {
159		- int error;
160		-
161		- error = vmtruncate(inode, attr->ia_size);
162		- if (error)
163		- return error;
164		- }
165		-
166		- setattr_copy(inode, attr);
167		-
168		- mark_inode_dirty(inode);
169		-
170		- return 0;
171		-}
172		-EXPORT_SYMBOL(inode_setattr);
173		-
174	149	int notify_change(struct dentry * dentry, struct iattr * attr)
175	150	{
176	151	struct inode *inode = dentry->d_inode;
...	...	@@ -3656,13 +3656,15 @@
3656	3656	if (err)
3657	3657	return err;
3658	3658	}
3659		- attr->ia_valid &= ~ATTR_SIZE;
3660	3659
3661		- if (attr->ia_valid)
3662		- err = inode_setattr(inode, attr);
	3660	+ if (attr->ia_valid) {
	3661	+ setattr_copy(inode, attr);
	3662	+ mark_inode_dirty(inode);
3663	3663
3664		- if (!err && ((attr->ia_valid & ATTR_MODE)))
3665		- err = btrfs_acl_chmod(inode);
	3664	+ if (attr->ia_valid & ATTR_MODE)
	3665	+ err = btrfs_acl_chmod(inode);
	3666	+ }
	3667	+
3666	3668	return err;
3667	3669	}
3668	3670
...	...	@@ -1889,18 +1889,27 @@
1889	1889	CIFS_MOUNT_MAP_SPECIAL_CHR);
1890	1890	}
1891	1891
1892		- if (!rc) {
1893		- rc = inode_setattr(inode, attrs);
	1892	+ if (rc)
	1893	+ goto out;
1894	1894
1895		- /* force revalidate when any of these times are set since some
1896		- of the fs types (eg ext3, fat) do not have fine enough
1897		- time granularity to match protocol, and we do not have a
1898		- a way (yet) to query the server fs's time granularity (and
1899		- whether it rounds times down).
1900		- */
1901		- if (!rc && (attrs->ia_valid & (ATTR_MTIME \| ATTR_CTIME)))
1902		- cifsInode->time = 0;
	1895	+ if ((attrs->ia_valid & ATTR_SIZE) &&
	1896	+ attrs->ia_size != i_size_read(inode)) {
	1897	+ rc = vmtruncate(inode, attrs->ia_size);
	1898	+ if (rc)
	1899	+ goto out;
1903	1900	}
	1901	+
	1902	+ setattr_copy(inode, attrs);
	1903	+ mark_inode_dirty(inode);
	1904	+
	1905	+ /* force revalidate when any of these times are set since some
	1906	+ of the fs types (eg ext3, fat) do not have fine enough
	1907	+ time granularity to match protocol, and we do not have a
	1908	+ a way (yet) to query the server fs's time granularity (and
	1909	+ whether it rounds times down).
	1910	+ */
	1911	+ if (attrs->ia_valid & (ATTR_MTIME \| ATTR_CTIME))
	1912	+ cifsInode->time = 0;
1904	1913	out:
1905	1914	kfree(args);
1906	1915	kfree(full_path);
...	...	@@ -2040,8 +2049,20 @@
2040	2049
2041	2050	/* do not need local check to inode_check_ok since the server does
2042	2051	that */
2043		- if (!rc)
2044		- rc = inode_setattr(inode, attrs);
	2052	+ if (rc)
	2053	+ goto cifs_setattr_exit;
	2054	+
	2055	+ if ((attrs->ia_valid & ATTR_SIZE) &&
	2056	+ attrs->ia_size != i_size_read(inode)) {
	2057	+ rc = vmtruncate(inode, attrs->ia_size);
	2058	+ if (rc)
	2059	+ goto cifs_setattr_exit;
	2060	+ }
	2061	+
	2062	+ setattr_copy(inode, attrs);
	2063	+ mark_inode_dirty(inode);
	2064	+ return 0;
	2065	+
2045	2066	cifs_setattr_exit:
2046	2067	kfree(full_path);
2047	2068	FreeXid(xid);
...	...	@@ -887,8 +887,18 @@
887	887	if (error)
888	888	return error;
889	889
890		- error = inode_setattr(inode, iattr);
891		- return error;
	890	+ if ((iattr->ia_valid & ATTR_SIZE) &&
	891	+ iattr->ia_size != i_size_read(inode)) {
	892	+ int error;
	893	+
	894	+ error = vmtruncate(inode, iattr->ia_size);
	895	+ if (error)
	896	+ return error;
	897	+ }
	898	+
	899	+ setattr_copy(inode, iattr);
	900	+ mark_inode_dirty(inode);
	901	+ return 0;
892	902	}
893	903
894	904	static const struct osd_attr g_attr_inode_file_layout = ATTR_DEF(
...	...	@@ -3208,9 +3208,17 @@
3208	3208	ext3_journal_stop(handle);
3209	3209	}
3210	3210
3211		- rc = inode_setattr(inode, attr);
	3211	+ if ((attr->ia_valid & ATTR_SIZE) &&
	3212	+ attr->ia_size != i_size_read(inode)) {
	3213	+ rc = vmtruncate(inode, attr->ia_size);
	3214	+ if (rc)
	3215	+ goto err_out;
	3216	+ }
3212	3217
3213		- if (!rc && (ia_valid & ATTR_MODE))
	3218	+ setattr_copy(inode, attr);
	3219	+ mark_inode_dirty(inode);
	3220	+
	3221	+ if (ia_valid & ATTR_MODE)
3214	3222	rc = ext3_acl_chmod(inode);
3215	3223
3216	3224	err_out:
...	...	@@ -5539,11 +5539,19 @@
5539	5539	ext4_truncate(inode);
5540	5540	}
5541	5541
5542		- rc = inode_setattr(inode, attr);
	5542	+ if ((attr->ia_valid & ATTR_SIZE) &&
	5543	+ attr->ia_size != i_size_read(inode))
	5544	+ rc = vmtruncate(inode, attr->ia_size);
5543	5545
5544		- /* If inode_setattr's call to ext4_truncate failed to get a
5545		- * transaction handle at all, we need to clean up the in-core
5546		- * orphan list manually. */
	5546	+ if (!rc) {
	5547	+ setattr_copy(inode, attr);
	5548	+ mark_inode_dirty(inode);
	5549	+ }
	5550	+
	5551	+ /*
	5552	+ * If the call to ext4_truncate failed to get a transaction handle at
	5553	+ * all, we need to clean up the in-core orphan list manually.
	5554	+ */
5547	5555	if (inode->i_nlink)
5548	5556	ext4_orphan_del(NULL, inode);
5549	5557