Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git

Signed-off-by: Steve French <sfrench@us.ibm.com>

6 files changed, 150 insertions, 156 deletions

diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 041380fe667b..6d2dfed1de08 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -56,13 +56,20 @@ static int
 nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
                                            struct nfsd3_attrstat *resp)
 {
-        int     nfserr;
+        int     err, nfserr;
 
         dprintk("nfsd: GETATTR(3)  %s\n",
-                                SVCFH_fmt(&argp->fh));
+                SVCFH_fmt(&argp->fh));
 
         fh_copy(&resp->fh, &argp->fh);
         nfserr = fh_verify(rqstp, &resp->fh, 0, MAY_NOP);
+        if (nfserr)
+                RETURN_STATUS(nfserr);
+
+        err = vfs_getattr(resp->fh.fh_export->ex_mnt,
+                          resp->fh.fh_dentry, &resp->stat);
+        nfserr = nfserrno(err);
+
         RETURN_STATUS(nfserr);
 }
 
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 9147b8524d05..243d94b9653a 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -154,37 +154,34 @@ decode_sattr3(u32 *p, struct iattr *iap)
 }
 
 static inline u32 *
-encode_fattr3(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp)
+encode_fattr3(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp,
+              struct kstat *stat)
 {
-        struct vfsmount *mnt = fhp->fh_export->ex_mnt;
         struct dentry   *dentry = fhp->fh_dentry;
-        struct kstat stat;
         struct timespec time;
 
-        vfs_getattr(mnt, dentry, &stat);
-
-        *p++ = htonl(nfs3_ftypes[(stat.mode & S_IFMT) >> 12]);
-        *p++ = htonl((u32) stat.mode);
-        *p++ = htonl((u32) stat.nlink);
-        *p++ = htonl((u32) nfsd_ruid(rqstp, stat.uid));
-        *p++ = htonl((u32) nfsd_rgid(rqstp, stat.gid));
-        if (S_ISLNK(stat.mode) && stat.size > NFS3_MAXPATHLEN) {
+        *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]);
+        *p++ = htonl((u32) stat->mode);
+        *p++ = htonl((u32) stat->nlink);
+        *p++ = htonl((u32) nfsd_ruid(rqstp, stat->uid));
+        *p++ = htonl((u32) nfsd_rgid(rqstp, stat->gid));
+        if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) {
                 p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN);
         } else {
-                p = xdr_encode_hyper(p, (u64) stat.size);
+                p = xdr_encode_hyper(p, (u64) stat->size);
         }
-        p = xdr_encode_hyper(p, ((u64)stat.blocks) << 9);
-        *p++ = htonl((u32) MAJOR(stat.rdev));
-        *p++ = htonl((u32) MINOR(stat.rdev));
+        p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9);
+        *p++ = htonl((u32) MAJOR(stat->rdev));
+        *p++ = htonl((u32) MINOR(stat->rdev));
         if (is_fsid(fhp, rqstp->rq_reffh))
                 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
         else
-                p = xdr_encode_hyper(p, (u64) huge_encode_dev(stat.dev));
-        p = xdr_encode_hyper(p, (u64) stat.ino);
-        p = encode_time3(p, &stat.atime);
+                p = xdr_encode_hyper(p, (u64) huge_encode_dev(stat->dev));
+        p = xdr_encode_hyper(p, (u64) stat->ino);
+        p = encode_time3(p, &stat->atime);
         lease_get_mtime(dentry->d_inode, &time); 
         p = encode_time3(p, &time);
-        p = encode_time3(p, &stat.ctime);
+        p = encode_time3(p, &stat->ctime);
 
         return p;
 }
