VFS: normal filesystems (and lustre): d_inode() annotations

that's the bulk of filesystem drivers dealing with inodes of their own

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

9 files changed, 96 insertions, 96 deletions

diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 8172775428a0..283cf69c6904 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -3391,7 +3391,7 @@ int ceph_encode_inode_release(void **p, struct inode *inode,
 int ceph_encode_dentry_release(void **p, struct dentry *dentry,
                                int mds, int drop, int unless)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct ceph_mds_request_release *rel = *p;
         struct ceph_dentry_info *di = ceph_dentry(dentry);
         int force = 0;
diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index 1b2355109b9f..31f831471ed2 100644
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -84,7 +84,7 @@ static int mdsc_show(struct seq_file *s, void *p)
                                 path = NULL;
                         spin_lock(&req->r_dentry->d_lock);
                         seq_printf(s, " #%llx/%pd (%s)",
-                                   ceph_ino(req->r_dentry->d_parent->d_inode),
+                                   ceph_ino(d_inode(req->r_dentry->d_parent)),
                                    req->r_dentry,
                                    path ? path : "");
                         spin_unlock(&req->r_dentry->d_lock);
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 83e9976f7189..173fc598c7f1 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -49,9 +49,9 @@ int ceph_init_dentry(struct dentry *dentry)
                 goto out_unlock;
         }
 
-        if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP)
+        if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_NOSNAP)
                 d_set_d_op(dentry, &ceph_dentry_ops);
-        else if (ceph_snap(dentry->d_parent->d_inode) == CEPH_SNAPDIR)
+        else if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_SNAPDIR)
                 d_set_d_op(dentry, &ceph_snapdir_dentry_ops);
         else
                 d_set_d_op(dentry, &ceph_snap_dentry_ops);
@@ -77,7 +77,7 @@ struct inode *ceph_get_dentry_parent_inode(struct dentry *dentry)
 
         spin_lock(&dentry->d_lock);
         if (!IS_ROOT(dentry)) {
-                inode = dentry->d_parent->d_inode;
+                inode = d_inode(dentry->d_parent);
                 ihold(inode);
         }
         spin_unlock(&dentry->d_lock);
@@ -122,7 +122,7 @@ static int __dcache_readdir(struct file *file,  struct dir_context *ctx,
 {
         struct ceph_file_info *fi = file->private_data;
         struct dentry *parent = file->f_path.dentry;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct list_head *p;
         struct dentry *dentry, *last;
         struct ceph_dentry_info *di;
@@ -161,15 +161,15 @@ more:
                 }
                 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
                 if (di->lease_shared_gen == shared_gen &&
-                    !d_unhashed(dentry) && dentry->d_inode &&
-                    ceph_snap(dentry->d_inode) != CEPH_SNAPDIR &&
-                    ceph_ino(dentry->d_inode) != CEPH_INO_CEPH &&
+                    !d_unhashed(dentry) && d_really_is_positive(dentry) &&
+                    ceph_snap(d_inode(dentry)) != CEPH_SNAPDIR &&
+                    ceph_ino(d_inode(dentry)) != CEPH_INO_CEPH &&
                     fpos_cmp(ctx->pos, di->offset) <= 0)
                         break;
                 dout(" skipping %p %pd at %llu (%llu)%s%s\n", dentry,
                      dentry, di->offset,
                      ctx->pos, d_unhashed(dentry) ? " unhashed" : "",
-                     !dentry->d_inode ? " null" : "");
+                     !d_inode(dentry) ? " null" : "");
                 spin_unlock(&dentry->d_lock);
                 p = p->prev;
                 dentry = list_entry(p, struct dentry, d_child);
