Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull fourth vfs update from Al Viro:
 "d_inode() annotations from David Howells (sat in for-next since before
  the beginning of merge window) + four assorted fixes"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  RCU pathwalk breakage when running into a symlink overmounting something
  fix I_DIO_WAKEUP definition
  direct-io: only inc/dec inode->i_dio_count for file systems
  fs/9p: fix readdir()
  VFS: assorted d_backing_inode() annotations
  VFS: fs/inode.c helpers: d_inode() annotations
  VFS: fs/cachefiles: d_backing_inode() annotations
  VFS: fs library helpers: d_inode() annotations
  VFS: assorted weird filesystems: d_inode() annotations
  VFS: normal filesystems (and lustre): d_inode() annotations
  VFS: security/: d_inode() annotations
  VFS: security/: d_backing_inode() annotations
  VFS: net/: d_inode() annotations
  VFS: net/unix: d_backing_inode() annotations
  VFS: kernel/: d_inode() annotations
  VFS: audit: d_backing_inode() annotations
  VFS: Fix up some ->d_inode accesses in the chelsio driver
  VFS: Cachefiles should perform fs modifications on the top layer only
  VFS: AF_UNIX sockets should call mknod on the top layer only

16 files changed, 95 insertions, 95 deletions

diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 900c3ae94adc..f79521a59747 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -599,7 +599,7 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
                                 goto out4;
                 }
 