@@ -232,8 +229,14 @@ encode_post_op_attr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp)
 {
         struct dentry *dentry = fhp->fh_dentry;
         if (dentry && dentry->d_inode != NULL) {
-                *p++ = xdr_one;         /* attributes follow */
-                return encode_fattr3(rqstp, p, fhp);
+                int err;
+                struct kstat stat;
+
+                err = vfs_getattr(fhp->fh_export->ex_mnt, dentry, &stat);
+                if (!err) {
+                        *p++ = xdr_one;         /* attributes follow */
+                        return encode_fattr3(rqstp, p, fhp, &stat);
+                }
         }
         *p++ = xdr_zero;
         return p;
@@ -616,7 +619,7 @@ nfs3svc_encode_attrstat(struct svc_rqst *rqstp, u32 *p,
                                         struct nfsd3_attrstat *resp)
 {
         if (resp->status == 0)
-                p = encode_fattr3(rqstp, p, &resp->fh);
+                p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
         return xdr_ressize_check(rqstp, p);
 }
 
diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index 583c0710e45e..d828662d737d 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -53,7 +53,7 @@
 #define NFSPROC4_CB_COMPOUND 1
 
 /* declarations */
-static void nfs4_cb_null(struct rpc_task *task);
+static const struct rpc_call_ops nfs4_cb_null_ops;
 
 /* Index of predefined Linux callback client operations */
 
@@ -431,7 +431,6 @@ nfsd4_probe_callback(struct nfs4_client *clp)
         }
         clnt->cl_intr = 0;
         clnt->cl_softrtry = 1;
-        clnt->cl_chatty = 1;
 
         /* Kick rpciod, put the call on the wire. */
 
@@ -447,7 +446,7 @@ nfsd4_probe_callback(struct nfs4_client *clp)
         msg.rpc_cred = nfsd4_lookupcred(clp,0);
         if (IS_ERR(msg.rpc_cred))
                 goto out_rpciod;
-        status = rpc_call_async(clnt, &msg, RPC_TASK_ASYNC, nfs4_cb_null, NULL);
+        status = rpc_call_async(clnt, &msg, RPC_TASK_ASYNC, &nfs4_cb_null_ops, NULL);
         put_rpccred(msg.rpc_cred);
 
         if (status != 0) {
@@ -469,7 +468,7 @@ out_err:
 }
 
 static void
-nfs4_cb_null(struct rpc_task *task)
+nfs4_cb_null(struct rpc_task *task, void *dummy)
 {
         struct nfs4_client *clp = (struct nfs4_client *)task->tk_msg.rpc_argp;
         struct nfs4_callback *cb = &clp->cl_callback;
@@ -488,6 +487,10 @@ out:
         put_nfs4_client(clp);
 }
 
+static const struct rpc_call_ops nfs4_cb_null_ops = {
+        .rpc_call_done = nfs4_cb_null,
+};
+
 /*
  * called with dp->dl_count inc'ed.
  * nfs4_lock_state() may or may not have been called.
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 954cf893d50c..be963a133aaa 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -121,9 +121,9 @@ out:
 static void
 nfsd4_sync_rec_dir(void)
 {
-        down(&rec_dir.dentry->d_inode->i_sem);
+        mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
         nfsd_sync_dir(rec_dir.dentry);
-        up(&rec_dir.dentry->d_inode->i_sem);
+        mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
 }
 
 int
@@ -143,7 +143,7 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
         nfs4_save_user(&uid, &gid);
 
         /* lock the parent */
-        down(&rec_dir.dentry->d_inode->i_sem);
+        mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
 
         dentry = lookup_one_len(dname, rec_dir.dentry, HEXDIR_LEN-1);
         if (IS_ERR(dentry)) {
@@ -159,7 +159,7 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
 out_put:
         dput(dentry);
 out_unlock:
-        up(&rec_dir.dentry->d_inode->i_sem);
+        mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
         if (status == 0) {
                 clp->cl_firststate = 1;
                 nfsd4_sync_rec_dir();
@@ -259,9 +259,9 @@ nfsd4_remove_clid_file(struct dentry *dir, struct dentry *dentry)
                 printk("nfsd4: non-file found in client recovery directory\n");
                 return -EINVAL;
         }
-        down(&dir->d_inode->i_sem);
+        mutex_lock(&dir->d_inode->i_mutex);
         status = vfs_unlink(dir->d_inode, dentry);
-        up(&dir->d_inode->i_sem);
+        mutex_unlock(&dir->d_inode->i_mutex);
         return status;
 }
 