@@ -189,11 +189,11 @@ more:
         }
 
         dout(" %llu (%llu) dentry %p %pd %p\n", di->offset, ctx->pos,
-             dentry, dentry, dentry->d_inode);
+             dentry, dentry, d_inode(dentry));
         if (!dir_emit(ctx, dentry->d_name.name,
                       dentry->d_name.len,
-                      ceph_translate_ino(dentry->d_sb, dentry->d_inode->i_ino),
-                      dentry->d_inode->i_mode >> 12)) {
+                      ceph_translate_ino(dentry->d_sb, d_inode(dentry)->i_ino),
+                      d_inode(dentry)->i_mode >> 12)) {
                 if (last) {
                         /* remember our position */
                         fi->dentry = last;
@@ -535,7 +535,7 @@ int ceph_handle_snapdir(struct ceph_mds_request *req,
                         struct dentry *dentry, int err)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
-        struct inode *parent = dentry->d_parent->d_inode; /* we hold i_mutex */
+        struct inode *parent = d_inode(dentry->d_parent); /* we hold i_mutex */
 
         /* .snap dir? */
         if (err == -ENOENT &&
@@ -571,8 +571,8 @@ struct dentry *ceph_finish_lookup(struct ceph_mds_request *req,
                 err = 0;
                 if (!req->r_reply_info.head->is_dentry) {
                         dout("ENOENT and no trace, dentry %p inode %p\n",
-                             dentry, dentry->d_inode);
-                        if (dentry->d_inode) {
+                             dentry, d_inode(dentry));
+                        if (d_really_is_positive(dentry)) {
                                 d_drop(dentry);
                                 err = -ENOENT;
                         } else {
@@ -619,7 +619,7 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
                 return ERR_PTR(err);
 
         /* can we conclude ENOENT locally? */
-        if (dentry->d_inode == NULL) {
+        if (d_really_is_negative(dentry)) {
                 struct ceph_inode_info *ci = ceph_inode(dir);
                 struct ceph_dentry_info *di = ceph_dentry(dentry);
 
@@ -725,7 +725,7 @@ static int ceph_mknod(struct inode *dir, struct dentry *dentry,
         ceph_mdsc_put_request(req);
 out:
         if (!err)
-                ceph_init_inode_acls(dentry->d_inode, &acls);
+                ceph_init_inode_acls(d_inode(dentry), &acls);
         else
                 d_drop(dentry);
         ceph_release_acls_info(&acls);
@@ -821,7 +821,7 @@ static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         ceph_mdsc_put_request(req);
 out:
         if (!err)
-                ceph_init_inode_acls(dentry->d_inode, &acls);
+                ceph_init_inode_acls(d_inode(dentry), &acls);
         else
                 d_drop(dentry);
         ceph_release_acls_info(&acls);
@@ -858,8 +858,8 @@ static int ceph_link(struct dentry *old_dentry, struct inode *dir,
         if (err) {
                 d_drop(dentry);
         } else if (!req->r_reply_info.head->is_dentry) {
-                ihold(old_dentry->d_inode);
-                d_instantiate(dentry, old_dentry->d_inode);
+                ihold(d_inode(old_dentry));
+                d_instantiate(dentry, d_inode(old_dentry));
         }
         ceph_mdsc_put_request(req);
         return err;
@@ -892,7 +892,7 @@ static int ceph_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_mds_request *req;
         int err = -EROFS;
         int op;
@@ -957,8 +957,8 @@ static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
         req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
         /* release LINK_RDCACHE on source inode (mds will lock it) */
         req->r_old_inode_drop = CEPH_CAP_LINK_SHARED;
-        if (new_dentry->d_inode)
-                req->r_inode_drop = drop_caps_for_unlink(new_dentry->d_inode);
+        if (d_really_is_positive(new_dentry))
+                req->r_inode_drop = drop_caps_for_unlink(d_inode(new_dentry));
         err = ceph_mdsc_do_request(mdsc, old_dir, req);
         if (!err && !req->r_reply_info.head->is_dentry) {
                 /*
@@ -1024,7 +1024,7 @@ static int dentry_lease_is_valid(struct dentry *dentry)
                         if (di->lease_renew_after &&
                             time_after(jiffies, di->lease_renew_after)) {
                                 /* we should renew */
-                                dir = dentry->d_parent->d_inode;
+                                dir = d_inode(dentry->d_parent);
                                 session = ceph_get_mds_session(s);
                                 seq = di->lease_seq;
                                 di->lease_renew_after = 0;
@@ -1074,22 +1074,22 @@ static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         dout("d_revalidate %p '%pd' inode %p offset %lld\n", dentry,
-             dentry, dentry->d_inode, ceph_dentry(dentry)->offset);
+             dentry, d_inode(dentry), ceph_dentry(dentry)->offset);
 
         dir = ceph_get_dentry_parent_inode(dentry);
 
         /* always trust cached snapped dentries, snapdir dentry */
         if (ceph_snap(dir) != CEPH_NOSNAP) {
                 dout("d_revalidate %p '%pd' inode %p is SNAPPED\n", dentry,
-                     dentry, dentry->d_inode);
+                     dentry, d_inode(dentry));
                 valid = 1;
-        } else if (dentry->d_inode &&
-                   ceph_snap(dentry->d_inode) == CEPH_SNAPDIR) {
+        } else if (d_really_is_positive(dentry) &&
+                   ceph_snap(d_inode(dentry)) == CEPH_SNAPDIR) {
                 valid = 1;
         } else if (dentry_lease_is_valid(dentry) ||
                    dir_lease_is_valid(dir, dentry)) {
-                if (dentry->d_inode)
-                        valid = ceph_is_any_caps(dentry->d_inode);
+                if (d_really_is_positive(dentry))
+                        valid = ceph_is_any_caps(d_inode(dentry));
                 else
                         valid = 1;
         }
@@ -1151,7 +1151,7 @@ static void ceph_d_prune(struct dentry *dentry)
          * we hold d_lock, so d_parent is stable, and d_fsdata is never
          * cleared until d_release
          */
-        ceph_dir_clear_complete(dentry->d_parent->d_inode);
+        ceph_dir_clear_complete(d_inode(dentry->d_parent));
 }
 
 /*
diff --git a/fs/ceph/export.c b/fs/ceph/export.c
index 8d7d782f4382..fe02ae7f056a 100644
--- a/fs/ceph/export.c
+++ b/fs/ceph/export.c
@@ -136,8 +136,8 @@ static struct dentry *__get_parent(struct super_block *sb,
                 return ERR_CAST(req);
 
         if (child) {
-                req->r_inode = child->d_inode;
-                ihold(child->d_inode);
+                req->r_inode = d_inode(child);
+                ihold(d_inode(child));
         } else {
                 req->r_ino1 = (struct ceph_vino) {
                         .ino = ino,
@@ -164,7 +164,7 @@ static struct dentry *__get_parent(struct super_block *sb,
                 return ERR_PTR(err);
         }
         dout("__get_parent ino %llx parent %p ino %llx.%llx\n",
-             child ? ceph_ino(child->d_inode) : ino,
+             child ? ceph_ino(d_inode(child)) : ino,
              dentry, ceph_vinop(inode));
         return dentry;
 }
@@ -172,11 +172,11 @@ static struct dentry *__get_parent(struct super_block *sb,
 static struct dentry *ceph_get_parent(struct dentry *child)
 {
         /* don't re-export snaps */
-        if (ceph_snap(child->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(d_inode(child)) != CEPH_NOSNAP)
                 return ERR_PTR(-EINVAL);
 
         dout("get_parent %p ino %llx.%llx\n",
-             child, ceph_vinop(child->d_inode));
+             child, ceph_vinop(d_inode(child)));
         return __get_parent(child->d_sb, child, 0);
 }
 
@@ -209,32 +209,32 @@ static int ceph_get_name(struct dentry *parent, char *name,
         struct ceph_mds_request *req;
         int err;
 
-        mdsc = ceph_inode_to_client(child->d_inode)->mdsc;
+        mdsc = ceph_inode_to_client(d_inode(child))->mdsc;
         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
                                        USE_ANY_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
 
-        req->r_inode = child->d_inode;
-        ihold(child->d_inode);
-        req->r_ino2 = ceph_vino(parent->d_inode);
-        req->r_locked_dir = parent->d_inode;
+        req->r_inode = d_inode(child);
+        ihold(d_inode(child));
+        req->r_ino2 = ceph_vino(d_inode(parent));
+        req->r_locked_dir = d_inode(parent);
         req->r_num_caps = 2;
         err = ceph_mdsc_do_request(mdsc, NULL, req);
 
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 
         if (!err) {
                 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
                 memcpy(name, rinfo->dname, rinfo->dname_len);
                 name[rinfo->dname_len] = 0;
                 dout("get_name %p ino %llx.%llx name %s\n",
-                     child, ceph_vinop(child->d_inode), name);
+                     child, ceph_vinop(d_inode(child)), name);
         } else {
                 dout("get_name %p ino %llx.%llx err %d\n",
-                     child, ceph_vinop(child->d_inode), err);
+                     child, ceph_vinop(d_inode(child)), err);
         }
 
         ceph_mdsc_put_request(req);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index b9b8eb225f66..3b6b522b4b31 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -291,14 +291,14 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
         }
         if (err)
                 goto out_req;
-        if (dn || dentry->d_inode == NULL || d_is_symlink(dentry)) {
+        if (dn || d_really_is_negative(dentry) || d_is_symlink(dentry)) {
                 /* make vfs retry on splice, ENOENT, or symlink */
                 dout("atomic_open finish_no_open on dn %p\n", dn);
                 err = finish_no_open(file, dn);
         } else {
                 dout("atomic_open finish_open on dn %p\n", dn);
                 if (req->r_op == CEPH_MDS_OP_CREATE && req->r_reply_info.has_create_ino) {
-                        ceph_init_inode_acls(dentry->d_inode, &acls);
+                        ceph_init_inode_acls(d_inode(dentry), &acls);
                         *opened |= FILE_CREATED;
                 }
                 err = finish_open(file, dentry, ceph_open, opened);
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 119c43c80638..e876e1944519 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -940,7 +940,7 @@ static void update_dentry_lease(struct dentry *dentry,
              dentry, duration, ttl);
 
         /* make lease_rdcache_gen match directory */
-        dir = dentry->d_parent->d_inode;
+        dir = d_inode(dentry->d_parent);
         di->lease_shared_gen = ceph_inode(dir)->i_shared_gen;
 
         if (duration == 0)
@@ -980,7 +980,7 @@ static struct dentry *splice_dentry(struct dentry *dn, struct inode *in,
 {
         struct dentry *realdn;
 
-        BUG_ON(dn->d_inode);
+        BUG_ON(d_inode(dn));
 
         /* dn must be unhashed */
         if (!d_unhashed(dn))
@@ -998,13 +998,13 @@ static struct dentry *splice_dentry(struct dentry *dn, struct inode *in,
                      "inode %p ino %llx.%llx\n",
                      dn, d_count(dn),
                      realdn, d_count(realdn),
-                     realdn->d_inode, ceph_vinop(realdn->d_inode));
+                     d_inode(realdn), ceph_vinop(d_inode(realdn)));
                 dput(dn);
                 dn = realdn;
         } else {
                 BUG_ON(!ceph_dentry(dn));
                 dout("dn %p attached to %p ino %llx.%llx\n",
-                     dn, dn->d_inode, ceph_vinop(dn->d_inode));
+                     dn, d_inode(dn), ceph_vinop(d_inode(dn)));
         }
         if ((!prehash || *prehash) && d_unhashed(dn))
                 d_rehash(dn);
@@ -1125,11 +1125,11 @@ retry_lookup:
                                         dput(parent);
                                         goto done;
                                 }
-                        } else if (dn->d_inode &&
-                                   (ceph_ino(dn->d_inode) != vino.ino ||
-                                    ceph_snap(dn->d_inode) != vino.snap)) {
+                        } else if (d_really_is_positive(dn) &&
+                                   (ceph_ino(d_inode(dn)) != vino.ino ||
+                                    ceph_snap(d_inode(dn)) != vino.snap)) {
                                 dout(" dn %p points to wrong inode %p\n",
-                                     dn, dn->d_inode);
+                                     dn, d_inode(dn));
                                 d_delete(dn);
                                 dput(dn);
                                 goto retry_lookup;
@@ -1183,7 +1183,7 @@ retry_lookup:
 
                 BUG_ON(!dn);
                 BUG_ON(!dir);
-                BUG_ON(dn->d_parent->d_inode != dir);
+                BUG_ON(d_inode(dn->d_parent) != dir);
                 BUG_ON(ceph_ino(dir) !=
                        le64_to_cpu(rinfo->diri.in->ino));
                 BUG_ON(ceph_snap(dir) !=
@@ -1235,7 +1235,7 @@ retry_lookup:
                 /* null dentry? */
                 if (!rinfo->head->is_target) {
                         dout("fill_trace null dentry\n");
-                        if (dn->d_inode) {
+                        if (d_really_is_positive(dn)) {
                                 ceph_dir_clear_ordered(dir);
                                 dout("d_delete %p\n", dn);
                                 d_delete(dn);
@@ -1252,7 +1252,7 @@ retry_lookup:
                 }
 
                 /* attach proper inode */
-                if (!dn->d_inode) {
+                if (d_really_is_negative(dn)) {
                         ceph_dir_clear_ordered(dir);
                         ihold(in);
                         dn = splice_dentry(dn, in, &have_lease);
@@ -1261,9 +1261,9 @@ retry_lookup:
                                 goto done;
                         }
                         req->r_dentry = dn;  /* may have spliced */
-                } else if (dn->d_inode && dn->d_inode != in) {
+                } else if (d_really_is_positive(dn) && d_inode(dn) != in) {
                         dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
-                             dn, dn->d_inode, ceph_vinop(dn->d_inode),
+                             dn, d_inode(dn), ceph_vinop(d_inode(dn)),
                              ceph_vinop(in));
                         have_lease = false;
                 }
@@ -1363,7 +1363,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
                 return readdir_prepopulate_inodes_only(req, session);
 
         if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) {
-                snapdir = ceph_get_snapdir(parent->d_inode);
+                snapdir = ceph_get_snapdir(d_inode(parent));
                 parent = d_find_alias(snapdir);
                 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n",
                      rinfo->dir_nr, parent);
@@ -1371,7 +1371,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
                 dout("readdir_prepopulate %d items under dn %p\n",
                      rinfo->dir_nr, parent);
                 if (rinfo->dir_dir)
-                        ceph_fill_dirfrag(parent->d_inode, rinfo->dir_dir);
+                        ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);
         }
 
         /* FIXME: release caps/leases if error occurs */
@@ -1405,11 +1405,11 @@ retry_lookup:
                                 err = ret;
                                 goto out;
                         }
-                } else if (dn->d_inode &&
-                           (ceph_ino(dn->d_inode) != vino.ino ||
-                            ceph_snap(dn->d_inode) != vino.snap)) {
+                } else if (d_really_is_positive(dn) &&
+                           (ceph_ino(d_inode(dn)) != vino.ino ||
+                            ceph_snap(d_inode(dn)) != vino.snap)) {
                         dout(" dn %p points to wrong inode %p\n",
-                             dn, dn->d_inode);
+                             dn, d_inode(dn));
                         d_delete(dn);
                         dput(dn);
                         goto retry_lookup;
@@ -1423,8 +1423,8 @@ retry_lookup:
                 }
 
                 /* inode */