-                err = check_export(exp.ex_path.dentry->d_inode, &exp.ex_flags,
+                err = check_export(d_inode(exp.ex_path.dentry), &exp.ex_flags,
                                    exp.ex_uuid);
                 if (err)
                         goto out4;
@@ -890,7 +890,7 @@ exp_rootfh(struct net *net, struct auth_domain *clp, char *name,
                 printk("nfsd: exp_rootfh path not found %s", name);
                 return err;
         }
-        inode = path.dentry->d_inode;
+        inode = d_inode(path.dentry);
 
         dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
                  name, path.dentry, clp->name,
diff --git a/fs/nfsd/nfs2acl.c b/fs/nfsd/nfs2acl.c
index ac54ea60b3f6..d54701f6dc78 100644
--- a/fs/nfsd/nfs2acl.c
+++ b/fs/nfsd/nfs2acl.c
@@ -42,7 +42,7 @@ static __be32 nfsacld_proc_getacl(struct svc_rqst * rqstp,
         if (nfserr)
                 RETURN_STATUS(nfserr);
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
 
         if (argp->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
                 RETURN_STATUS(nfserr_inval);
@@ -103,7 +103,7 @@ static __be32 nfsacld_proc_setacl(struct svc_rqst * rqstp,
         if (nfserr)
                 goto out;
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
         if (!IS_POSIXACL(inode) || !inode->i_op->set_acl) {
                 error = -EOPNOTSUPP;
                 goto out_errno;
@@ -266,9 +266,9 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
          * nfsd_dispatch actually ensures the following cannot happen.
          * However, it seems fragile to depend on that.
          */
-        if (dentry == NULL || dentry->d_inode == NULL)
+        if (dentry == NULL || d_really_is_negative(dentry))
                 return 0;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         *p++ = htonl(resp->mask);
diff --git a/fs/nfsd/nfs3acl.c b/fs/nfsd/nfs3acl.c
index 34cbbab6abd7..882b1a14bc3e 100644
--- a/fs/nfsd/nfs3acl.c
+++ b/fs/nfsd/nfs3acl.c
@@ -39,7 +39,7 @@ static __be32 nfsd3_proc_getacl(struct svc_rqst * rqstp,
         if (nfserr)
                 RETURN_STATUS(nfserr);
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
 
         if (argp->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
                 RETURN_STATUS(nfserr_inval);
@@ -94,7 +94,7 @@ static __be32 nfsd3_proc_setacl(struct svc_rqst * rqstp,
         if (nfserr)
                 goto out;
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
         if (!IS_POSIXACL(inode) || !inode->i_op->set_acl) {
                 error = -EOPNOTSUPP;
                 goto out_errno;
@@ -174,8 +174,8 @@ static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
         struct dentry *dentry = resp->fh.fh_dentry;
 
         p = nfs3svc_encode_post_op_attr(rqstp, p, &resp->fh);
-        if (resp->status == 0 && dentry && dentry->d_inode) {
-                struct inode *inode = dentry->d_inode;
+        if (resp->status == 0 && dentry && d_really_is_positive(dentry)) {
+                struct inode *inode = d_inode(dentry);
                 struct kvec *head = rqstp->rq_res.head;
                 unsigned int base;
                 int n;
diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 12f2aab4f614..7b755b7f785c 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -166,7 +166,7 @@ nfsd3_proc_read(struct svc_rqst *rqstp, struct nfsd3_readargs *argp,
                                   rqstp->rq_vec, argp->vlen,
                                   &resp->count);
         if (nfserr == 0) {
-                struct inode    *inode = resp->fh.fh_dentry->d_inode;
+                struct inode    *inode = d_inode(resp->fh.fh_dentry);
 
                 resp->eof = (argp->offset + resp->count) >= inode->i_size;
         }
@@ -551,7 +551,7 @@ nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
          * different read/write sizes for file systems known to have
          * problems with large blocks */
         if (nfserr == 0) {
-                struct super_block *sb = argp->fh.fh_dentry->d_inode->i_sb;
+                struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb;
 
                 /* Note that we don't care for remote fs's here */
                 if (sb->s_magic == MSDOS_SUPER_MAGIC) {
@@ -587,7 +587,7 @@ nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle      *argp,
         nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP);
 
         if (nfserr == 0) {
-                struct super_block *sb = argp->fh.fh_dentry->d_inode->i_sb;
+                struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb;
 
                 /* Note that we don't care for remote fs's here */
                 switch (sb->s_magic) {
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 39c5eb3ad33a..e4b2b4322553 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -146,7 +146,7 @@ static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
         default:
         case FSIDSOURCE_DEV:
                 p = xdr_encode_hyper(p, (u64)huge_encode_dev
-                                     (fhp->fh_dentry->d_inode->i_sb->s_dev));
+                                     (d_inode(fhp->fh_dentry)->i_sb->s_dev));
                 break;
         case FSIDSOURCE_FSID:
                 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
@@ -203,14 +203,14 @@ static __be32 *
 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 {
         struct dentry *dentry = fhp->fh_dentry;
-        if (dentry && dentry->d_inode) {
+        if (dentry && d_really_is_positive(dentry)) {
                 __be32 err;
                 struct kstat stat;
 
                 err = fh_getattr(fhp, &stat);
                 if (!err) {
                         *p++ = xdr_one;         /* attributes follow */
-                        lease_get_mtime(dentry->d_inode, &stat.mtime);
+                        lease_get_mtime(d_inode(dentry), &stat.mtime);
                         return encode_fattr3(rqstp, p, fhp, &stat);
                 }
         }
@@ -233,7 +233,7 @@ encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 {
         struct dentry   *dentry = fhp->fh_dentry;
 
-        if (dentry && dentry->d_inode && fhp->fh_post_saved) {
+        if (dentry && d_really_is_positive(dentry) && fhp->fh_post_saved) {
                 if (fhp->fh_pre_saved) {
                         *p++ = xdr_one;
                         p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size);
@@ -260,11 +260,11 @@ void fill_post_wcc(struct svc_fh *fhp)
                 printk("nfsd: inode locked twice during operation.\n");
 
         err = fh_getattr(fhp, &fhp->fh_post_attr);
-        fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
+        fhp->fh_post_change = d_inode(fhp->fh_dentry)->i_version;
         if (err) {
                 fhp->fh_post_saved = 0;
                 /* Grab the ctime anyway - set_change_info might use it */
-                fhp->fh_post_attr.ctime = fhp->fh_dentry->d_inode->i_ctime;
+                fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime;
         } else
                 fhp->fh_post_saved = 1;
 }
@@ -628,7 +628,7 @@ nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
                                         struct nfsd3_attrstat *resp)
 {
         if (resp->status == 0) {
-                lease_get_mtime(resp->fh.fh_dentry->d_inode,
+                lease_get_mtime(d_inode(resp->fh.fh_dentry),
                                 &resp->stat.mtime);
                 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
         }
@@ -828,7 +828,7 @@ compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
                 return rv;
         if (d_mountpoint(dchild))
                 goto out;
-        if (!dchild->d_inode)
+        if (d_really_is_negative(dchild))
                 goto out;
         rv = fh_compose(fhp, exp, dchild, &cd->fh);
 out:
diff --git a/fs/nfsd/nfs4acl.c b/fs/nfsd/nfs4acl.c
index eaf4605a4b9e..67242bf7c6cc 100644
--- a/fs/nfsd/nfs4acl.c
+++ b/fs/nfsd/nfs4acl.c
@@ -139,7 +139,7 @@ int
 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry,
                 struct nfs4_acl **acl)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error = 0;
         struct posix_acl *pacl = NULL, *dpacl = NULL;
         unsigned int flags = 0;
@@ -780,7 +780,7 @@ nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 return error;
 
         dentry = fhp->fh_dentry;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         if (!inode->i_op->set_acl || !IS_POSIXACL(inode))
                 return nfserr_attrnotsupp;
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 4a8314f08a0e..864e2003e8de 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -52,7 +52,7 @@
 static inline void
 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
 {
-        struct inode *inode = resfh->fh_dentry->d_inode;
+        struct inode *inode = d_inode(resfh->fh_dentry);
         int status;
 
         mutex_lock(&inode->i_mutex);
@@ -110,7 +110,7 @@ check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
          * in current environment or not.
          */
         if (bmval[0] & FATTR4_WORD0_ACL) {
-                if (!IS_POSIXACL(dentry->d_inode))
+                if (!IS_POSIXACL(d_inode(dentry)))
                         return nfserr_attrnotsupp;
         }
 
@@ -209,7 +209,7 @@ do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfs
 
 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
 {
-        umode_t mode = fh->fh_dentry->d_inode->i_mode;
+        umode_t mode = d_inode(fh->fh_dentry)->i_mode;
 
         if (S_ISREG(mode))
                 return nfs_ok;
@@ -881,7 +881,7 @@ nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                                     &exp, &dentry);
         if (err)
                 return err;
-        if (dentry->d_inode == NULL) {
+        if (d_really_is_negative(dentry)) {
                 exp_put(exp);
                 err = nfserr_noent;
         } else
@@ -1312,7 +1312,7 @@ nfsd4_layoutget(struct svc_rqst *rqstp,
         if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
                 goto out_put_stid;
 
-        nfserr = ops->proc_layoutget(current_fh->fh_dentry->d_inode,
+        nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
                                      current_fh, lgp);
         if (nfserr)
                 goto out_put_stid;
@@ -1346,7 +1346,7 @@ nfsd4_layoutcommit(struct svc_rqst *rqstp,
         ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
         if (!ops)
                 goto out;
-        inode = current_fh->fh_dentry->d_inode;
+        inode = d_inode(current_fh->fh_dentry);
 
         nfserr = nfserr_inval;
         if (new_size <= seg->offset) {
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 1c307f02baa8..d88ea7b9a85c 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -192,14 +192,14 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
 
         dir = nn->rec_file->f_path.dentry;
         /* lock the parent */
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock(&d_inode(dir)->i_mutex);
 
         dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
                 goto out_unlock;
         }
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 /*
                  * In the 4.1 case, where we're called from
                  * reclaim_complete(), records from the previous reboot
@@ -209,11 +209,11 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
                  * as well be forgiving and just succeed silently.
                  */
                 goto out_put;
-        status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
+        status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU);
 out_put:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         if (status == 0) {
                 if (nn->in_grace) {
                         crp = nfs4_client_to_reclaim(dname, nn);
@@ -285,7 +285,7 @@ nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
         }
 
         status = iterate_dir(nn->rec_file, &ctx.ctx);
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
         while (!list_empty(&ctx.names)) {
                 struct name_list *entry;
                 entry = list_entry(ctx.names.next, struct name_list, list);
@@ -302,7 +302,7 @@ nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
                 list_del(&entry->list);
                 kfree(entry);
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         nfs4_reset_creds(original_cred);
         return status;
 }
@@ -316,20 +316,20 @@ nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
         dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
 
         dir = nn->rec_file->f_path.dentry;
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
         dentry = lookup_one_len(name, dir, namlen);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
                 goto out_unlock;
         }
         status = -ENOENT;
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 goto out;
-        status = vfs_rmdir(dir->d_inode, dentry);
+        status = vfs_rmdir(d_inode(dir), dentry);
 out:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         return status;
 }
 
@@ -385,7 +385,7 @@ purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
         if (nfs4_has_reclaimed_state(child->d_name.name, nn))
                 return 0;
 
-        status = vfs_rmdir(parent->d_inode, child);
+        status = vfs_rmdir(d_inode(parent), child);
         if (status)
                 printk("failed to remove client recovery directory %pd\n",
                                 child);
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index d42786ee39af..38f2d7abe3a7 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -4472,7 +4472,7 @@ nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
         struct nfs4_ol_stateid *stp = NULL;
         struct nfs4_delegation *dp = NULL;
         struct svc_fh *current_fh = &cstate->current_fh;
-        struct inode *ino = current_fh->fh_dentry->d_inode;
+        struct inode *ino = d_inode(current_fh->fh_dentry);
         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
         struct file *file = NULL;
         __be32 status;
@@ -5170,7 +5170,7 @@ lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
         struct nfs4_file *fi = ost->st_stid.sc_file;
         struct nfs4_openowner *oo = openowner(ost->st_stateowner);
         struct nfs4_client *cl = oo->oo_owner.so_client;
-        struct inode *inode = cstate->current_fh.fh_dentry->d_inode;
+        struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
         struct nfs4_lockowner *lo;
         unsigned int strhashval;
 
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index a45032ce7b80..158badf945df 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2292,7 +2292,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
         if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) ||
                         bmval[0] & FATTR4_WORD0_SUPPORTED_ATTRS) {
-                err = security_inode_getsecctx(dentry->d_inode,
+                err = security_inode_getsecctx(d_inode(dentry),
                                                 &context, &contextlen);
                 contextsupport = (err == 0);
                 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
@@ -2384,7 +2384,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
                 p = xdr_reserve_space(xdr, 8);
                 if (!p)
                         goto out_resource;
-                p = encode_change(p, &stat, dentry->d_inode);
+                p = encode_change(p, &stat, d_inode(dentry));
         }
         if (bmval0 & FATTR4_WORD0_SIZE) {
                 p = xdr_reserve_space(xdr, 8);
@@ -2807,7 +2807,7 @@ nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
         dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);
         if (IS_ERR(dentry))
                 return nfserrno(PTR_ERR(dentry));
-        if (!dentry->d_inode) {
+        if (d_really_is_negative(dentry)) {
                 /*
                  * nfsd_buffered_readdir drops the i_mutex between
                  * readdir and calling this callback, leaving a window
@@ -3324,7 +3324,7 @@ static __be32 nfsd4_encode_splice_read(
         }
 
         eof = (read->rd_offset + maxcount >=
-               read->rd_fhp->fh_dentry->d_inode->i_size);
+               d_inode(read->rd_fhp->fh_dentry)->i_size);
 
         *(p++) = htonl(eof);
         *(p++) = htonl(maxcount);
@@ -3401,7 +3401,7 @@ static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
         xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3));
 
         eof = (read->rd_offset + maxcount >=
-               read->rd_fhp->fh_dentry->d_inode->i_size);
+               d_inode(read->rd_fhp->fh_dentry)->i_size);
 
         tmp = htonl(eof);
         write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index e9fa966fc37f..350041a40fe5 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -38,7 +38,7 @@ static int nfsd_acceptable(void *expv, struct dentry *dentry)
                 /* make sure parents give x permission to user */
                 int err;
                 parent = dget_parent(tdentry);
-                err = inode_permission(parent->d_inode, MAY_EXEC);
+                err = inode_permission(d_inode(parent), MAY_EXEC);
                 if (err < 0) {
                         dput(parent);
                         break;
@@ -340,7 +340,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, int access)
         if (error)
                 goto out;
 
-        error = nfsd_mode_check(rqstp, dentry->d_inode->i_mode, type);
+        error = nfsd_mode_check(rqstp, d_inode(dentry)->i_mode, type);
         if (error)
                 goto out;
 
@@ -412,8 +412,8 @@ static inline void _fh_update_old(struct dentry *dentry,
                                   struct svc_export *exp,
                                   struct knfsd_fh *fh)
 {
-        fh->ofh_ino = ino_t_to_u32(dentry->d_inode->i_ino);
-        fh->ofh_generation = dentry->d_inode->i_generation;
+        fh->ofh_ino = ino_t_to_u32(d_inode(dentry)->i_ino);
+        fh->ofh_generation = d_inode(dentry)->i_generation;
         if (d_is_dir(dentry) ||
             (exp->ex_flags & NFSEXP_NOSUBTREECHECK))
                 fh->ofh_dirino = 0;
@@ -426,7 +426,7 @@ static bool is_root_export(struct svc_export *exp)
 
 static struct super_block *exp_sb(struct svc_export *exp)
 {
-        return exp->ex_path.dentry->d_inode->i_sb;
+        return d_inode(exp->ex_path.dentry)->i_sb;
 }
 
 static bool fsid_type_ok_for_exp(u8 fsid_type, struct svc_export *exp)
@@ -520,12 +520,12 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
          *
          */
 
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         dev_t ex_dev = exp_sb(exp)->s_dev;
 
         dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n",
                 MAJOR(ex_dev), MINOR(ex_dev),
-                (long) exp->ex_path.dentry->d_inode->i_ino,
+                (long) d_inode(exp->ex_path.dentry)->i_ino,
                 dentry,
                 (inode ? inode->i_ino : 0));
 
@@ -558,7 +558,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
                 fhp->fh_handle.ofh_dev =  old_encode_dev(ex_dev);
                 fhp->fh_handle.ofh_xdev = fhp->fh_handle.ofh_dev;
                 fhp->fh_handle.ofh_xino =
-                        ino_t_to_u32(exp->ex_path.dentry->d_inode->i_ino);
+                        ino_t_to_u32(d_inode(exp->ex_path.dentry)->i_ino);
                 fhp->fh_handle.ofh_dirino = ino_t_to_u32(parent_ino(dentry));
                 if (inode)
                         _fh_update_old(dentry, exp, &fhp->fh_handle);
@@ -570,7 +570,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
                 mk_fsid(fhp->fh_handle.fh_fsid_type,
                         fhp->fh_handle.fh_fsid,
                         ex_dev,
-                        exp->ex_path.dentry->d_inode->i_ino,
+                        d_inode(exp->ex_path.dentry)->i_ino,
                         exp->ex_fsid, exp->ex_uuid);
 
                 if (inode)
@@ -597,7 +597,7 @@ fh_update(struct svc_fh *fhp)
                 goto out_bad;
 
         dentry = fhp->fh_dentry;
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 goto out_negative;
         if (fhp->fh_handle.fh_version != 1) {
                 _fh_update_old(dentry, fhp->fh_export, &fhp->fh_handle);
diff --git a/fs/nfsd/nfsfh.h b/fs/nfsd/nfsfh.h
index f22920442172..1e90dad4926b 100644
--- a/fs/nfsd/nfsfh.h
+++ b/fs/nfsd/nfsfh.h
@@ -225,7 +225,7 @@ fill_pre_wcc(struct svc_fh *fhp)
 {
         struct inode    *inode;
 
-        inode = fhp->fh_dentry->d_inode;
+        inode = d_inode(fhp->fh_dentry);
         if (!fhp->fh_pre_saved) {
                 fhp->fh_pre_mtime = inode->i_mtime;
                 fhp->fh_pre_ctime = inode->i_ctime;
@@ -264,7 +264,7 @@ fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
                 return;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         mutex_lock_nested(&inode->i_mutex, subclass);
         fill_pre_wcc(fhp);
         fhp->fh_locked = 1;
@@ -284,7 +284,7 @@ fh_unlock(struct svc_fh *fhp)
 {
         if (fhp->fh_locked) {
                 fill_post_wcc(fhp);
-                mutex_unlock(&fhp->fh_dentry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(fhp->fh_dentry)->i_mutex);
                 fhp->fh_locked = 0;
         }
 }
diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
index b8680738f588..aecbcd34d336 100644
--- a/fs/nfsd/nfsproc.c
+++ b/fs/nfsd/nfsproc.c
@@ -223,7 +223,7 @@ nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
         }
         fh_init(newfhp, NFS_FHSIZE);
         nfserr = fh_compose(newfhp, dirfhp->fh_export, dchild, dirfhp);
-        if (!nfserr && !dchild->d_inode)
+        if (!nfserr && d_really_is_negative(dchild))
                 nfserr = nfserr_noent;
         dput(dchild);
         if (nfserr) {
@@ -241,7 +241,7 @@ nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
                 }
         }
 
-        inode = newfhp->fh_dentry->d_inode;
+        inode = d_inode(newfhp->fh_dentry);
 
         /* Unfudge the mode bits */
         if (attr->ia_valid & ATTR_MODE) {
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index 412d7061f9e5..79d964aa8079 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -187,7 +187,7 @@ encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
         *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); 
+        lease_get_mtime(d_inode(dentry), &time); 
         *p++ = htonl((u32) time.tv_sec);
         *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0); 
         *p++ = htonl((u32) stat->ctime.tv_sec);
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 368526582429..84d770be056e 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -174,7 +174,7 @@ int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp)
                 return 1;
         if (!(exp->ex_flags & NFSEXP_V4ROOT))
                 return 0;
-        return dentry->d_inode != NULL;
+        return d_inode(dentry) != NULL;
 }
 
 __be32
@@ -270,7 +270,7 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
          * dentry may be negative, it may need to be updated.
          */
         err = fh_compose(resfh, exp, dentry, fhp);
-        if (!err && !dentry->d_inode)
+        if (!err && d_really_is_negative(dentry))
                 err = nfserr_noent;
 out:
         dput(dentry);
@@ -284,7 +284,7 @@ out:
 static int
 commit_metadata(struct svc_fh *fhp)
 {
-        struct inode *inode = fhp->fh_dentry->d_inode;
+        struct inode *inode = d_inode(fhp->fh_dentry);
         const struct export_operations *export_ops = inode->i_sb->s_export_op;
 
         if (!EX_ISSYNC(fhp->fh_export))
@@ -364,7 +364,7 @@ static __be32
 nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 struct iattr *iap)
 {
-        struct inode *inode = fhp->fh_dentry->d_inode;
+        struct inode *inode = d_inode(fhp->fh_dentry);
         int host_err;
 
         if (iap->ia_size < inode->i_size) {
@@ -426,7 +426,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
         }
 
         dentry = fhp->fh_dentry;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         /* Ignore any mode updates on symlinks */
         if (S_ISLNK(inode->i_mode))
@@ -495,7 +495,7 @@ out:
  */
 int nfsd4_is_junction(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (inode == NULL)
                 return 0;
@@ -521,9 +521,9 @@ __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
 
         dentry = fhp->fh_dentry;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(dentry)->i_mutex);
         host_error = security_inode_setsecctx(dentry, label->data, label->len);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
         return nfserrno(host_error);
 }
 #else
@@ -706,7 +706,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
 
         path.mnt = fhp->fh_export->ex_path.mnt;
         path.dentry = fhp->fh_dentry;
-        inode = path.dentry->d_inode;
+        inode = d_inode(path.dentry);
 
         /* Disallow write access to files with the append-only bit set
          * or any access when mandatory locking enabled
@@ -1211,7 +1211,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out;
 
         dentry = fhp->fh_dentry;
-        dirp = dentry->d_inode;
+        dirp = d_inode(dentry);
 
         err = nfserr_notdir;
         if (!dirp->i_op->lookup)
@@ -1250,7 +1250,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
          * Make sure the child dentry is still negative ...
          */
         err = nfserr_exist;
-        if (dchild->d_inode) {
+        if (d_really_is_positive(dchild)) {
                 dprintk("nfsd_create: dentry %pd/%pd not negative!\n",
                         dentry, dchild);
                 goto out; 
@@ -1353,7 +1353,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out;
 
         dentry = fhp->fh_dentry;
-        dirp = dentry->d_inode;
+        dirp = d_inode(dentry);
 
         /* Get all the sanity checks out of the way before
          * we lock the parent. */
@@ -1376,7 +1376,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out_nfserr;
 
         /* If file doesn't exist, check for permissions to create one */
-        if (!dchild->d_inode) {
+        if (d_really_is_negative(dchild)) {
                 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
                 if (err)
                         goto out;
@@ -1397,7 +1397,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 v_atime = verifier[1]&0x7fffffff;
         }
         
-        if (dchild->d_inode) {
+        if (d_really_is_positive(dchild)) {
                 err = 0;
 
                 switch (createmode) {
@@ -1420,17 +1420,17 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                         }
                         break;
                 case NFS3_CREATE_EXCLUSIVE:
-                        if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
-                            && dchild->d_inode->i_atime.tv_sec == v_atime
-                            && dchild->d_inode->i_size  == 0 ) {
+                        if (   d_inode(dchild)->i_mtime.tv_sec == v_mtime
+                            && d_inode(dchild)->i_atime.tv_sec == v_atime
+                            && d_inode(dchild)->i_size  == 0 ) {
                                 if (created)
                                         *created = 1;
                                 break;
                         }
                 case NFS4_CREATE_EXCLUSIVE4_1:
-                        if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
-                            && dchild->d_inode->i_atime.tv_sec == v_atime
-                            && dchild->d_inode->i_size  == 0 ) {
+                        if (   d_inode(dchild)->i_mtime.tv_sec == v_mtime
+                            && d_inode(dchild)->i_atime.tv_sec == v_atime
+                            && d_inode(dchild)->i_size  == 0 ) {
                                 if (created)
                                         *created = 1;
                                 goto set_attr;
@@ -1513,7 +1513,7 @@ nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
 
         path.mnt = fhp->fh_export->ex_path.mnt;
         path.dentry = fhp->fh_dentry;
-        inode = path.dentry->d_inode;
+        inode = d_inode(path.dentry);
 
         err = nfserr_inval;
         if (!inode->i_op->readlink)
@@ -1576,7 +1576,7 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (IS_ERR(dnew))
                 goto out_nfserr;
 
-        host_err = vfs_symlink(dentry->d_inode, dnew, path);
+        host_err = vfs_symlink(d_inode(dentry), dnew, path);
         err = nfserrno(host_err);
         if (!err)
                 err = nfserrno(commit_metadata(fhp));
@@ -1632,7 +1632,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
 
         fh_lock_nested(ffhp, I_MUTEX_PARENT);
         ddir = ffhp->fh_dentry;
-        dirp = ddir->d_inode;
+        dirp = d_inode(ddir);
 
         dnew = lookup_one_len(name, ddir, len);
         host_err = PTR_ERR(dnew);
@@ -1642,7 +1642,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
         dold = tfhp->fh_dentry;
 
         err = nfserr_noent;
-        if (!dold->d_inode)
+        if (d_really_is_negative(dold))
                 goto out_dput;
         host_err = vfs_link(dold, dirp, dnew, NULL);
         if (!host_err) {
@@ -1689,10 +1689,10 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
                 goto out;
 
         fdentry = ffhp->fh_dentry;
-        fdir = fdentry->d_inode;
+        fdir = d_inode(fdentry);
 
         tdentry = tfhp->fh_dentry;
-        tdir = tdentry->d_inode;
+        tdir = d_inode(tdentry);
 
         err = nfserr_perm;
         if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
@@ -1717,7 +1717,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
                 goto out_nfserr;
 
         host_err = -ENOENT;
-        if (!odentry->d_inode)
+        if (d_really_is_negative(odentry))
                 goto out_dput_old;
         host_err = -EINVAL;
         if (odentry == trap)
@@ -1790,21 +1790,21 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
 
         fh_lock_nested(fhp, I_MUTEX_PARENT);
         dentry = fhp->fh_dentry;
-        dirp = dentry->d_inode;
+        dirp = d_inode(dentry);
 
         rdentry = lookup_one_len(fname, dentry, flen);
         host_err = PTR_ERR(rdentry);
         if (IS_ERR(rdentry))
                 goto out_nfserr;
 
-        if (!rdentry->d_inode) {
+        if (d_really_is_negative(rdentry)) {
                 dput(rdentry);
                 err = nfserr_noent;
                 goto out;
         }
 
         if (!type)
-                type = rdentry->d_inode->i_mode & S_IFMT;
+                type = d_inode(rdentry)->i_mode & S_IFMT;
 
         if (type != S_IFDIR)
                 host_err = vfs_unlink(dirp, rdentry, NULL);
@@ -2015,7 +2015,7 @@ __be32
 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
                                         struct dentry *dentry, int acc)
 {
-        struct inode    *inode = dentry->d_inode;
+        struct inode    *inode = d_inode(dentry);
         int             err;
 
         if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
index 556ce2e47555..f982ae84f0cd 100644
--- a/fs/nfsd/xdr4.h
+++ b/fs/nfsd/xdr4.h
@@ -631,7 +631,7 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)
 {
         BUG_ON(!fhp->fh_pre_saved);
         cinfo->atomic = fhp->fh_post_saved;
-        cinfo->change_supported = IS_I_VERSION(fhp->fh_dentry->d_inode);
+        cinfo->change_supported = IS_I_VERSION(d_inode(fhp->fh_dentry));
 
         cinfo->before_change = fhp->fh_pre_change;
         cinfo->after_change = fhp->fh_post_change;