@@ -274,9 +274,9 @@ nfsd4_clear_clid_dir(struct dentry *dir, struct dentry *dentry)
          * any regular files anyway, just in case the directory was created by
          * a kernel from the future.... */
         nfsd4_list_rec_dir(dentry, nfsd4_remove_clid_file);
-        down(&dir->d_inode->i_sem);
+        mutex_lock(&dir->d_inode->i_mutex);
         status = vfs_rmdir(dir->d_inode, dentry);
-        up(&dir->d_inode->i_sem);
+        mutex_unlock(&dir->d_inode->i_mutex);
         return status;
 }
 
@@ -288,9 +288,9 @@ nfsd4_unlink_clid_dir(char *name, int namlen)
 
         dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
 
-        down(&rec_dir.dentry->d_inode->i_sem);
+        mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
         dentry = lookup_one_len(name, rec_dir.dentry, namlen);
-        up(&rec_dir.dentry->d_inode->i_sem);
+        mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
                 return status;
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index b45999ff33e6..aa7bb41b293d 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -152,46 +152,44 @@ decode_sattr(u32 *p, struct iattr *iap)
 }
 
 static inline u32 *
-encode_fattr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp)
+encode_fattr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp,
+             struct kstat *stat)
 {
-        struct vfsmount *mnt = fhp->fh_export->ex_mnt;
         struct dentry   *dentry = fhp->fh_dentry;
-        struct kstat stat;
         int type;
         struct timespec time;
 
-        vfs_getattr(mnt, dentry, &stat);
-        type = (stat.mode & S_IFMT);
+        type = (stat->mode & S_IFMT);
 
         *p++ = htonl(nfs_ftypes[type >> 12]);
-        *p++ = htonl((u32) stat.mode);
-        *p++ = htonl((u32) stat.nlink);
-        *p++ = htonl((u32) nfsd_ruid(rqstp, stat.uid));
-        *p++ = htonl((u32) nfsd_rgid(rqstp, stat.gid));
+        *p++ = htonl((u32) stat->mode);
+        *p++ = htonl((u32) stat->nlink);
+        *p++ = htonl((u32) nfsd_ruid(rqstp, stat->uid));
+        *p++ = htonl((u32) nfsd_rgid(rqstp, stat->gid));
 
-        if (S_ISLNK(type) && stat.size > NFS_MAXPATHLEN) {
+        if (S_ISLNK(type) && stat->size > NFS_MAXPATHLEN) {
                 *p++ = htonl(NFS_MAXPATHLEN);
         } else {
-                *p++ = htonl((u32) stat.size);
+                *p++ = htonl((u32) stat->size);
         }
-        *p++ = htonl((u32) stat.blksize);
+        *p++ = htonl((u32) stat->blksize);
         if (S_ISCHR(type) || S_ISBLK(type))
-                *p++ = htonl(new_encode_dev(stat.rdev));
+                *p++ = htonl(new_encode_dev(stat->rdev));
         else
                 *p++ = htonl(0xffffffff);
-        *p++ = htonl((u32) stat.blocks);
+        *p++ = htonl((u32) stat->blocks);
         if (is_fsid(fhp, rqstp->rq_reffh))
                 *p++ = htonl((u32) fhp->fh_export->ex_fsid);
         else
-                *p++ = htonl(new_encode_dev(stat.dev));
-        *p++ = htonl((u32) stat.ino);
-        *p++ = htonl((u32) stat.atime.tv_sec);
-        *p++ = htonl(stat.atime.tv_nsec ? stat.atime.tv_nsec / 1000 : 0);
+                *p++ = htonl(new_encode_dev(stat->dev));
+        *p++ = htonl((u32) stat->ino);
+        *p++ = htonl((u32) stat->atime.tv_sec);
+        *p++ = htonl(stat->atime.tv_nsec ? stat->atime.tv_nsec / 1000 : 0);
         lease_get_mtime(dentry->d_inode, &time); 
         *p++ = htonl((u32) time.tv_sec);
         *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0); 
-        *p++ = htonl((u32) stat.ctime.tv_sec);
-        *p++ = htonl(stat.ctime.tv_nsec ? stat.ctime.tv_nsec / 1000 : 0);
+        *p++ = htonl((u32) stat->ctime.tv_sec);
+        *p++ = htonl(stat->ctime.tv_nsec ? stat->ctime.tv_nsec / 1000 : 0);
 
         return p;
 }