-                if (dn->d_inode) {
-                        in = dn->d_inode;
+                if (d_really_is_positive(dn)) {
+                        in = d_inode(dn);
                 } else {
                         in = ceph_get_inode(parent->d_sb, vino);
                         if (IS_ERR(in)) {
@@ -1440,13 +1440,13 @@ retry_lookup:
                                req->r_request_started, -1,
                                &req->r_caps_reservation) < 0) {
                         pr_err("fill_inode badness on %p\n", in);
-                        if (!dn->d_inode)
+                        if (d_really_is_negative(dn))
                                 iput(in);
                         d_drop(dn);
                         goto next_item;
                 }
 
-                if (!dn->d_inode) {
+                if (d_really_is_negative(dn)) {
                         struct dentry *realdn = splice_dentry(dn, in, NULL);
                         if (IS_ERR(realdn)) {
                                 err = PTR_ERR(realdn);
@@ -1693,7 +1693,7 @@ retry:
  */
 static void *ceph_sym_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ceph_inode_info *ci = ceph_inode(dentry->d_inode);
+        struct ceph_inode_info *ci = ceph_inode(d_inode(dentry));
         nd_set_link(nd, ci->i_symlink);
         return NULL;
 }
@@ -1714,7 +1714,7 @@ static const struct inode_operations ceph_symlink_iops = {
  */
 int ceph_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         const unsigned int ia_valid = attr->ia_valid;
         struct ceph_mds_request *req;
@@ -1990,7 +1990,7 @@ int ceph_permission(struct inode *inode, int mask)
 int ceph_getattr(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         int err;
 
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 71c073f38e54..a39389092102 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -679,7 +679,7 @@ static struct dentry *get_nonsnap_parent(struct dentry *dentry)
          * except to resplice to another snapdir, and either the old or new
          * result is a valid result.
          */
-        while (!IS_ROOT(dentry) && ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
+        while (!IS_ROOT(dentry) && ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
                 dentry = dentry->d_parent;
         return dentry;
 }
@@ -716,20 +716,20 @@ static int __choose_mds(struct ceph_mds_client *mdsc,
         } else if (req->r_dentry) {
                 /* ignore race with rename; old or new d_parent is okay */
                 struct dentry *parent = req->r_dentry->d_parent;
-                struct inode *dir = parent->d_inode;
+                struct inode *dir = d_inode(parent);
 
                 if (dir->i_sb != mdsc->fsc->sb) {
                         /* not this fs! */
-                        inode = req->r_dentry->d_inode;
+                        inode = d_inode(req->r_dentry);
                 } else if (ceph_snap(dir) != CEPH_NOSNAP) {
                         /* direct snapped/virtual snapdir requests
                          * based on parent dir inode */
                         struct dentry *dn = get_nonsnap_parent(parent);
-                        inode = dn->d_inode;
+                        inode = d_inode(dn);
                         dout("__choose_mds using nonsnap parent %p\n", inode);
                 } else {
                         /* dentry target */
-                        inode = req->r_dentry->d_inode;
+                        inode = d_inode(req->r_dentry);
                         if (!inode || mode == USE_AUTH_MDS) {
                                 /* dir + name */
                                 inode = dir;
@@ -1712,7 +1712,7 @@ retry:
         seq = read_seqbegin(&rename_lock);
         rcu_read_lock();
         for (temp = dentry; !IS_ROOT(temp);) {
-                struct inode *inode = temp->d_inode;
+                struct inode *inode = d_inode(temp);
                 if (inode && ceph_snap(inode) == CEPH_SNAPDIR)
                         len++;  /* slash only */
                 else if (stop_on_nosnap && inode &&
@@ -1736,7 +1736,7 @@ retry:
                 struct inode *inode;
 
                 spin_lock(&temp->d_lock);
-                inode = temp->d_inode;
+                inode = d_inode(temp);
                 if (inode && ceph_snap(inode) == CEPH_SNAPDIR) {
                         dout("build_path path+%d: %p SNAPDIR\n",
                              pos, temp);
@@ -1770,7 +1770,7 @@ retry:
                 goto retry;
         }
 
-        *base = ceph_ino(temp->d_inode);
+        *base = ceph_ino(d_inode(temp));
         *plen = len;
         dout("build_path on %p %d built %llx '%.*s'\n",
              dentry, d_count(dentry), *base, len, path);
@@ -1783,8 +1783,8 @@ static int build_dentry_path(struct dentry *dentry,
 {
         char *path;
 
-        if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP) {
-                *pino = ceph_ino(dentry->d_parent->d_inode);
+        if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_NOSNAP) {
+                *pino = ceph_ino(d_inode(dentry->d_parent));
                 *ppath = dentry->d_name.name;
                 *ppathlen = dentry->d_name.len;
                 return 0;
@@ -1925,7 +1925,7 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
         releases = 0;
         if (req->r_inode_drop)
                 releases += ceph_encode_inode_release(&p,
-                      req->r_inode ? req->r_inode : req->r_dentry->d_inode,
+                      req->r_inode ? req->r_inode : d_inode(req->r_dentry),
                       mds, req->r_inode_drop, req->r_inode_unless, 0);
         if (req->r_dentry_drop)
                 releases += ceph_encode_dentry_release(&p, req->r_dentry,
@@ -1935,7 +1935,7 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
                        mds, req->r_old_dentry_drop, req->r_old_dentry_unless);
         if (req->r_old_inode_drop)
                 releases += ceph_encode_inode_release(&p,
-                      req->r_old_dentry->d_inode,
+                      d_inode(req->r_old_dentry),
                       mds, req->r_old_inode_drop, req->r_old_inode_unless, 0);
         head->num_releases = cpu_to_le16(releases);
 
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index a63997b8bcff..e68591df9942 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -44,7 +44,7 @@ static void ceph_put_super(struct super_block *s)
 
 static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct ceph_fs_client *fsc = ceph_inode_to_client(dentry->d_inode);
+        struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry));
         struct ceph_monmap *monmap = fsc->client->monc.monmap;
         struct ceph_statfs st;
         u64 fsid;
@@ -976,7 +976,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type,
         if (IS_ERR(res))
                 goto out_splat;
         dout("root %p inode %p ino %llx.%llx\n", res,
-             res->d_inode, ceph_vinop(res->d_inode));
+             d_inode(res), ceph_vinop(d_inode(res)));
         return res;
 
 out_splat:
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index 5a492caf34cb..e448766ce549 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -776,12 +776,12 @@ ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
                 return generic_getxattr(dentry, name, value, size);
 
-        return __ceph_getxattr(dentry->d_inode, name, value, size);
+        return __ceph_getxattr(d_inode(dentry), name, value, size);
 }
 
 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode);
         u32 vir_namelen = 0;
@@ -847,7 +847,7 @@ static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
                               const char *value, size_t size, int flags)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_mds_request *req;
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -901,7 +901,7 @@ out:
 int __ceph_setxattr(struct dentry *dentry, const char *name,
                         const void *value, size_t size, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_vxattr *vxattr;
         struct ceph_inode_info *ci = ceph_inode(inode);
         int issued;
@@ -995,7 +995,7 @@ out:
 int ceph_setxattr(struct dentry *dentry, const char *name,
                   const void *value, size_t size, int flags)
 {
-        if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
                 return -EROFS;
 
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
@@ -1011,7 +1011,7 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_mds_request *req;
         int err;
 
@@ -1032,7 +1032,7 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
 
 int __ceph_removexattr(struct dentry *dentry, const char *name)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_vxattr *vxattr;
         struct ceph_inode_info *ci = ceph_inode(inode);
         int issued;
@@ -1098,7 +1098,7 @@ out:
 
 int ceph_removexattr(struct dentry *dentry, const char *name)
 {
-        if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
                 return -EROFS;
 
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))