@@ -199,7 +197,9 @@ encode_fattr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp)
 /* Helper function for NFSv2 ACL code */
 u32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp)
 {
-        return encode_fattr(rqstp, p, fhp);
+        struct kstat stat;
+        vfs_getattr(fhp->fh_export->ex_mnt, fhp->fh_dentry, &stat);
+        return encode_fattr(rqstp, p, fhp, &stat);
 }
 
 /*
@@ -394,7 +394,7 @@ int
 nfssvc_encode_attrstat(struct svc_rqst *rqstp, u32 *p,
                                         struct nfsd_attrstat *resp)
 {
-        p = encode_fattr(rqstp, p, &resp->fh);
+        p = encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         return xdr_ressize_check(rqstp, p);
 }
 
@@ -403,7 +403,7 @@ nfssvc_encode_diropres(struct svc_rqst *rqstp, u32 *p,
                                         struct nfsd_diropres *resp)
 {
         p = encode_fh(p, &resp->fh);
-        p = encode_fattr(rqstp, p, &resp->fh);
+        p = encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         return xdr_ressize_check(rqstp, p);
 }
 
@@ -428,7 +428,7 @@ int
 nfssvc_encode_readres(struct svc_rqst *rqstp, u32 *p,
                                         struct nfsd_readres *resp)
 {
-        p = encode_fattr(rqstp, p, &resp->fh);
+        p = encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         *p++ = htonl(resp->count);
         xdr_ressize_check(rqstp, p);
 
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index af7c3c3074b0..eef0576a7785 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -48,8 +48,8 @@
 #include <linux/fsnotify.h>
 #include <linux/posix_acl.h>
 #include <linux/posix_acl_xattr.h>
-#ifdef CONFIG_NFSD_V4
 #include <linux/xattr.h>
+#ifdef CONFIG_NFSD_V4
 #include <linux/nfs4.h>
 #include <linux/nfs4_acl.h>
 #include <linux/nfsd_idmap.h>
@@ -365,8 +365,30 @@ out_nfserr:
         goto out;
 }
 
-#if defined(CONFIG_NFSD_V4)
+#if defined(CONFIG_NFSD_V2_ACL) || \
+    defined(CONFIG_NFSD_V3_ACL) || \
+    defined(CONFIG_NFSD_V4)
+static ssize_t nfsd_getxattr(struct dentry *dentry, char *key, void **buf)
+{
+        ssize_t buflen;
+        int error;
+
+        buflen = vfs_getxattr(dentry, key, NULL, 0);
+        if (buflen <= 0)
+                return buflen;
+
+        *buf = kmalloc(buflen, GFP_KERNEL);
+        if (!*buf)
+                return -ENOMEM;
 
+        error = vfs_getxattr(dentry, key, *buf, buflen);
+        if (error < 0)
+                return error;
+        return buflen;
+}
+#endif
+
+#if defined(CONFIG_NFSD_V4)
 static int
 set_nfsv4_acl_one(struct dentry *dentry, struct posix_acl *pacl, char *key)
 {
@@ -374,7 +396,6 @@ set_nfsv4_acl_one(struct dentry *dentry, struct posix_acl *pacl, char *key)
         size_t buflen;
         char *buf = NULL;
         int error = 0;
-        struct inode *inode = dentry->d_inode;
 
         buflen = posix_acl_xattr_size(pacl->a_count);
         buf = kmalloc(buflen, GFP_KERNEL);
@@ -388,15 +409,7 @@ set_nfsv4_acl_one(struct dentry *dentry, struct posix_acl *pacl, char *key)
                 goto out;
         }
 
-        error = -EOPNOTSUPP;
-        if (inode->i_op && inode->i_op->setxattr) {
-                down(&inode->i_sem);
-                security_inode_setxattr(dentry, key, buf, len, 0);
-                error = inode->i_op->setxattr(dentry, key, buf, len, 0);
-                if (!error)
-                        security_inode_post_setxattr(dentry, key, buf, len, 0);
-                up(&inode->i_sem);
-        }
+        error = vfs_setxattr(dentry, key, buf, len, 0);
 out:
         kfree(buf);
         return error;
@@ -455,44 +468,19 @@ out_nfserr:
 static struct posix_acl *
 _get_posix_acl(struct dentry *dentry, char *key)
 {
-        struct inode *inode = dentry->d_inode;
-        char *buf = NULL;
-        int buflen, error = 0;
+        void *buf = NULL;
         struct posix_acl *pacl = NULL;
+        int buflen;
 
-        error = -EOPNOTSUPP;
-        if (inode->i_op == NULL)
-                goto out_err;
-        if (inode->i_op->getxattr == NULL)
-                goto out_err;
-
-        error = security_inode_getxattr(dentry, key);
-        if (error)
-                goto out_err;
-
-        buflen = inode->i_op->getxattr(dentry, key, NULL, 0);
-        if (buflen <= 0) {
-                error = buflen < 0 ? buflen : -ENODATA;
-                goto out_err;
-        }
-
-        buf = kmalloc(buflen, GFP_KERNEL);
-        if (buf == NULL) {
-                error = -ENOMEM;
-                goto out_err;
-        }
-
-        error = inode->i_op->getxattr(dentry, key, buf, buflen);
-        if (error < 0)
-                goto out_err;
+        buflen = nfsd_getxattr(dentry, key, &buf);
+        if (!buflen)
+                buflen = -ENODATA;
+        if (buflen <= 0)
+                return ERR_PTR(buflen);
 
         pacl = posix_acl_from_xattr(buf, buflen);
- out:
         kfree(buf);
         return pacl;
- out_err:
-        pacl = ERR_PTR(error);
-        goto out;
 }
 
 int
@@ -717,27 +705,33 @@ nfsd_close(struct file *filp)
  * As this calls fsync (not fdatasync) there is no need for a write_inode
  * after it.
  */
-static inline void nfsd_dosync(struct file *filp, struct dentry *dp,
-                               struct file_operations *fop)
+static inline int nfsd_dosync(struct file *filp, struct dentry *dp,
+                              struct file_operations *fop)
 {
         struct inode *inode = dp->d_inode;
         int (*fsync) (struct file *, struct dentry *, int);
+        int err = nfs_ok;
 
         filemap_fdatawrite(inode->i_mapping);
         if (fop && (fsync = fop->fsync))
-                fsync(filp, dp, 0);
+                err=fsync(filp, dp, 0);
         filemap_fdatawait(inode->i_mapping);
+
+        return nfserrno(err);
 }
         
 
-static void
+static int
 nfsd_sync(struct file *filp)
 {
+        int err;
         struct inode *inode = filp->f_dentry->d_inode;
         dprintk("nfsd: sync file %s\n", filp->f_dentry->d_name.name);
-        down(&inode->i_sem);
-        nfsd_dosync(filp, filp->f_dentry, filp->f_op);
-        up(&inode->i_sem);
+        mutex_lock(&inode->i_mutex);
+        err=nfsd_dosync(filp, filp->f_dentry, filp->f_op);
+        mutex_unlock(&inode->i_mutex);
+
+        return err;
 }
 
 void
@@ -874,6 +868,16 @@ out:
         return err;
 }
 
+static void kill_suid(struct dentry *dentry)
+{
+        struct iattr    ia;
+        ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID;
+
+        mutex_lock(&dentry->d_inode->i_mutex);
+        notify_change(dentry, &ia);
+        mutex_unlock(&dentry->d_inode->i_mutex);
+}
+
 static inline int
 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                                 loff_t offset, struct kvec *vec, int vlen,
@@ -927,14 +931,8 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         }
 
         /* clear setuid/setgid flag after write */
-        if (err >= 0 && (inode->i_mode & (S_ISUID | S_ISGID))) {
-                struct iattr    ia;
-                ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID;
-
-                down(&inode->i_sem);
-                notify_change(dentry, &ia);
-                up(&inode->i_sem);
-        }
+        if (err >= 0 && (inode->i_mode & (S_ISUID | S_ISGID)))
+                kill_suid(dentry);
 
         if (err >= 0 && stable) {
                 static ino_t    last_ino;
@@ -962,7 +960,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
 
                         if (inode->i_state & I_DIRTY) {
                                 dprintk("nfsd: write sync %d\n", current->pid);
-                                nfsd_sync(file);
+                                err=nfsd_sync(file);
                         }
 #if 0
                         wake_up(&inode->i_wait);
@@ -1066,7 +1064,7 @@ nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 return err;
         if (EX_ISSYNC(fhp->fh_export)) {
                 if (file->f_op && file->f_op->fsync) {
-                        nfsd_sync(file);
+                        err = nfsd_sync(file);
                 } else {
                         err = nfserr_notsupp;
                 }
@@ -1874,39 +1872,25 @@ nfsd_get_posix_acl(struct svc_fh *fhp, int type)
         ssize_t size;
         struct posix_acl *acl;
 
-        if (!IS_POSIXACL(inode) || !inode->i_op || !inode->i_op->getxattr)
+        if (!IS_POSIXACL(inode))
+                return ERR_PTR(-EOPNOTSUPP);
+
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                name = POSIX_ACL_XATTR_ACCESS;
+                break;
+        case ACL_TYPE_DEFAULT:
+                name = POSIX_ACL_XATTR_DEFAULT;
+                break;
+        default:
                 return ERR_PTR(-EOPNOTSUPP);
-        switch(type) {
-                case ACL_TYPE_ACCESS:
-                        name = POSIX_ACL_XATTR_ACCESS;
-                        break;
-                case ACL_TYPE_DEFAULT:
-                        name = POSIX_ACL_XATTR_DEFAULT;
-                        break;
-                default:
-                        return ERR_PTR(-EOPNOTSUPP);
         }
 
-        size = inode->i_op->getxattr(fhp->fh_dentry, name, NULL, 0);
+        size = nfsd_getxattr(fhp->fh_dentry, name, &value);
+        if (size < 0)
+                return ERR_PTR(size);
 
-        if (size < 0) {
-                acl = ERR_PTR(size);
-                goto getout;
-        } else if (size > 0) {
-                value = kmalloc(size, GFP_KERNEL);
-                if (!value) {
-                        acl = ERR_PTR(-ENOMEM);
-                        goto getout;
-                }
-                size = inode->i_op->getxattr(fhp->fh_dentry, name, value, size);
-                if (size < 0) {
-                        acl = ERR_PTR(size);
-                        goto getout;
-                }
-        }
         acl = posix_acl_from_xattr(value, size);
-
-getout:
         kfree(value);
         return acl;
 }
@@ -1947,16 +1931,13 @@ nfsd_set_posix_acl(struct svc_fh *fhp, int type, struct posix_acl *acl)
         } else
                 size = 0;
 
-        if (!fhp->fh_locked)
-                fh_lock(fhp);  /* unlocking is done automatically */
         if (size)
-                error = inode->i_op->setxattr(fhp->fh_dentry, name,
-                                              value, size, 0);
+                error = vfs_setxattr(fhp->fh_dentry, name, value, size, 0);
         else {
                 if (!S_ISDIR(inode->i_mode) && type == ACL_TYPE_DEFAULT)
                         error = 0;
                 else {
-                        error = inode->i_op->removexattr(fhp->fh_dentry, name);
+                        error = vfs_removexattr(fhp->fh_dentry, name);
                         if (error == -ENODATA)
                                 error = 0;
                 }