VFS: normal filesystems (and lustre): d_inode() annotations
authorDavid Howells <dhowells@redhat.com>
Tue, 17 Mar 2015 22:25:59 +0000 (22:25 +0000)
committerAl Viro <viro@zeniv.linux.org.uk>
Wed, 15 Apr 2015 19:06:57 +0000 (15:06 -0400)
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>
278 files changed:
drivers/staging/lustre/lustre/llite/dcache.c
drivers/staging/lustre/lustre/llite/file.c
drivers/staging/lustre/lustre/llite/llite_internal.h
drivers/staging/lustre/lustre/llite/llite_lib.c
drivers/staging/lustre/lustre/llite/llite_nfs.c
drivers/staging/lustre/lustre/llite/namei.c
drivers/staging/lustre/lustre/llite/statahead.c
drivers/staging/lustre/lustre/llite/symlink.c
drivers/staging/lustre/lustre/llite/xattr.c
fs/9p/acl.c
fs/9p/vfs_dentry.c
fs/9p/vfs_inode.c
fs/9p/vfs_inode_dotl.c
fs/9p/vfs_super.c
fs/adfs/inode.c
fs/affs/amigaffs.c
fs/affs/inode.c
fs/affs/namei.c
fs/afs/dir.c
fs/afs/inode.c
fs/afs/mntpt.c
fs/afs/super.c
fs/autofs4/autofs_i.h
fs/autofs4/expire.c
fs/autofs4/inode.c
fs/autofs4/root.c
fs/autofs4/symlink.c
fs/autofs4/waitq.c
fs/befs/linuxvfs.c
fs/bfs/dir.c
fs/btrfs/export.c
fs/btrfs/file.c
fs/btrfs/inode.c
fs/btrfs/ioctl.c
fs/btrfs/super.c
fs/btrfs/tree-log.c
fs/btrfs/xattr.c
fs/ceph/caps.c
fs/ceph/debugfs.c
fs/ceph/dir.c
fs/ceph/export.c
fs/ceph/file.c
fs/ceph/inode.c
fs/ceph/mds_client.c
fs/ceph/super.c
fs/ceph/xattr.c
fs/cifs/cifs_dfs_ref.c
fs/cifs/cifsfs.c
fs/cifs/cifssmb.c
fs/cifs/dir.c
fs/cifs/file.c
fs/cifs/inode.c
fs/cifs/link.c
fs/cifs/misc.c
fs/cifs/readdir.c
fs/cifs/smb1ops.c
fs/cifs/smb2file.c
fs/cifs/smb2misc.c
fs/cifs/smb2ops.c
fs/cifs/xattr.c
fs/coda/cache.c
fs/coda/dir.c
fs/coda/inode.c
fs/coda/pioctl.c
fs/coda/upcall.c
fs/configfs/dir.c
fs/configfs/file.c
fs/configfs/inode.c
fs/debugfs/file.c
fs/debugfs/inode.c
fs/devpts/inode.c
fs/ecryptfs/crypto.c
fs/ecryptfs/dentry.c
fs/ecryptfs/file.c
fs/ecryptfs/inode.c
fs/ecryptfs/kthread.c
fs/ecryptfs/main.c
fs/ecryptfs/mmap.c
fs/efivarfs/inode.c
fs/efivarfs/super.c
fs/efs/namei.c
fs/exofs/dir.c
fs/exofs/inode.c
fs/exofs/namei.c
fs/exofs/super.c
fs/exofs/symlink.c
fs/ext2/dir.c
fs/ext2/ialloc.c
fs/ext2/inode.c
fs/ext2/namei.c
fs/ext2/symlink.c
fs/ext2/xattr.c
fs/ext2/xattr_security.c
fs/ext2/xattr_trusted.c
fs/ext2/xattr_user.c
fs/ext3/ialloc.c
fs/ext3/inode.c
fs/ext3/namei.c
fs/ext3/super.c
fs/ext3/symlink.c
fs/ext3/xattr.c
fs/ext3/xattr_security.c
fs/ext3/xattr_trusted.c
fs/ext3/xattr_user.c
fs/ext4/fsync.c
fs/ext4/ialloc.c
fs/ext4/inline.c
fs/ext4/inode.c
fs/ext4/migrate.c
fs/ext4/namei.c
fs/ext4/super.c
fs/ext4/symlink.c
fs/ext4/xattr.c
fs/ext4/xattr_security.c
fs/ext4/xattr_trusted.c
fs/ext4/xattr_user.c
fs/f2fs/f2fs.h
fs/f2fs/file.c
fs/f2fs/namei.c
fs/f2fs/xattr.c
fs/fat/file.c
fs/fat/namei_msdos.c
fs/fat/namei_vfat.c
fs/fat/nfs.c
fs/freevxfs/vxfs_immed.c
fs/fuse/control.c
fs/fuse/dir.c
fs/fuse/inode.c
fs/gfs2/dentry.c
fs/gfs2/export.c
fs/gfs2/inode.c
fs/gfs2/ops_fstype.c
fs/gfs2/super.c
fs/gfs2/xattr.c
fs/hfs/attr.c
fs/hfs/dir.c
fs/hfs/inode.c
fs/hfs/sysdep.c
fs/hfsplus/dir.c
fs/hfsplus/inode.c
fs/hfsplus/ioctl.c
fs/hfsplus/xattr.c
fs/hfsplus/xattr.h
fs/hostfs/hostfs_kern.c
fs/hpfs/inode.c
fs/hpfs/namei.c
fs/hppfs/hppfs.c
fs/hugetlbfs/inode.c
fs/isofs/export.c
fs/jffs2/dir.c
fs/jffs2/fs.c
fs/jffs2/security.c
fs/jffs2/super.c
fs/jffs2/symlink.c
fs/jffs2/xattr.c
fs/jffs2/xattr_trusted.c
fs/jffs2/xattr_user.c
fs/jfs/file.c
fs/jfs/namei.c
fs/jfs/symlink.c
fs/jfs/xattr.c
fs/kernfs/dir.c
fs/kernfs/inode.c
fs/logfs/dir.c
fs/logfs/file.c
fs/minix/dir.c
fs/minix/file.c
fs/minix/inode.c
fs/minix/namei.c
fs/ncpfs/dir.c
fs/ncpfs/inode.c
fs/ncpfs/ioctl.c
fs/ncpfs/ncplib_kernel.c
fs/ncpfs/symlink.c
fs/nfs/dir.c
fs/nfs/direct.c
fs/nfs/getroot.c
fs/nfs/inode.c
fs/nfs/namespace.c
fs/nfs/nfs3acl.c
fs/nfs/nfs3proc.c
fs/nfs/nfs4client.c
fs/nfs/nfs4file.c
fs/nfs/nfs4namespace.c
fs/nfs/nfs4proc.c
fs/nfs/nfs4state.c
fs/nfs/nfs4trace.h
fs/nfs/pagelist.c
fs/nfs/pnfs.h
fs/nfs/proc.c
fs/nfs/read.c
fs/nfs/super.c
fs/nfs/symlink.c
fs/nfs/unlink.c
fs/nfs/write.c
fs/nfsd/export.c
fs/nfsd/nfs2acl.c
fs/nfsd/nfs3acl.c
fs/nfsd/nfs3proc.c
fs/nfsd/nfs3xdr.c
fs/nfsd/nfs4acl.c
fs/nfsd/nfs4proc.c
fs/nfsd/nfs4recover.c
fs/nfsd/nfs4state.c
fs/nfsd/nfs4xdr.c
fs/nfsd/nfsfh.c
fs/nfsd/nfsfh.h
fs/nfsd/nfsproc.c
fs/nfsd/nfsxdr.c
fs/nfsd/vfs.c
fs/nfsd/xdr4.h
fs/nilfs2/dir.c
fs/nilfs2/inode.c
fs/nilfs2/namei.c
fs/nilfs2/super.c
fs/ntfs/inode.c
fs/ntfs/namei.c
fs/ocfs2/dcache.c
fs/ocfs2/dir.h
fs/ocfs2/dlmfs/dlmfs.c
fs/ocfs2/export.c
fs/ocfs2/file.c
fs/ocfs2/inode.c
fs/ocfs2/namei.c
fs/ocfs2/refcounttree.c
fs/ocfs2/xattr.c
fs/omfs/dir.c
fs/omfs/file.c
fs/proc/base.c
fs/proc/fd.c
fs/proc/generic.c
fs/proc/inode.c
fs/proc/namespaces.c
fs/proc/proc_net.c
fs/proc/proc_sysctl.c
fs/proc/root.c
fs/proc/self.c
fs/proc/thread_self.c
fs/pstore/inode.c
fs/qnx6/inode.c
fs/ramfs/file-nommu.c
fs/reiserfs/dir.c
fs/reiserfs/inode.c
fs/reiserfs/namei.c
fs/reiserfs/super.c
fs/reiserfs/xattr.c
fs/reiserfs/xattr.h
fs/reiserfs/xattr_security.c
fs/reiserfs/xattr_trusted.c
fs/reiserfs/xattr_user.c
fs/squashfs/export.c
fs/squashfs/xattr.c
fs/sysv/dir.c
fs/sysv/file.c
fs/sysv/itree.c
fs/sysv/namei.c
fs/sysv/symlink.c
fs/ubifs/dir.c
fs/ubifs/file.c
fs/ubifs/journal.c
fs/ubifs/xattr.c
fs/udf/file.c
fs/udf/namei.c
fs/ufs/dir.c
fs/ufs/namei.c
fs/ufs/super.c
fs/ufs/symlink.c
fs/ufs/truncate.c
fs/xfs/xfs_export.c
fs/xfs/xfs_filestream.c
fs/xfs/xfs_ioctl.c
fs/xfs/xfs_ioctl32.c
fs/xfs/xfs_iops.c
fs/xfs/xfs_super.c
fs/xfs/xfs_xattr.c
include/trace/events/btrfs.h
include/trace/events/ext3.h
include/trace/events/ext4.h

index ddf1fa9f67f8f80fbb8237260a0b4bef3a74b0d4..16e87e97121fad86042d7c1613f2f952a0919ab5 100644 (file)
@@ -153,7 +153,7 @@ static int ll_ddelete(const struct dentry *de)
 
        CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
               d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
-              de, de, de->d_parent, de->d_inode,
+              de, de, de->d_parent, d_inode(de),
               d_unhashed(de) ? "" : "hashed,",
               list_empty(&de->d_subdirs) ? "" : "subdirs");
 
@@ -167,8 +167,8 @@ static int ll_ddelete(const struct dentry *de)
 #if 0
        /* if not ldlm lock for this inode, set i_nlink to 0 so that
         * this inode can be recycled later b=20433 */
-       if (de->d_inode && !find_cbdata(de->d_inode))
-               clear_nlink(de->d_inode);
+       if (d_really_is_positive(de) && !find_cbdata(d_inode(de)))
+               clear_nlink(d_inode(de));
 #endif
 
        if (d_lustre_invalid((struct dentry *)de))
@@ -181,7 +181,7 @@ int ll_d_init(struct dentry *de)
        LASSERT(de != NULL);
 
        CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
-               de, de, de->d_parent, de->d_inode,
+               de, de, de->d_parent, d_inode(de),
                d_count(de));
 
        if (de->d_fsdata == NULL) {
@@ -261,7 +261,7 @@ void ll_invalidate_aliases(struct inode *inode)
        ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_u.d_alias) {
                CDEBUG(D_DENTRY, "dentry in drop %pd (%p) parent %p inode %p flags %d\n",
                       dentry, dentry, dentry->d_parent,
-                      dentry->d_inode, dentry->d_flags);
+                      d_inode(dentry), dentry->d_flags);
 
                d_lustre_invalidate(dentry, 0);
        }
@@ -309,7 +309,7 @@ void ll_lookup_finish_locks(struct lookup_intent *it, struct inode *inode)
 static int ll_revalidate_dentry(struct dentry *dentry,
                                unsigned int lookup_flags)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
 
        /*
         * if open&create is set, talk to MDS to make sure file is created if
@@ -329,7 +329,7 @@ static int ll_revalidate_dentry(struct dentry *dentry,
        if (lookup_flags & LOOKUP_RCU)
                return -ECHILD;
 
-       do_statahead_enter(dir, &dentry, dentry->d_inode == NULL);
+       do_statahead_enter(dir, &dentry, d_inode(dentry) == NULL);
        ll_statahead_mark(dir, dentry);
        return 1;
 }
index d73111ef949eee71f8e696b3e800be03f0e2dc1d..a6d43534871d1ee0d121c7a8cbf36448b10ad43d 100644 (file)
@@ -387,7 +387,7 @@ int ll_file_release(struct inode *inode, struct file *file)
 static int ll_intent_file_open(struct dentry *dentry, void *lmm,
                               int lmmsize, struct lookup_intent *itp)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ll_sb_info *sbi = ll_i2sbi(inode);
        struct dentry *parent = dentry->d_parent;
        const char *name = dentry->d_name.name;
@@ -412,7 +412,7 @@ static int ll_intent_file_open(struct dentry *dentry, void *lmm,
                        opc = LUSTRE_OPC_CREATE;
        }
 
-       op_data  = ll_prep_md_op_data(NULL, parent->d_inode,
+       op_data  = ll_prep_md_op_data(NULL, d_inode(parent),
                                      inode, name, len,
                                      O_RDWR, opc, NULL);
        if (IS_ERR(op_data))
@@ -2889,7 +2889,7 @@ static int ll_inode_revalidate_fini(struct inode *inode, int rc)
 
 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ptlrpc_request *req = NULL;
        struct obd_export *exp;
        int rc = 0;
@@ -2941,12 +2941,12 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
                   do_lookup() -> ll_revalidate_it(). We cannot use d_drop
                   here to preserve get_cwd functionality on 2.6.
                   Bug 10503 */
-               if (!dentry->d_inode->i_nlink)
+               if (!d_inode(dentry)->i_nlink)
                        d_lustre_invalidate(dentry, 0);
 
                ll_lookup_finish_locks(&oit, inode);
-       } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
-               struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
+       } else if (!ll_have_md_lock(d_inode(dentry), &ibits, LCK_MINMODE)) {
+               struct ll_sb_info *sbi = ll_i2sbi(d_inode(dentry));
                u64 valid = OBD_MD_FLGETATTR;
                struct md_op_data *op_data;
                int ealen = 0;
@@ -2984,7 +2984,7 @@ out:
 
 static int ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int rc;
 
        rc = __ll_inode_revalidate(dentry, ibits);
@@ -3012,7 +3012,7 @@ static int ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 
 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
 {
-       struct inode *inode = de->d_inode;
+       struct inode *inode = d_inode(de);
        struct ll_sb_info *sbi = ll_i2sbi(inode);
        struct ll_inode_info *lli = ll_i2info(inode);
        int res = 0;
index e7422f5c9c6f408deb97d93583a52fe30ebc20c9..5f918e3c4683ddac82c864d1d45f7c5700d20282 100644 (file)
@@ -1488,7 +1488,7 @@ static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
 {
        CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p refc %d\n",
               dentry, dentry,
-              dentry->d_parent, dentry->d_inode, d_count(dentry));
+              dentry->d_parent, d_inode(dentry), d_count(dentry));
 
        spin_lock_nested(&dentry->d_lock,
                         nested ? DENTRY_D_LOCK_NESTED : DENTRY_D_LOCK_NORMAL);
index 0c1b583a4ea1fe77fd5e694e2f35e312cf0ae271..f9132eddf51f18af018fad14148c0ea641fbbf2f 100644 (file)
@@ -1169,7 +1169,7 @@ static int ll_md_setattr(struct dentry *dentry, struct md_op_data *op_data,
                  struct md_open_data **mod)
 {
        struct lustre_md md;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ll_sb_info *sbi = ll_i2sbi(inode);
        struct ptlrpc_request *request = NULL;
        int rc, ia_valid;
@@ -1293,7 +1293,7 @@ static int ll_setattr_ost(struct inode *inode, struct iattr *attr)
  */
 int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ll_inode_info *lli = ll_i2info(inode);
        struct md_op_data *op_data = NULL;
        struct md_open_data *mod = NULL;
@@ -1467,7 +1467,7 @@ out:
 
 int ll_setattr(struct dentry *de, struct iattr *attr)
 {
-       int mode = de->d_inode->i_mode;
+       int mode = d_inode(de)->i_mode;
 
        if ((attr->ia_valid & (ATTR_CTIME|ATTR_SIZE|ATTR_MODE)) ==
                              (ATTR_CTIME|ATTR_SIZE|ATTR_MODE))
index 243a7840457f17457a32d86a039eacedcbceeaa1..db43b81386f7aedfdf634488d4b6634329dc67f1 100644 (file)
@@ -230,11 +230,11 @@ static int ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name,
 static int ll_get_name(struct dentry *dentry, char *name,
                       struct dentry *child)
 {
-       struct inode *dir = dentry->d_inode;
+       struct inode *dir = d_inode(dentry);
        int rc;
        struct ll_getname_data lgd = {
                .lgd_name = name,
-               .lgd_fid = ll_i2info(child->d_inode)->lli_fid,
+               .lgd_fid = ll_i2info(d_inode(child))->lli_fid,
                .ctx.actor = ll_nfs_get_name_filldir,
        };
 
@@ -282,7 +282,7 @@ static struct dentry *ll_fh_to_parent(struct super_block *sb, struct fid *fid,
 static struct dentry *ll_get_parent(struct dentry *dchild)
 {
        struct ptlrpc_request *req = NULL;
-       struct inode      *dir = dchild->d_inode;
+       struct inode      *dir = d_inode(dchild);
        struct ll_sb_info     *sbi;
        struct dentry    *result = NULL;
        struct mdt_body       *body;
index 890ac190f5faf3300ab8461f08cfe63182078c27..2ddb50c98acda977870a1ae69b335975adad39e7 100644 (file)
@@ -154,7 +154,7 @@ static void ll_invalidate_negative_children(struct inode *dir)
                        list_for_each_entry_safe(child, tmp_subdir,
                                                 &dentry->d_subdirs,
                                                 d_child) {
-                               if (child->d_inode == NULL)
+                               if (d_really_is_negative(child))
                                        d_lustre_invalidate(child, 1);
                        }
                }
@@ -391,7 +391,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de)
                        iput(inode);
                        CDEBUG(D_DENTRY,
                               "Reuse dentry %p inode %p refc %d flags %#x\n",
-                             new, new->d_inode, d_count(new), new->d_flags);
+                             new, d_inode(new), d_count(new), new->d_flags);
                        return new;
                }
        }
@@ -400,7 +400,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de)
                return ERR_PTR(rc);
        d_add(de, inode);
        CDEBUG(D_DENTRY, "Add dentry %p inode %p refc %d flags %#x\n",
-              de, de->d_inode, d_count(de), de->d_flags);
+              de, d_inode(de), d_count(de), de->d_flags);
        return de;
 }
 
@@ -447,7 +447,7 @@ static int ll_lookup_it_finish(struct ptlrpc_request *request,
                   !it_disposition(it, DISP_OPEN_CREATE)) {
                /* With DISP_OPEN_CREATE dentry will
                   instantiated in ll_create_it. */
-               LASSERT((*de)->d_inode == NULL);
+               LASSERT(d_inode(*de) == NULL);
                d_instantiate(*de, inode);
        }
 
@@ -540,7 +540,7 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
                goto out;
        }
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        if ((it->it_op & IT_OPEN) && inode &&
            !S_ISREG(inode->i_mode) &&
            !S_ISDIR(inode->i_mode)) {
@@ -636,9 +636,9 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
 
                        *opened |= FILE_CREATED;
                }
-               if (dentry->d_inode && it_disposition(it, DISP_OPEN_OPEN)) {
+               if (d_really_is_positive(dentry) && it_disposition(it, DISP_OPEN_OPEN)) {
                        /* Open dentry. */
-                       if (S_ISFIFO(dentry->d_inode->i_mode)) {
+                       if (S_ISFIFO(d_inode(dentry)->i_mode)) {
                                /* We cannot call open here as it would
                                 * deadlock.
                                 */
@@ -860,8 +860,8 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 
 static inline void ll_get_child_fid(struct dentry *child, struct lu_fid *fid)
 {
-       if (child->d_inode)
-               *fid = *ll_inode2fid(child->d_inode);
+       if (d_really_is_positive(child))
+               *fid = *ll_inode2fid(d_inode(child));
 }
 
 /**
@@ -1073,7 +1073,7 @@ static int ll_symlink(struct inode *dir, struct dentry *dentry,
 static int ll_link(struct dentry *old_dentry, struct inode *dir,
                   struct dentry *new_dentry)
 {
-       struct inode *src = old_dentry->d_inode;
+       struct inode *src = d_inode(old_dentry);
        struct ll_sb_info *sbi = ll_i2sbi(dir);
        struct ptlrpc_request *request = NULL;
        struct md_op_data *op_data;
index 6ad9dd0fe2b3d9d7da842e9af2d895a1097c42e6..5537254d469e02f018b8543c3e1030af6dbbfff5 100644 (file)
@@ -871,7 +871,7 @@ static int do_sa_lookup(struct inode *dir, struct ll_sa_entry *entry)
 static int do_sa_revalidate(struct inode *dir, struct ll_sa_entry *entry,
                            struct dentry *dentry)
 {
-       struct inode         *inode = dentry->d_inode;
+       struct inode         *inode = d_inode(dentry);
        struct lookup_intent      it = { .it_op = IT_GETATTR,
                                         .d.lustre.it_lock_handle = 0 };
        struct md_enqueue_info   *minfo;
@@ -917,7 +917,7 @@ static int do_sa_revalidate(struct inode *dir, struct ll_sa_entry *entry,
 static void ll_statahead_one(struct dentry *parent, const char *entry_name,
                             int entry_name_len)
 {
-       struct inode         *dir    = parent->d_inode;
+       struct inode         *dir    = d_inode(parent);
        struct ll_inode_info     *lli    = ll_i2info(dir);
        struct ll_statahead_info *sai    = lli->lli_sai;
        struct dentry       *dentry = NULL;
@@ -935,8 +935,8 @@ static void ll_statahead_one(struct dentry *parent, const char *entry_name,
                rc = do_sa_lookup(dir, entry);
        } else {
                rc = do_sa_revalidate(dir, entry, dentry);
-               if (rc == 1 && agl_should_run(sai, dentry->d_inode))
-                       ll_agl_add(sai, dentry->d_inode, entry->se_index);
+               if (rc == 1 && agl_should_run(sai, d_inode(dentry)))
+                       ll_agl_add(sai, d_inode(dentry), entry->se_index);
        }
 
        if (dentry != NULL)
@@ -959,7 +959,7 @@ static void ll_statahead_one(struct dentry *parent, const char *entry_name,
 static int ll_agl_thread(void *arg)
 {
        struct dentry       *parent = (struct dentry *)arg;
-       struct inode         *dir    = parent->d_inode;
+       struct inode         *dir    = d_inode(parent);
        struct ll_inode_info     *plli   = ll_i2info(dir);
        struct ll_inode_info     *clli;
        struct ll_sb_info       *sbi    = ll_i2sbi(dir);
@@ -1033,7 +1033,7 @@ static void ll_start_agl(struct dentry *parent, struct ll_statahead_info *sai)
        CDEBUG(D_READA, "start agl thread: sai %p, parent %pd\n",
               sai, parent);
 
-       plli = ll_i2info(parent->d_inode);
+       plli = ll_i2info(d_inode(parent));
        task = kthread_run(ll_agl_thread, parent,
                               "ll_agl_%u", plli->lli_opendir_pid);
        if (IS_ERR(task)) {
@@ -1050,7 +1050,7 @@ static void ll_start_agl(struct dentry *parent, struct ll_statahead_info *sai)
 static int ll_statahead_thread(void *arg)
 {
        struct dentry       *parent = (struct dentry *)arg;
-       struct inode         *dir    = parent->d_inode;
+       struct inode         *dir    = d_inode(parent);
        struct ll_inode_info     *plli   = ll_i2info(dir);
        struct ll_inode_info     *clli;
        struct ll_sb_info       *sbi    = ll_i2sbi(dir);
@@ -1595,7 +1595,7 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                        rc = md_revalidate_lock(ll_i2mdexp(dir), &it,
                                                ll_inode2fid(inode), &bits);
                        if (rc == 1) {
-                               if ((*dentryp)->d_inode == NULL) {
+                               if (d_inode(*dentryp) == NULL) {
                                        struct dentry *alias;
 
                                        alias = ll_splice_alias(inode,
@@ -1605,13 +1605,13 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                                                return PTR_ERR(alias);
                                        }
                                        *dentryp = alias;
-                               } else if ((*dentryp)->d_inode != inode) {
+                               } else if (d_inode(*dentryp) != inode) {
                                        /* revalidate, but inode is recreated */
                                        CDEBUG(D_READA,
                                              "stale dentry %pd inode %lu/%u, statahead inode %lu/%u\n",
                                              *dentryp,
-                                             (*dentryp)->d_inode->i_ino,
-                                             (*dentryp)->d_inode->i_generation,
+                                             d_inode(*dentryp)->i_ino,
+                                             d_inode(*dentryp)->i_generation,
                                              inode->i_ino,
                                              inode->i_generation);
                                        ll_sai_unplug(sai, entry);
@@ -1657,8 +1657,8 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
 
        /* get parent reference count here, and put it in ll_statahead_thread */
        parent = dget((*dentryp)->d_parent);
-       if (unlikely(sai->sai_inode != parent->d_inode)) {
-               struct ll_inode_info *nlli = ll_i2info(parent->d_inode);
+       if (unlikely(sai->sai_inode != d_inode(parent))) {
+               struct ll_inode_info *nlli = ll_i2info(d_inode(parent));
 
                CWARN("Race condition, someone changed %pd just now: old parent "DFID", new parent "DFID"\n",
                      *dentryp,
@@ -1680,7 +1680,7 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
        ll_sai_get(sai);
        lli->lli_sai = sai;
 
-       plli = ll_i2info(parent->d_inode);
+       plli = ll_i2info(d_inode(parent));
        rc = PTR_ERR(kthread_run(ll_statahead_thread, parent,
                                 "ll_sa_%u", plli->lli_opendir_pid));
        thread = &sai->sai_thread;
index 686b6a574cc585610641da696728a1acc12b746b..3711e671a4dfaa21af87d19857416f8f0f631734 100644 (file)
@@ -120,7 +120,7 @@ failed:
 
 static void *ll_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ptlrpc_request *request = NULL;
        int rc;
        char *symname = NULL;
index b439936b4524e5d8032f451cd6fd1a710bc400b4..e0fcbe1395fd31cfec2319f9a61768961a813be5 100644 (file)
@@ -214,7 +214,7 @@ int ll_setxattr_common(struct inode *inode, const char *name,
 int ll_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);
 
        LASSERT(inode);
        LASSERT(name);
@@ -267,7 +267,7 @@ int ll_setxattr(struct dentry *dentry, const char *name,
 
 int ll_removexattr(struct dentry *dentry, const char *name)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        LASSERT(inode);
        LASSERT(name);
@@ -457,7 +457,7 @@ out:
 ssize_t ll_getxattr(struct dentry *dentry, const char *name,
                    void *buffer, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        LASSERT(inode);
        LASSERT(name);
@@ -545,7 +545,7 @@ out:
 
 ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int rc = 0, rc2 = 0;
        struct lov_mds_md *lmm = NULL;
        struct ptlrpc_request *request = NULL;
index 8482f2d1160667ba1255ee5b48434287bc51da65..31c010372660154f6665782e89cea669b8457d29 100644 (file)
@@ -247,7 +247,7 @@ static int v9fs_xattr_get_acl(struct dentry *dentry, const char *name,
        if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
                return v9fs_remote_get_acl(dentry, name, buffer, size, type);
 
-       acl = v9fs_get_cached_acl(dentry->d_inode, type);
+       acl = v9fs_get_cached_acl(d_inode(dentry), type);
        if (IS_ERR(acl))
                return PTR_ERR(acl);
        if (acl == NULL)
@@ -285,7 +285,7 @@ static int v9fs_xattr_set_acl(struct dentry *dentry, const char *name,
        int retval;
        struct posix_acl *acl;
        struct v9fs_session_info *v9ses;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (strcmp(name, "") != 0)
                return -EINVAL;
index a345b2d659cc8ac638ddb8dbd2d39535e442ec4b..bd456c668d3997959220eaacd5aebf1b1da19309 100644 (file)
@@ -53,7 +53,7 @@ static int v9fs_cached_dentry_delete(const struct dentry *dentry)
                 dentry, dentry);
 
        /* Don't cache negative dentries */
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                return 1;
        return 0;
 }
@@ -83,7 +83,7 @@ static int v9fs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        if (!inode)
                goto out_valid;
 
index 3662f1d1d9cf0fc2f73c44fa4c34fb6e14c0af5f..703342e309f57af329085db6d8f0b1b4814793dd 100644 (file)
@@ -595,7 +595,7 @@ static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
                 dir, dentry, flags);
 
        v9ses = v9fs_inode2v9ses(dir);
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        dfid = v9fs_fid_lookup(dentry->d_parent);
        if (IS_ERR(dfid)) {
                retval = PTR_ERR(dfid);
@@ -864,7 +864,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
        }
 
        /* Only creates */
-       if (!(flags & O_CREAT) || dentry->d_inode)
+       if (!(flags & O_CREAT) || d_really_is_positive(dentry))
                return finish_no_open(file, res);
 
        err = 0;
@@ -881,7 +881,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
        }
 
        v9fs_invalidate_inode_attr(dir);
-       v9inode = V9FS_I(dentry->d_inode);
+       v9inode = V9FS_I(d_inode(dentry));
        mutex_lock(&v9inode->v_mutex);
        if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
            !v9inode->writeback_fid &&
@@ -908,7 +908,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
 
        file->private_data = fid;
        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
-               v9fs_cache_inode_set_cookie(dentry->d_inode, file);
+               v9fs_cache_inode_set_cookie(d_inode(dentry), file);
 
        *opened |= FILE_CREATED;
 out:
@@ -969,8 +969,8 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
        p9_debug(P9_DEBUG_VFS, "\n");
        retval = 0;
-       old_inode = old_dentry->d_inode;
-       new_inode = new_dentry->d_inode;
+       old_inode = d_inode(old_dentry);
+       new_inode = d_inode(new_dentry);
        v9ses = v9fs_inode2v9ses(old_inode);
        oldfid = v9fs_fid_lookup(old_dentry);
        if (IS_ERR(oldfid))
@@ -1061,7 +1061,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
        p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
        v9ses = v9fs_dentry2v9ses(dentry);
        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-               generic_fillattr(dentry->d_inode, stat);
+               generic_fillattr(d_inode(dentry), stat);
                return 0;
        }
        fid = v9fs_fid_lookup(dentry);
@@ -1072,8 +1072,8 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
        if (IS_ERR(st))
                return PTR_ERR(st);
 
-       v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
-       generic_fillattr(dentry->d_inode, stat);
+       v9fs_stat2inode(st, d_inode(dentry), d_inode(dentry)->i_sb);
+       generic_fillattr(d_inode(dentry), stat);
 
        p9stat_free(st);
        kfree(st);
@@ -1095,7 +1095,7 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
        struct p9_wstat wstat;
 
        p9_debug(P9_DEBUG_VFS, "\n");
-       retval = inode_change_ok(dentry->d_inode, iattr);
+       retval = inode_change_ok(d_inode(dentry), iattr);
        if (retval)
                return retval;
 
@@ -1128,20 +1128,20 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
 
        /* Write all dirty data */
        if (d_is_reg(dentry))
-               filemap_write_and_wait(dentry->d_inode->i_mapping);
+               filemap_write_and_wait(d_inode(dentry)->i_mapping);
 
        retval = p9_client_wstat(fid, &wstat);
        if (retval < 0)
                return retval;
 
        if ((iattr->ia_valid & ATTR_SIZE) &&
-           iattr->ia_size != i_size_read(dentry->d_inode))
-               truncate_setsize(dentry->d_inode, iattr->ia_size);
+           iattr->ia_size != i_size_read(d_inode(dentry)))
+               truncate_setsize(d_inode(dentry), iattr->ia_size);
 
-       v9fs_invalidate_inode_attr(dentry->d_inode);
+       v9fs_invalidate_inode_attr(d_inode(dentry));
 
-       setattr_copy(dentry->d_inode, iattr);
-       mark_inode_dirty(dentry->d_inode);
+       setattr_copy(d_inode(dentry), iattr);
+       mark_inode_dirty(d_inode(dentry));
        return 0;
 }
 
@@ -1403,7 +1403,7 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
        retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
        __putname(name);
        if (!retval) {
-               v9fs_refresh_inode(oldfid, old_dentry->d_inode);
+               v9fs_refresh_inode(oldfid, d_inode(old_dentry));
                v9fs_invalidate_inode_attr(dir);
        }
 clunk_fid:
index 6054c16b8faed41d0e80771a5a711f7c06a79fe8..9861c7c951a6dbd293e78d84e190f0908b4a1921 100644 (file)
@@ -265,7 +265,7 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
        }
 
        /* Only creates */
-       if (!(flags & O_CREAT) || dentry->d_inode)
+       if (!(flags & O_CREAT) || d_really_is_positive(dentry))
                return  finish_no_open(file, res);
 
        v9ses = v9fs_inode2v9ses(dir);
@@ -481,7 +481,7 @@ v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
        p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
        v9ses = v9fs_dentry2v9ses(dentry);
        if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-               generic_fillattr(dentry->d_inode, stat);
+               generic_fillattr(d_inode(dentry), stat);
                return 0;
        }
        fid = v9fs_fid_lookup(dentry);
@@ -496,8 +496,8 @@ v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
        if (IS_ERR(st))
                return PTR_ERR(st);
 
-       v9fs_stat2inode_dotl(st, dentry->d_inode);
-       generic_fillattr(dentry->d_inode, stat);
+       v9fs_stat2inode_dotl(st, d_inode(dentry));
+       generic_fillattr(d_inode(dentry), stat);
        /* Change block size to what the server returned */
        stat->blksize = st->st_blksize;
 
@@ -557,7 +557,7 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
        int retval;
        struct p9_fid *fid;
        struct p9_iattr_dotl p9attr;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        p9_debug(P9_DEBUG_VFS, "\n");
 
@@ -795,10 +795,10 @@ v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
                if (IS_ERR(fid))
                        return PTR_ERR(fid);
 
-               v9fs_refresh_inode_dotl(fid, old_dentry->d_inode);
+               v9fs_refresh_inode_dotl(fid, d_inode(old_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));
 
        return err;
 }
index 0afd0382822bca65bb87f10bffc1716f6944cefe..e99a338a46384128f32d6a32af8e549319f5121a 100644 (file)
@@ -168,8 +168,8 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                        retval = PTR_ERR(st);
                        goto release_sb;
                }
-               root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
-               v9fs_stat2inode_dotl(st, root->d_inode);
+               d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
+               v9fs_stat2inode_dotl(st, d_inode(root));
                kfree(st);
        } else {
                struct p9_wstat *st = NULL;
@@ -179,8 +179,8 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                        goto release_sb;
                }
 
-               root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
-               v9fs_stat2inode(st, root->d_inode, sb);
+               d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
+               v9fs_stat2inode(st, d_inode(root), sb);
 
                p9stat_free(st);
                kfree(st);
index b9acadafa4a10780d92c6d520008406fce4d5ddc..335055d828e45d082f24558ac5b1c155dac1fefb 100644 (file)
@@ -298,7 +298,7 @@ out:
 int
 adfs_notify_change(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = inode->i_sb;
        unsigned int ia_valid = attr->ia_valid;
        int error;
index 388da1ea815d07dd43af7a856293a4c3c840e400..40eb5814b98c06ec4633c2c964e4a69c67db4ba3 100644 (file)
@@ -138,7 +138,7 @@ affs_fix_dcache(struct inode *inode, u32 entry_ino)
 static int
 affs_remove_link(struct dentry *dentry)
 {
-       struct inode *dir, *inode = dentry->d_inode;
+       struct inode *dir, *inode = d_inode(dentry);
        struct super_block *sb = inode->i_sb;
        struct buffer_head *bh = NULL, *link_bh = NULL;
        u32 link_ino, ino;
@@ -268,11 +268,11 @@ affs_remove_header(struct dentry *dentry)
        struct buffer_head *bh = NULL;
        int retval;
 
-       dir = dentry->d_parent->d_inode;
+       dir = d_inode(dentry->d_parent);
        sb = dir->i_sb;
 
        retval = -ENOENT;
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        if (!inode)
                goto done;
 
@@ -471,7 +471,7 @@ affs_warning(struct super_block *sb, const char *function, const char *fmt, ...)
 bool
 affs_nofilenametruncate(const struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        return AFFS_SB(inode->i_sb)->s_flags & SF_NO_TRUNCATE;
 
 }
index 6f34510449e892b3afc807760d1108cba16d0dc2..57ed17137a13a493fda56fe78e176fc71c98b8eb 100644 (file)
@@ -212,7 +212,7 @@ affs_write_inode(struct inode *inode, struct writeback_control *wbc)
 int
 affs_notify_change(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
index ffb7bd82c2a5e8ffa84d08e49a6f8bbb086527ca..372100288ee5863d03fe2fcfbc5861c988cb811c 100644 (file)
@@ -250,7 +250,7 @@ int
 affs_unlink(struct inode *dir, struct dentry *dentry)
 {
        pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
-                dentry->d_inode->i_ino, dentry);
+                d_inode(dentry)->i_ino, dentry);
 
        return affs_remove_header(dentry);
 }
@@ -318,7 +318,7 @@ int
 affs_rmdir(struct inode *dir, struct dentry *dentry)
 {
        pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
-                dentry->d_inode->i_ino, dentry);
+                d_inode(dentry)->i_ino, dentry);
 
        return affs_remove_header(dentry);
 }
@@ -401,7 +401,7 @@ err:
 int
 affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
 
        pr_debug("%s(%lu, %lu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino,
                 dentry);
@@ -428,13 +428,13 @@ affs_rename(struct inode *old_dir, struct dentry *old_dentry,
                return retval;
 
        /* Unlink destination if it already exists */
-       if (new_dentry->d_inode) {
+       if (d_really_is_positive(new_dentry)) {
                retval = affs_remove_header(new_dentry);
                if (retval)
                        return retval;
        }
 
-       bh = affs_bread(sb, old_dentry->d_inode->i_ino);
+       bh = affs_bread(sb, d_inode(old_dentry)->i_ino);
        if (!bh)
                return -EIO;
 
index 4ec35e9130e1d7d2731ca381edbcc119b13da5a4..e10e17788f06073b2cd80204bf09343918654111 100644 (file)
@@ -505,7 +505,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
        _enter("{%x:%u},%p{%pd},",
               vnode->fid.vid, vnode->fid.vnode, dentry, dentry);
 
-       ASSERTCMP(dentry->d_inode, ==, NULL);
+       ASSERTCMP(d_inode(dentry), ==, NULL);
 
        if (dentry->d_name.len >= AFSNAMEMAX) {
                _leave(" = -ENAMETOOLONG");
@@ -563,8 +563,8 @@ success:
        _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",
               fid.vnode,
               fid.unique,
-              dentry->d_inode->i_ino,
-              dentry->d_inode->i_generation);
+              d_inode(dentry)->i_ino,
+              d_inode(dentry)->i_generation);
 
        return NULL;
 }
@@ -586,9 +586,9 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       vnode = AFS_FS_I(dentry->d_inode);
+       vnode = AFS_FS_I(d_inode(dentry));
 
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                _enter("{v={%x:%u} n=%pd fl=%lx},",
                       vnode->fid.vid, vnode->fid.vnode, dentry,
                       vnode->flags);
@@ -601,7 +601,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
 
        /* lock down the parent dentry so we can peer at it */
        parent = dget_parent(dentry);
-       dir = AFS_FS_I(parent->d_inode);
+       dir = AFS_FS_I(d_inode(parent));
 
        /* validate the parent directory */
        if (test_bit(AFS_VNODE_MODIFIED, &dir->flags))
@@ -623,9 +623,9 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
        switch (ret) {
        case 0:
                /* the filename maps to something */
-               if (!dentry->d_inode)
+               if (d_really_is_negative(dentry))
                        goto out_bad;
-               if (is_bad_inode(dentry->d_inode)) {
+               if (is_bad_inode(d_inode(dentry))) {
                        printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
                               dentry);
                        goto out_bad;
@@ -647,7 +647,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
                        _debug("%pd: file deleted (uq %u -> %u I:%u)",
                               dentry, fid.unique,
                               vnode->fid.unique,
-                              dentry->d_inode->i_generation);
+                              d_inode(dentry)->i_generation);
                        spin_lock(&vnode->lock);
                        set_bit(AFS_VNODE_DELETED, &vnode->flags);
                        spin_unlock(&vnode->lock);
@@ -658,7 +658,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
        case -ENOENT:
                /* the filename is unknown */
                _debug("%pd: dirent not found", dentry);
-               if (dentry->d_inode)
+               if (d_really_is_positive(dentry))
                        goto not_found;
                goto out_valid;
 
@@ -703,9 +703,9 @@ static int afs_d_delete(const struct dentry *dentry)
        if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
                goto zap;
 
-       if (dentry->d_inode &&
-           (test_bit(AFS_VNODE_DELETED,   &AFS_FS_I(dentry->d_inode)->flags) ||
-            test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(dentry->d_inode)->flags)))
+       if (d_really_is_positive(dentry) &&
+           (test_bit(AFS_VNODE_DELETED,   &AFS_FS_I(d_inode(dentry))->flags) ||
+            test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))
                goto zap;
 
        _leave(" = 0 [keep]");
@@ -814,8 +814,8 @@ static int afs_rmdir(struct inode *dir, struct dentry *dentry)
        if (ret < 0)
                goto rmdir_error;
 
-       if (dentry->d_inode) {
-               vnode = AFS_FS_I(dentry->d_inode);
+       if (d_really_is_positive(dentry)) {
+               vnode = AFS_FS_I(d_inode(dentry));
                clear_nlink(&vnode->vfs_inode);
                set_bit(AFS_VNODE_DELETED, &vnode->flags);
                afs_discard_callback_on_delete(vnode);
@@ -856,8 +856,8 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
                goto error;
        }
 
-       if (dentry->d_inode) {
-               vnode = AFS_FS_I(dentry->d_inode);
+       if (d_really_is_positive(dentry)) {
+               vnode = AFS_FS_I(d_inode(dentry));
 
                /* make sure we have a callback promise on the victim */
                ret = afs_validate(vnode, key);
@@ -869,7 +869,7 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
        if (ret < 0)
                goto remove_error;
 
-       if (dentry->d_inode) {
+       if (d_really_is_positive(dentry)) {
                /* if the file wasn't deleted due to excess hard links, the
                 * fileserver will break the callback promise on the file - if
                 * it had one - before it returns to us, and if it was deleted,
@@ -879,7 +879,7 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
                 * or it was outstanding on a different server, then it won't
                 * break it either...
                 */
-               vnode = AFS_FS_I(dentry->d_inode);
+               vnode = AFS_FS_I(d_inode(dentry));
                if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
                        _debug("AFS_VNODE_DELETED");
                if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags))
@@ -977,7 +977,7 @@ static int afs_link(struct dentry *from, struct inode *dir,
        struct key *key;
        int ret;
 
-       vnode = AFS_FS_I(from->d_inode);
+       vnode = AFS_FS_I(d_inode(from));
        dvnode = AFS_FS_I(dir);
 
        _enter("{%x:%u},{%x:%u},{%pd}",
@@ -1089,7 +1089,7 @@ static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct key *key;
        int ret;
 
-       vnode = AFS_FS_I(old_dentry->d_inode);
+       vnode = AFS_FS_I(d_inode(old_dentry));
        orig_dvnode = AFS_FS_I(old_dir);
        new_dvnode = AFS_FS_I(new_dir);
 
index 8a1d38ef0fc203678883493a672c0f638f94a107..e06f5a23352ac65415f8bcb54450af2620588e95 100644 (file)
@@ -379,7 +379,7 @@ int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 {
        struct inode *inode;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
 
@@ -458,7 +458,7 @@ void afs_evict_inode(struct inode *inode)
  */
 int afs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
+       struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
        struct key *key;
        int ret;
 
index 938c5ab06d5a2d875f22963a267b7e976ef5f339..ccd0b212e82a703b6ea1792339f7bf4603e5015f 100644 (file)
@@ -134,7 +134,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
 
        _enter("{%pd}", mntpt);
 
-       BUG_ON(!mntpt->d_inode);
+       BUG_ON(!d_inode(mntpt));
 
        ret = -ENOMEM;
        devname = (char *) get_zeroed_page(GFP_KERNEL);
@@ -145,7 +145,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
        if (!options)
                goto error_no_options;
 
-       vnode = AFS_FS_I(mntpt->d_inode);
+       vnode = AFS_FS_I(d_inode(mntpt));
        if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) {
                /* if the directory is a pseudo directory, use the d_name */
                static const char afs_root_cell[] = ":root.cell.";
@@ -169,14 +169,14 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
                }
        } else {
                /* read the contents of the AFS special symlink */
-               loff_t size = i_size_read(mntpt->d_inode);
+               loff_t size = i_size_read(d_inode(mntpt));
                char *buf;
 
                ret = -EINVAL;
                if (size > PAGE_SIZE - 1)
                        goto error_no_page;
 
-               page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL);
+               page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL);
                if (IS_ERR(page)) {
                        ret = PTR_ERR(page);
                        goto error_no_page;
index c4861557e38573796dd20237ff90938ee5f1429e..1fb4a5129f7dfc0007dfa52f287ca03766feeff0 100644 (file)
@@ -529,7 +529,7 @@ static void afs_destroy_inode(struct inode *inode)
 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct afs_volume_status vs;
-       struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
+       struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
        struct key *key;
        int ret;
 
index d10e619632ab48b30390062455eef4b543b7c183..5b700ef1e59db31c9d8d71e9386566eb1c488774 100644 (file)
@@ -235,12 +235,12 @@ static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
 
 static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
 {
-       return sbi->sb->s_root->d_inode->i_ino;
+       return d_inode(sbi->sb->s_root)->i_ino;
 }
 
 static inline int simple_positive(struct dentry *dentry)
 {
-       return dentry->d_inode && !d_unhashed(dentry);
+       return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 static inline void __autofs4_add_expiring(struct dentry *dentry)
index 11dd118f75e25e6a8f25f2143724901fb64c72a0..1cebc3c52fa5792242144c939908be50040b9e0b 100644 (file)
@@ -374,7 +374,7 @@ static struct dentry *should_expire(struct dentry *dentry,
                return NULL;
        }
 
-       if (dentry->d_inode && d_is_symlink(dentry)) {
+       if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
                DPRINTK("checking symlink %p %pd", dentry, dentry);
                /*
                 * A symlink can't be "busy" in the usual sense so
index 1c55388ae633c9908ab31934de070cbee08ae06f..a3ae0b2aeb5a0feeaeb43d5c3016bc13a0ca1d19 100644 (file)
@@ -71,7 +71,7 @@ void autofs4_kill_sb(struct super_block *sb)
 static int autofs4_show_options(struct seq_file *m, struct dentry *root)
 {
        struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
-       struct inode *root_inode = root->d_sb->s_root->d_inode;
+       struct inode *root_inode = d_inode(root->d_sb->s_root);
 
        if (!sbi)
                return 0;
@@ -352,8 +352,8 @@ struct inode *autofs4_get_inode(struct super_block *sb, umode_t mode)
 
        inode->i_mode = mode;
        if (sb->s_root) {
-               inode->i_uid = sb->s_root->d_inode->i_uid;
-               inode->i_gid = sb->s_root->d_inode->i_gid;
+               inode->i_uid = d_inode(sb->s_root)->i_uid;
+               inode->i_gid = d_inode(sb->s_root)->i_gid;
        }
        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
        inode->i_ino = get_next_ino();
index 7e44fdd03e2dd0a684036be49e7c2152c192ee63..c6d7d3dbd52abfa9af11ea0fb7aab955e355bbc9 100644 (file)
@@ -240,7 +240,7 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry,
                spin_lock(&expiring->d_lock);
 
                /* We've already been dentry_iput or unlinked */
-               if (!expiring->d_inode)
+               if (d_really_is_negative(expiring))
                        goto next;
 
                qstr = &expiring->d_name;
@@ -371,7 +371,7 @@ static struct vfsmount *autofs4_d_automount(struct path *path)
         * having d_mountpoint() true, so there's no need to call back
         * to the daemon.
         */
-       if (dentry->d_inode && d_is_symlink(dentry)) {
+       if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
                spin_unlock(&sbi->fs_lock);
                goto done;
        }
@@ -459,7 +459,7 @@ static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
                        return 0;
                if (d_mountpoint(dentry))
                        return 0;
-               inode = ACCESS_ONCE(dentry->d_inode);
+               inode = d_inode_rcu(dentry);
                if (inode && S_ISLNK(inode->i_mode))
                        return -EISDIR;
                if (list_empty(&dentry->d_subdirs))
@@ -485,7 +485,7 @@ static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
                 * an incorrect ELOOP error return.
                 */
                if ((!d_mountpoint(dentry) && !simple_empty(dentry)) ||
-                   (dentry->d_inode && d_is_symlink(dentry)))
+                   (d_really_is_positive(dentry) && d_is_symlink(dentry)))
                        status = -EISDIR;
        }
        spin_unlock(&sbi->fs_lock);
@@ -625,8 +625,8 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
        }
        dput(ino->dentry);
 
-       dentry->d_inode->i_size = 0;
-       clear_nlink(dentry->d_inode);
+       d_inode(dentry)->i_size = 0;
+       clear_nlink(d_inode(dentry));
 
        dir->i_mtime = CURRENT_TIME;
 
@@ -719,8 +719,8 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
                        atomic_dec(&p_ino->count);
        }
        dput(ino->dentry);
-       dentry->d_inode->i_size = 0;
-       clear_nlink(dentry->d_inode);
+       d_inode(dentry)->i_size = 0;
+       clear_nlink(d_inode(dentry));
 
        if (dir->i_nlink)
                drop_nlink(dir);
@@ -839,7 +839,7 @@ static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
 */
 int is_autofs4_dentry(struct dentry *dentry)
 {
-       return dentry && dentry->d_inode &&
+       return dentry && d_really_is_positive(dentry) &&
                dentry->d_op == &autofs4_dentry_operations &&
                dentry->d_fsdata != NULL;
 }
index 1e8ea192be2b13612e9702c4296f57611e50ba09..de58cc7b8076178605cea8f776031945d7d6da62 100644 (file)
@@ -18,7 +18,7 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
        struct autofs_info *ino = autofs4_dentry_ino(dentry);
        if (ino && !autofs4_oz_mode(sbi))
                ino->last_used = jiffies;
-       nd_set_link(nd, dentry->d_inode->i_private);
+       nd_set_link(nd, d_inode(dentry)->i_private);
        return NULL;
 }
 
index 2ad05ab93db86efe0e4d0432b7ed8f1f37a0dd52..35b755e79c2d9b311d0eb899dd749580cb42b209 100644 (file)
@@ -322,7 +322,7 @@ static int validate_request(struct autofs_wait_queue **wait,
                 * continue on and create a new request.
                 */
                if (!IS_ROOT(dentry)) {
-                       if (dentry->d_inode && d_unhashed(dentry)) {
+                       if (d_really_is_positive(dentry) && d_unhashed(dentry)) {
                                struct dentry *parent = dentry->d_parent;
                                new = d_lookup(parent, &dentry->d_name);
                                if (new)
@@ -364,7 +364,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
        if (pid == 0 || tgid == 0)
                return -ENOENT;
 
-       if (!dentry->d_inode) {
+       if (d_really_is_negative(dentry)) {
                /*
                 * A wait for a negative dentry is invalid for certain
                 * cases. A direct or offset mount "always" has its mount
index e089f1985fcaa35e4e213669776e0f3190fc0db8..d3cb8774765f392f0710d3ba7122fe518f6c0e74 100644 (file)
@@ -472,7 +472,7 @@ static void *
 befs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
        struct super_block *sb = dentry->d_sb;
-       befs_inode_info *befs_ino = BEFS_I(dentry->d_inode);
+       befs_inode_info *befs_ino = BEFS_I(d_inode(dentry));
        befs_data_stream *data = &befs_ino->i_data.ds;
        befs_off_t len = data->size;
        char *link;
@@ -502,7 +502,7 @@ befs_follow_link(struct dentry *dentry, struct nameidata *nd)
 static void *
 befs_fast_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       befs_inode_info *befs_ino = BEFS_I(dentry->d_inode);
+       befs_inode_info *befs_ino = BEFS_I(d_inode(dentry));
        nd_set_link(nd, befs_ino->i_data.symlink);
        return NULL;
 }
index 08063ae0a17cd631b0c3194ea68043045f7cce05..7efed2ad7eeaac707625d84cb6273957a7df7f42 100644 (file)
@@ -153,7 +153,7 @@ static struct dentry *bfs_lookup(struct inode *dir, struct dentry *dentry,
 static int bfs_link(struct dentry *old, struct inode *dir,
                                                struct dentry *new)
 {
-       struct inode *inode = old->d_inode;
+       struct inode *inode = d_inode(old);
        struct bfs_sb_info *info = BFS_SB(inode->i_sb);
        int err;
 
@@ -176,7 +176,7 @@ static int bfs_link(struct dentry *old, struct inode *dir,
 static int bfs_unlink(struct inode *dir, struct dentry *dentry)
 {
        int error = -ENOENT;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct buffer_head *bh;
        struct bfs_dirent *de;
        struct bfs_sb_info *info = BFS_SB(inode->i_sb);
@@ -216,7 +216,7 @@ static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        int error = -ENOENT;
 
        old_bh = new_bh = NULL;
-       old_inode = old_dentry->d_inode;
+       old_inode = d_inode(old_dentry);
        if (S_ISDIR(old_inode->i_mode))
                return -EINVAL;
 
@@ -231,7 +231,7 @@ static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                goto end_rename;
 
        error = -EPERM;
-       new_inode = new_dentry->d_inode;
+       new_inode = d_inode(new_dentry);
        new_bh = bfs_find_entry(new_dir, 
                                new_dentry->d_name.name, 
                                new_dentry->d_name.len, &new_de);
index 37d164540c3a25c469d831899e05f9cc5eccb9d1..8d052209f473be1d0959b6e65bded71b92c05584 100644 (file)
@@ -152,7 +152,7 @@ static struct dentry *btrfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
 
 static struct dentry *btrfs_get_parent(struct dentry *child)
 {
-       struct inode *dir = child->d_inode;
+       struct inode *dir = d_inode(child);
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct btrfs_path *path;
        struct extent_buffer *leaf;
@@ -220,8 +220,8 @@ fail:
 static int btrfs_get_name(struct dentry *parent, char *name,
                          struct dentry *child)
 {
-       struct inode *inode = child->d_inode;
-       struct inode *dir = parent->d_inode;
+       struct inode *inode = d_inode(child);
+       struct inode *dir = d_inode(parent);
        struct btrfs_path *path;
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct btrfs_inode_ref *iref;
index faa7d390841b9a245a95ffb4944d515c3c486cbf..2e57064c3cdf160f446916d09da39daae81028ab 100644 (file)
@@ -1864,7 +1864,7 @@ static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 {
        struct dentry *dentry = file->f_path.dentry;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_trans_handle *trans;
        struct btrfs_log_ctx ctx;
index 43192e10cc4331f9f533c61f10f21c602bdee806..811576346a92f48508e8538a9e7256c9a6fef635 100644 (file)
@@ -4016,16 +4016,16 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct btrfs_trans_handle *trans;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int ret;
 
        trans = __unlink_start_trans(dir);
        if (IS_ERR(trans))
                return PTR_ERR(trans);
 
-       btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
+       btrfs_record_unlink_dir(trans, dir, d_inode(dentry), 0);
 
-       ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
+       ret = btrfs_unlink_inode(trans, root, dir, d_inode(dentry),
                                 dentry->d_name.name, dentry->d_name.len);
        if (ret)
                goto out;
@@ -4124,7 +4124,7 @@ out:
 
 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int err = 0;
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct btrfs_trans_handle *trans;
@@ -4151,7 +4151,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
                goto out;
 
        /* now the directory is empty */
-       err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
+       err = btrfs_unlink_inode(trans, root, dir, d_inode(dentry),
                                 dentry->d_name.name, dentry->d_name.len);
        if (!err)
                btrfs_i_size_write(inode, 0);
@@ -4826,7 +4826,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
 
 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct btrfs_root *root = BTRFS_I(inode)->root;
        int err;
 
@@ -5416,10 +5416,10 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
 static int btrfs_dentry_delete(const struct dentry *dentry)
 {
        struct btrfs_root *root;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (!inode && !IS_ROOT(dentry))
-               inode = dentry->d_parent->d_inode;
+               inode = d_inode(dentry->d_parent);
 
        if (inode) {
                root = BTRFS_I(inode)->root;
@@ -6226,7 +6226,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
 {
        struct btrfs_trans_handle *trans;
        struct btrfs_root *root = BTRFS_I(dir)->root;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        u64 index;
        int err;
        int drop_inode = 0;
@@ -8875,7 +8875,7 @@ static int btrfs_getattr(struct vfsmount *mnt,
                         struct dentry *dentry, struct kstat *stat)
 {
        u64 delalloc_bytes;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        u32 blocksize = inode->i_sb->s_blocksize;
 
        generic_fillattr(inode, stat);
@@ -8896,8 +8896,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct btrfs_trans_handle *trans;
        struct btrfs_root *root = BTRFS_I(old_dir)->root;
        struct btrfs_root *dest = BTRFS_I(new_dir)->root;
-       struct inode *new_inode = new_dentry->d_inode;
-       struct inode *old_inode = old_dentry->d_inode;
+       struct inode *new_inode = d_inode(new_dentry);
+       struct inode *old_inode = d_inode(old_dentry);
        struct timespec ctime = CURRENT_TIME;
        u64 index = 0;
        u64 root_objectid;
@@ -9009,7 +9009,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                        old_dentry->d_name.len);
        } else {
                ret = __btrfs_unlink_inode(trans, root, old_dir,
-                                       old_dentry->d_inode,
+                                       d_inode(old_dentry),
                                        old_dentry->d_name.name,
                                        old_dentry->d_name.len);
                if (!ret)
@@ -9033,12 +9033,12 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        BUG_ON(new_inode->i_nlink == 0);
                } else {
                        ret = btrfs_unlink_inode(trans, dest, new_dir,
-                                                new_dentry->d_inode,
+                                                d_inode(new_dentry),
                                                 new_dentry->d_name.name,
                                                 new_dentry->d_name.len);
                }
                if (!ret && new_inode->i_nlink == 0)
-                       ret = btrfs_orphan_add(trans, new_dentry->d_inode);
+                       ret = btrfs_orphan_add(trans, d_inode(new_dentry));
                if (ret) {
                        btrfs_abort_transaction(trans, root, ret);
                        goto out_fail;
index 74609b931ba5564da01de0955b8aa1d3142512d7..20957ed47ce22b148c48410bead824de915b79fe 100644 (file)
@@ -717,7 +717,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
        if (ret)
                goto fail;
 
-       inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
+       inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry);
        if (IS_ERR(inode)) {
                ret = PTR_ERR(inode);
                goto fail;
@@ -761,10 +761,10 @@ static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
 {
        int error;
 
-       if (!victim->d_inode)
+       if (d_really_is_negative(victim))
                return -ENOENT;
 
-       BUG_ON(victim->d_parent->d_inode != dir);
+       BUG_ON(d_inode(victim->d_parent) != dir);
        audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
 
        error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
@@ -772,8 +772,8 @@ static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
                return error;
        if (IS_APPEND(dir))
                return -EPERM;
-       if (check_sticky(dir, victim->d_inode) || IS_APPEND(victim->d_inode) ||
-           IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
+       if (check_sticky(dir, d_inode(victim)) || IS_APPEND(d_inode(victim)) ||
+           IS_IMMUTABLE(d_inode(victim)) || IS_SWAPFILE(d_inode(victim)))
                return -EPERM;
        if (isdir) {
                if (!d_is_dir(victim))
@@ -792,7 +792,7 @@ static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
 /* copy of may_create in fs/namei.c() */
 static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
 {
-       if (child->d_inode)
+       if (d_really_is_positive(child))
                return -EEXIST;
        if (IS_DEADDIR(dir))
                return -ENOENT;
@@ -810,7 +810,7 @@ static noinline int btrfs_mksubvol(struct path *parent,
                                   u64 *async_transid, bool readonly,
                                   struct btrfs_qgroup_inherit *inherit)
 {
-       struct inode *dir  = parent->dentry->d_inode;
+       struct inode *dir  = d_inode(parent->dentry);
        struct dentry *dentry;
        int error;
 
@@ -824,7 +824,7 @@ static noinline int btrfs_mksubvol(struct path *parent,
                goto out_unlock;
 
        error = -EEXIST;
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                goto out_dput;
 
        error = btrfs_may_create(dir, dentry);
@@ -2294,7 +2294,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
 {
        struct dentry *parent = file->f_path.dentry;
        struct dentry *dentry;
-       struct inode *dir = parent->d_inode;
+       struct inode *dir = d_inode(parent);
        struct inode *inode;
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct btrfs_root *dest = NULL;
@@ -2333,12 +2333,12 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                goto out_unlock_dir;
        }
 
-       if (!dentry->d_inode) {
+       if (d_really_is_negative(dentry)) {
                err = -ENOENT;
                goto out_dput;
        }
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        dest = BTRFS_I(inode)->root;
        if (!capable(CAP_SYS_ADMIN)) {
                /*
index 05fef198ff94fc8df4eb126a62195af8452fb18d..68ee619fff4528c32066a96599e04849594c72ef 100644 (file)
@@ -916,7 +916,7 @@ setup_root:
         * a reference to the dentry.  We will have already gotten a reference
         * to the inode in btrfs_fill_super so we're good to go.
         */
-       if (!new && sb->s_root->d_inode == inode) {
+       if (!new && d_inode(sb->s_root) == inode) {
                iput(inode);
                return dget(sb->s_root);
        }
@@ -1221,7 +1221,7 @@ static struct dentry *mount_subvol(const char *subvol_name, int flags,
 
        root = mount_subtree(mnt, subvol_name);
 
-       if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
+       if (!IS_ERR(root) && !is_subvolume_inode(d_inode(root))) {
                struct super_block *s = root->d_sb;
                dput(root);
                root = ERR_PTR(-EINVAL);
@@ -1886,8 +1886,8 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
        buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
        /* Mask in the root object ID too, to disambiguate subvols */
-       buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
-       buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
+       buf->f_fsid.val[0] ^= BTRFS_I(d_inode(dentry))->root->objectid >> 32;
+       buf->f_fsid.val[1] ^= BTRFS_I(d_inode(dentry))->root->objectid;
 
        return 0;
 }
index c5b8ba37f88e31fa188258af9c6e13036c2df18f..25db71be462a12dc9649430f6c9b9dd9f0051d4f 100644 (file)
@@ -4327,9 +4327,9 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                        goto out;
 
        if (!S_ISDIR(inode->i_mode)) {
-               if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
+               if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
                        goto out;
-               inode = parent->d_inode;
+               inode = d_inode(parent);
        }
 
        while (1) {
@@ -4355,7 +4355,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                        break;
                }
 
-               if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
+               if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
                        break;
 
                if (IS_ROOT(parent))
@@ -4364,7 +4364,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                parent = dget_parent(parent);
                dput(old_parent);
                old_parent = parent;
-               inode = parent->d_inode;
+               inode = d_inode(parent);
 
        }
        dput(old_parent);
@@ -4450,10 +4450,10 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
        }
 
        while (1) {
-               if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
+               if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
                        break;
 
-               inode = parent->d_inode;
+               inode = d_inode(parent);
                if (root != BTRFS_I(inode)->root)
                        break;
 
@@ -4515,7 +4515,7 @@ int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
        struct dentry *parent = dget_parent(dentry);
        int ret;
 
-       ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent,
+       ret = btrfs_log_inode_parent(trans, root, d_inode(dentry), parent,
                                     start, end, 0, ctx);
        dput(parent);
 
index 883b93623bc5682ecde2684bfe936bb98fd9e51d..4cca14ecb660b1dda0c34f040c008f9d019cb738 100644 (file)
@@ -261,7 +261,7 @@ out:
 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
        struct btrfs_key key, found_key;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_path *path;
        struct extent_buffer *leaf;
@@ -390,13 +390,13 @@ ssize_t btrfs_getxattr(struct dentry *dentry, const char *name,
 
        if (!btrfs_is_valid_xattr(name))
                return -EOPNOTSUPP;
-       return __btrfs_getxattr(dentry->d_inode, name, buffer, size);
+       return __btrfs_getxattr(d_inode(dentry), name, buffer, size);
 }
 
 int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                   size_t size, int flags)
 {
-       struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root;
+       struct btrfs_root *root = BTRFS_I(d_inode(dentry))->root;
 
        /*
         * The permission on security.* and system.* is not checked
@@ -417,19 +417,19 @@ int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                return -EOPNOTSUPP;
 
        if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
-               return btrfs_set_prop(dentry->d_inode, name,
+               return btrfs_set_prop(d_inode(dentry), name,
                                      value, size, flags);
 
        if (size == 0)
                value = "";  /* empty EA, do not remove */
 
-       return __btrfs_setxattr(NULL, dentry->d_inode, name, value, size,
+       return __btrfs_setxattr(NULL, d_inode(dentry), name, value, size,
                                flags);
 }
 
 int btrfs_removexattr(struct dentry *dentry, const char *name)
 {
-       struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root;
+       struct btrfs_root *root = BTRFS_I(d_inode(dentry))->root;
 
        /*
         * The permission on security.* and system.* is not checked
@@ -450,10 +450,10 @@ int btrfs_removexattr(struct dentry *dentry, const char *name)
                return -EOPNOTSUPP;
 
        if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
-               return btrfs_set_prop(dentry->d_inode, name,
+               return btrfs_set_prop(d_inode(dentry), name,
                                      NULL, 0, XATTR_REPLACE);
 
-       return __btrfs_setxattr(NULL, dentry->d_inode, name, NULL, 0,
+       return __btrfs_setxattr(NULL, d_inode(dentry), name, NULL, 0,
                                XATTR_REPLACE);
 }
 
index 8172775428a0b9165e68d293d23812a3f2be1593..283cf69c6904b980b0ca3492dc041361863f6c1d 100644 (file)
@@ -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;
index 1b2355109b9fd13faa3141ecc1cd75bbe28881c1..31f831471ed287e470bc38fc8632b19d6aed61d2 100644 (file)
@@ -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);
index 83e9976f718983ccfb5d95c56893e81c7d01caa9..173fc598c7f1f63b824a24cc0eb462f643ea420c 100644 (file)
@@ -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));
 }
 
 /*
index 8d7d782f43822d2fd29b1f6fe941093ff7e247d3..fe02ae7f056a332220929ce653e822a0a39e2605 100644 (file)
@@ -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);
index b9b8eb225f66ead124f4a1484cfc5b76dbb8d2fb..3b6b522b4b31ed9e2f7193c661894787bfe63627 100644 (file)
@@ -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);
index 119c43c80638788f648272fbd1593e6e6bdbfd94..e876e1944519a330a2cc1f44e33a031139a35438 100644 (file)
@@ -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;
 
index 71c073f38e547522c81fa335fcae85c5d8c7ef58..a39389092102ce2052f72f3a59781ae9ec4f8e35 100644 (file)
@@ -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);
 
index a63997b8bcff8ac6d5967361700d79f1b6e35c3f..e68591df99424e322df6eaed5c5dc257cce48853 100644 (file)
@@ -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:
index 5a492caf34cbbdbede390a00ecf534fdc7826a62..e448766ce54990c99ea92a0b7e542ab36a42f041 100644 (file)
@@ -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))
index b8602f19981560bc51fe9123689d75eed24f8e0c..430e0348c99ebb9b86c65ccd957a1b5e69ed6a2a 100644 (file)
@@ -301,7 +301,7 @@ static struct vfsmount *cifs_dfs_do_automount(struct dentry *mntpt)
        if (full_path == NULL)
                goto cdda_exit;
 
-       cifs_sb = CIFS_SB(mntpt->d_inode->i_sb);
+       cifs_sb = CIFS_SB(d_inode(mntpt)->i_sb);
        tlink = cifs_sb_tlink(cifs_sb);
        if (IS_ERR(tlink)) {
                mnt = ERR_CAST(tlink);
index eaab4b2a05953225ea92075c95dd2e0174d3d75b..f5089bde363576dcab6a35887f3c539a8a7e6247 100644 (file)
@@ -607,7 +607,7 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
        p = s = full_path;
 
        do {
-               struct inode *dir = dentry->d_inode;
+               struct inode *dir = d_inode(dentry);
                struct dentry *child;
 
                if (!dir) {
index fa13d5e79f643afb4fcfdb92333a68786e5dff32..84650a51c7c4064357eab083868cc613a75f7f18 100644 (file)
@@ -1898,7 +1898,7 @@ static void
 cifs_writev_requeue(struct cifs_writedata *wdata)
 {
        int i, rc = 0;
-       struct inode *inode = wdata->cfile->dentry->d_inode;
+       struct inode *inode = d_inode(wdata->cfile->dentry);
        struct TCP_Server_Info *server;
        unsigned int rest_len;
 
@@ -1981,7 +1981,7 @@ cifs_writev_complete(struct work_struct *work)
 {
        struct cifs_writedata *wdata = container_of(work,
                                                struct cifs_writedata, work);
-       struct inode *inode = wdata->cfile->dentry->d_inode;
+       struct inode *inode = d_inode(wdata->cfile->dentry);
        int i = 0;
 
        if (wdata->result == 0) {
index b72bc29cba23e7f29b4acfc5f1309150f0711aaf..338d56936f6af694b7085284a38e7b751ba7eb66 100644 (file)
@@ -745,13 +745,13 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
                goto lookup_out;
        }
 
-       if (direntry->d_inode != NULL) {
+       if (d_really_is_positive(direntry)) {
                cifs_dbg(FYI, "non-NULL inode in lookup\n");
        } else {
                cifs_dbg(FYI, "NULL inode in lookup\n");
        }
        cifs_dbg(FYI, "Full path: %s inode = 0x%p\n",
-                full_path, direntry->d_inode);
+                full_path, d_inode(direntry));
 
        if (pTcon->unix_ext) {
                rc = cifs_get_inode_info_unix(&newInode, full_path,
@@ -792,7 +792,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       if (direntry->d_inode) {
+       if (d_really_is_positive(direntry)) {
                if (cifs_revalidate_dentry(direntry))
                        return 0;
                else {
@@ -803,7 +803,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
                         * attributes will have been updated by
                         * cifs_revalidate_dentry().
                         */
-                       if (IS_AUTOMOUNT(direntry->d_inode) &&
+                       if (IS_AUTOMOUNT(d_inode(direntry)) &&
                           !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
                                spin_lock(&direntry->d_lock);
                                direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
index ca2bc5406306e57fb0d9620ffeec3488ed7d4414..cafbf10521d5017074196e02ad37218939d0ab70 100644 (file)
@@ -273,7 +273,7 @@ cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
                  struct tcon_link *tlink, __u32 oplock)
 {
        struct dentry *dentry = file->f_path.dentry;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct cifsInodeInfo *cinode = CIFS_I(inode);
        struct cifsFileInfo *cfile;
        struct cifs_fid_locks *fdlocks;
@@ -357,7 +357,7 @@ cifsFileInfo_get(struct cifsFileInfo *cifs_file)
  */
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 {
-       struct inode *inode = cifs_file->dentry->d_inode;
+       struct inode *inode = d_inode(cifs_file->dentry);
        struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
        struct TCP_Server_Info *server = tcon->ses->server;
        struct cifsInodeInfo *cifsi = CIFS_I(inode);
@@ -386,7 +386,7 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 
        if (list_empty(&cifsi->openFileList)) {
                cifs_dbg(FYI, "closing last open instance for inode %p\n",
-                        cifs_file->dentry->d_inode);
+                        d_inode(cifs_file->dentry));
                /*
                 * In strict cache mode we need invalidate mapping on the last
                 * close  because it may cause a error when we open this file
@@ -572,7 +572,7 @@ static int
 cifs_relock_file(struct cifsFileInfo *cfile)
 {
        struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
        int rc = 0;
 
@@ -620,7 +620,7 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
                return rc;
        }
 
-       inode = cfile->dentry->d_inode;
+       inode = d_inode(cfile->dentry);
        cifs_sb = CIFS_SB(inode->i_sb);
        tcon = tlink_tcon(cfile->tlink);
        server = tcon->ses->server;
@@ -874,7 +874,7 @@ cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 {
        bool rc = false;
        struct cifs_fid_locks *cur;
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 
        list_for_each_entry(cur, &cinode->llist, llist) {
                rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
@@ -899,7 +899,7 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 {
        int rc = 0;
        struct cifsLockInfo *conf_lock;
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
        bool exist;
 
@@ -927,7 +927,7 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 static void
 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
 {
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        down_write(&cinode->lock_sem);
        list_add_tail(&lock->llist, &cfile->llist->locks);
        up_write(&cinode->lock_sem);
@@ -944,7 +944,7 @@ cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
                 bool wait)
 {
        struct cifsLockInfo *conf_lock;
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        bool exist;
        int rc = 0;
 
@@ -1125,7 +1125,7 @@ struct lock_to_push {
 static int
 cifs_push_posix_locks(struct cifsFileInfo *cfile)
 {
-       struct inode *inode = cfile->dentry->d_inode;
+       struct inode *inode = d_inode(cfile->dentry);
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
        struct file_lock *flock;
        struct file_lock_context *flctx = inode->i_flctx;
@@ -1214,7 +1214,7 @@ static int
 cifs_push_locks(struct cifsFileInfo *cfile)
 {
        struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
        int rc = 0;
 
@@ -1382,7 +1382,7 @@ cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
        unsigned int max_num, num, max_buf;
        LOCKING_ANDX_RANGE *buf, *cur;
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct cifsLockInfo *li, *tmp;
        __u64 length = 1 + flock->fl_end - flock->fl_start;
        struct list_head tmp_llist;
@@ -1488,7 +1488,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
        struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
        struct TCP_Server_Info *server = tcon->ses->server;
-       struct inode *inode = cfile->dentry->d_inode;
+       struct inode *inode = d_inode(cfile->dentry);
 
        if (posix_lck) {
                int posix_lock_type;
@@ -1643,7 +1643,7 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
        struct TCP_Server_Info *server;
        unsigned int xid;
        struct dentry *dentry = open_file->dentry;
-       struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
+       struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
        struct cifs_io_parms io_parms;
 
        cifs_sb = CIFS_SB(dentry->d_sb);
@@ -1676,7 +1676,7 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
                                        break;
                        }
 
-                       len = min(server->ops->wp_retry_size(dentry->d_inode),
+                       len = min(server->ops->wp_retry_size(d_inode(dentry)),
                                  (unsigned int)write_size - total_written);
                        /* iov[0] is reserved for smb header */
                        iov[1].iov_base = (char *)write_data + total_written;
@@ -1696,9 +1696,9 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
                                return rc;
                        }
                } else {
-                       spin_lock(&dentry->d_inode->i_lock);
+                       spin_lock(&d_inode(dentry)->i_lock);
                        cifs_update_eof(cifsi, *offset, bytes_written);
-                       spin_unlock(&dentry->d_inode->i_lock);
+                       spin_unlock(&d_inode(dentry)->i_lock);
                        *offset += bytes_written;
                }
        }
@@ -1706,12 +1706,12 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
        cifs_stats_bytes_written(tcon, total_written);
 
        if (total_written > 0) {
-               spin_lock(&dentry->d_inode->i_lock);
-               if (*offset > dentry->d_inode->i_size)
-                       i_size_write(dentry->d_inode, *offset);
-               spin_unlock(&dentry->d_inode->i_lock);
+               spin_lock(&d_inode(dentry)->i_lock);
+               if (*offset > d_inode(dentry)->i_size)
+                       i_size_write(d_inode(dentry), *offset);
+               spin_unlock(&d_inode(dentry)->i_lock);
        }
-       mark_inode_dirty_sync(dentry->d_inode);
+       mark_inode_dirty_sync(d_inode(dentry));
        free_xid(xid);
        return total_written;
 }
@@ -2406,7 +2406,7 @@ cifs_uncached_writev_complete(struct work_struct *work)
 {
        struct cifs_writedata *wdata = container_of(work,
                                        struct cifs_writedata, work);
-       struct inode *inode = wdata->cfile->dentry->d_inode;
+       struct inode *inode = d_inode(wdata->cfile->dentry);
        struct cifsInodeInfo *cifsi = CIFS_I(inode);
 
        spin_lock(&inode->i_lock);
@@ -3794,7 +3794,7 @@ void cifs_oplock_break(struct work_struct *work)
 {
        struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
                                                  oplock_break);
-       struct inode *inode = cfile->dentry->d_inode;
+       struct inode *inode = d_inode(cfile->dentry);
        struct cifsInodeInfo *cinode = CIFS_I(inode);
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
        struct TCP_Server_Info *server = tcon->ses->server;
index 3e126d7bb2ea5bec97c9d6e02973a49886261580..55b58112d122248b92305ea00eb66c6715a40b03 100644 (file)
@@ -1067,7 +1067,7 @@ cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
        int rc;
        struct cifs_fid fid;
        struct cifs_open_parms oparms;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
        struct tcon_link *tlink;
@@ -1196,7 +1196,7 @@ cifs_drop_nlink(struct inode *inode)
 }
 
 /*
- * If dentry->d_inode is null (usually meaning the cached dentry
+ * If d_inode(dentry) is null (usually meaning the cached dentry
  * is a negative dentry) then we would attempt a standard SMB delete, but
  * if that fails we can not attempt the fall back mechanisms on EACCESS
  * but will return the EACCESS to the caller. Note that the VFS does not call
@@ -1207,7 +1207,7 @@ int cifs_unlink(struct inode *dir, struct dentry *dentry)
        int rc = 0;
        unsigned int xid;
        char *full_path = NULL;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct cifsInodeInfo *cifs_inode;
        struct super_block *sb = dir->i_sb;
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
@@ -1551,13 +1551,13 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
        cifs_put_tlink(tlink);
 
        if (!rc) {
-               spin_lock(&direntry->d_inode->i_lock);
-               i_size_write(direntry->d_inode, 0);
-               clear_nlink(direntry->d_inode);
-               spin_unlock(&direntry->d_inode->i_lock);
+               spin_lock(&d_inode(direntry)->i_lock);
+               i_size_write(d_inode(direntry), 0);
+               clear_nlink(d_inode(direntry));
+               spin_unlock(&d_inode(direntry)->i_lock);
        }
 
-       cifsInode = CIFS_I(direntry->d_inode);
+       cifsInode = CIFS_I(d_inode(direntry));
        /* force revalidate to go get info when needed */
        cifsInode->time = 0;
 
@@ -1568,7 +1568,7 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
         */
        cifsInode->time = 0;
 
-       direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
+       d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
                current_fs_time(inode->i_sb);
 
 rmdir_exit:
@@ -1727,7 +1727,7 @@ cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
 
 unlink_target:
        /* Try unlinking the target dentry if it's not negative */
-       if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
+       if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
                if (d_is_dir(target_dentry))
                        tmprc = cifs_rmdir(target_dir, target_dentry);
                else
@@ -1867,7 +1867,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
 {
        unsigned int xid;
        int rc = 0;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = dentry->d_sb;
        char *full_path = NULL;
 
@@ -1919,7 +1919,7 @@ int cifs_revalidate_file(struct file *filp)
 int cifs_revalidate_dentry(struct dentry *dentry)
 {
        int rc;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        rc = cifs_revalidate_dentry_attr(dentry);
        if (rc)
@@ -1933,7 +1933,7 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 {
        struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int rc;
 
        /*
@@ -2110,7 +2110,7 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
        int rc;
        unsigned int xid;
        char *full_path = NULL;
-       struct inode *inode = direntry->d_inode;
+       struct inode *inode = d_inode(direntry);
        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
        struct tcon_link *tlink;
@@ -2251,7 +2251,7 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
        unsigned int xid;
        kuid_t uid = INVALID_UID;
        kgid_t gid = INVALID_GID;
-       struct inode *inode = direntry->d_inode;
+       struct inode *inode = d_inode(direntry);
        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
        struct cifsInodeInfo *cifsInode = CIFS_I(inode);
        char *full_path = NULL;
@@ -2409,7 +2409,7 @@ cifs_setattr_exit:
 int
 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
 {
-       struct inode *inode = direntry->d_inode;
+       struct inode *inode = d_inode(direntry);
        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
        struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
 
index 2ec6037f61c758e11f7e1238e0e3c17c9a65af12..252e672d56043468fb8f906ce371acef27d74db0 100644 (file)
@@ -586,12 +586,12 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
         * if source file is cached (oplocked) revalidate will not go to server
         * until the file is closed or oplock broken so update nlinks locally
         */
-       if (old_file->d_inode) {
-               cifsInode = CIFS_I(old_file->d_inode);
+       if (d_really_is_positive(old_file)) {
+               cifsInode = CIFS_I(d_inode(old_file));
                if (rc == 0) {
-                       spin_lock(&old_file->d_inode->i_lock);
-                       inc_nlink(old_file->d_inode);
-                       spin_unlock(&old_file->d_inode->i_lock);
+                       spin_lock(&d_inode(old_file)->i_lock);
+                       inc_nlink(d_inode(old_file));
+                       spin_unlock(&d_inode(old_file)->i_lock);
 
                        /*
                         * parent dir timestamps will update from srv within a
@@ -629,7 +629,7 @@ cifs_hl_exit:
 void *
 cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 {
-       struct inode *inode = direntry->d_inode;
+       struct inode *inode = d_inode(direntry);
        int rc = -ENOMEM;
        unsigned int xid;
        char *full_path = NULL;
index 337946355b29db5c71632f66a354295311e9f3e3..8442b8b8e0be145e7f68055e0025f1909442d156 100644 (file)
@@ -473,7 +473,7 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
                                        continue;
 
                                cifs_dbg(FYI, "file id match, oplock break\n");
-                               pCifsInode = CIFS_I(netfile->dentry->d_inode);
+                               pCifsInode = CIFS_I(d_inode(netfile->dentry));
 
                                set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK,
                                        &pCifsInode->flags);
index c295338e0a98ce95a71c60afedc87ad9bd5267b5..b4a47237486b883851e889e78505bd1179c7842d 100644 (file)
@@ -78,7 +78,7 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
 {
        struct dentry *dentry, *alias;
        struct inode *inode;
-       struct super_block *sb = parent->d_inode->i_sb;
+       struct super_block *sb = d_inode(parent)->i_sb;
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 
        cifs_dbg(FYI, "%s: for %s\n", __func__, name->name);
@@ -88,7 +88,7 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
                return;
 
        if (dentry) {
-               inode = dentry->d_inode;
+               inode = d_inode(dentry);
                if (inode) {
                        /*
                         * If we're generating inode numbers, then we don't
index d2979036a4c72756e91f9fa6c454337585c06800..7bfdd6066276256fc03855cd809f63c167d3991b 100644 (file)
@@ -722,7 +722,7 @@ cifs_open_file(const unsigned int xid, struct cifs_open_parms *oparms,
 static void
 cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
 {
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        cfile->fid.netfid = fid->netfid;
        cifs_set_oplock_level(cinode, oplock);
        cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
index 7198eac5dddd2ab5746a8d7778f7fdfd5e9bd5bb..2ab297dae5a7b2b4e544e3f35abc5f09b9fa7b1d 100644 (file)
@@ -95,7 +95,7 @@ smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
        unsigned int max_num, num = 0, max_buf;
        struct smb2_lock_element *buf, *cur;
        struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct cifsLockInfo *li, *tmp;
        __u64 length = 1 + flock->fl_end - flock->fl_start;
        struct list_head tmp_llist;
@@ -231,7 +231,7 @@ smb2_push_mandatory_locks(struct cifsFileInfo *cfile)
        unsigned int xid;
        unsigned int max_num, max_buf;
        struct smb2_lock_element *buf;
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct cifs_fid_locks *fdlocks;
 
        xid = get_xid();
index 22dfdf17d06547f3d1b3abbc302bb03abf1b047b..1c5907019045517ac302daf4c04e8caea21f1fda 100644 (file)
@@ -453,7 +453,7 @@ smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp,
 
        list_for_each(tmp, &tcon->openFileList) {
                cfile = list_entry(tmp, struct cifsFileInfo, tlist);
-               cinode = CIFS_I(cfile->dentry->d_inode);
+               cinode = CIFS_I(d_inode(cfile->dentry));
 
                if (memcmp(cinode->lease_key, rsp->LeaseKey,
                                                        SMB2_LEASE_KEY_SIZE))
@@ -590,7 +590,7 @@ smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server)
                                        continue;
 
                                cifs_dbg(FYI, "file id match, oplock break\n");
-                               cinode = CIFS_I(cfile->dentry->d_inode);
+                               cinode = CIFS_I(d_inode(cfile->dentry));
 
                                if (!CIFS_CACHE_WRITE(cinode) &&
                                    rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE)
index eab05e1aa587424863d6914eb351da9fdcf17437..54daee5ad4c102b71b3617317a58d15375f4e755 100644 (file)
@@ -524,7 +524,7 @@ smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
 static void
 smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
 {
-       struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+       struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
        struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 
        cfile->fid.persistent_fid = fid->persistent_fid;
@@ -793,7 +793,7 @@ smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
         * If extending file more than one page make sparse. Many Linux fs
         * make files sparse by default when extending via ftruncate
         */
-       inode = cfile->dentry->d_inode;
+       inode = d_inode(cfile->dentry);
 
        if (!set_alloc && (size > inode->i_size + 8192)) {
                __u8 set_sparse = 1;
@@ -1032,7 +1032,7 @@ static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon,
 
        xid = get_xid();
 
-       inode = cfile->dentry->d_inode;
+       inode = d_inode(cfile->dentry);
        cifsi = CIFS_I(inode);
 
        /* if file not oplocked can't be sure whether asking to extend size */
@@ -1083,7 +1083,7 @@ static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon,
 
        xid = get_xid();
 
-       inode = cfile->dentry->d_inode;
+       inode = d_inode(cfile->dentry);
        cifsi = CIFS_I(inode);
 
        /* Need to make file sparse, if not already, before freeing range. */
@@ -1115,7 +1115,7 @@ static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
 
        xid = get_xid();
 
-       inode = cfile->dentry->d_inode;
+       inode = d_inode(cfile->dentry);
        cifsi = CIFS_I(inode);
 
        /* if file not oplocked can't be sure whether asking to extend size */
index 72a4d10653d6e746919bae66d9fe46316cdaa812..ff9e1f8b16a4872158c05f688a9761a9a7a8781d 100644 (file)
@@ -50,9 +50,9 @@ int cifs_removexattr(struct dentry *direntry, const char *ea_name)
 
        if (direntry == NULL)
                return -EIO;
-       if (direntry->d_inode == NULL)
+       if (d_really_is_negative(direntry))
                return -EIO;
-       sb = direntry->d_inode->i_sb;
+       sb = d_inode(direntry)->i_sb;
        if (sb == NULL)
                return -EIO;
 
@@ -111,9 +111,9 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
 
        if (direntry == NULL)
                return -EIO;
-       if (direntry->d_inode == NULL)
+       if (d_really_is_negative(direntry))
                return -EIO;
-       sb = direntry->d_inode->i_sb;
+       sb = d_inode(direntry)->i_sb;
        if (sb == NULL)
                return -EIO;
 
@@ -177,12 +177,12 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
                        memcpy(pacl, ea_value, value_size);
                        if (pTcon->ses->server->ops->set_acl)
                                rc = pTcon->ses->server->ops->set_acl(pacl,
-                                               value_size, direntry->d_inode,
+                                               value_size, d_inode(direntry),
                                                full_path, CIFS_ACL_DACL);
                        else
                                rc = -EOPNOTSUPP;
                        if (rc == 0) /* force revalidate of the inode */
-                               CIFS_I(direntry->d_inode)->time = 0;
+                               CIFS_I(d_inode(direntry))->time = 0;
                        kfree(pacl);
                }
 #else
@@ -246,9 +246,9 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 
        if (direntry == NULL)
                return -EIO;
-       if (direntry->d_inode == NULL)
+       if (d_really_is_negative(direntry))
                return -EIO;
-       sb = direntry->d_inode->i_sb;
+       sb = d_inode(direntry)->i_sb;
        if (sb == NULL)
                return -EIO;
 
@@ -324,7 +324,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                                goto get_ea_exit; /* rc already EOPNOTSUPP */
 
                        pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
-                                       direntry->d_inode, full_path, &acllen);
+                                       d_inode(direntry), full_path, &acllen);
                        if (IS_ERR(pacl)) {
                                rc = PTR_ERR(pacl);
                                cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
@@ -382,9 +382,9 @@ ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 
        if (direntry == NULL)
                return -EIO;
-       if (direntry->d_inode == NULL)
+       if (d_really_is_negative(direntry))
                return -EIO;
-       sb = direntry->d_inode->i_sb;
+       sb = d_inode(direntry)->i_sb;
        if (sb == NULL)
                return -EIO;
 
index 46ee6f238985a86186493cd22a245f4baa7638e0..5bb630a769e044942fcfa3e5910ffd841141ee47 100644 (file)
@@ -94,8 +94,8 @@ static void coda_flag_children(struct dentry *parent, int flag)
        spin_lock(&parent->d_lock);
        list_for_each_entry(de, &parent->d_subdirs, d_child) {
                /* don't know what to do with negative dentries */
-               if (de->d_inode ) 
-                       coda_flag_inode(de->d_inode, flag);
+               if (d_inode(de) ) 
+                       coda_flag_inode(d_inode(de), flag);
        }
        spin_unlock(&parent->d_lock);
        return; 
index 60cb88c1dd2bf88bb12f3e5451e33ed51d5ac1ff..fda9f4311212fe4a6d3b884d43dfdb7b5ff51e7e 100644 (file)
@@ -201,7 +201,7 @@ err_out:
 static int coda_link(struct dentry *source_de, struct inode *dir_inode, 
          struct dentry *de)
 {
-       struct inode *inode = source_de->d_inode;
+       struct inode *inode = d_inode(source_de);
         const char * name = de->d_name.name;
        int len = de->d_name.len;
        int error;
@@ -266,7 +266,7 @@ static int coda_unlink(struct inode *dir, struct dentry *de)
                return error;
 
        coda_dir_update_mtime(dir);
-       drop_nlink(de->d_inode);
+       drop_nlink(d_inode(de));
        return 0;
 }
 
@@ -279,8 +279,8 @@ static int coda_rmdir(struct inode *dir, struct dentry *de)
        error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
        if (!error) {
                /* VFS may delete the child */
-               if (de->d_inode)
-                       clear_nlink(de->d_inode);
+               if (d_really_is_positive(de))
+                       clear_nlink(d_inode(de));
 
                /* fix the link count of the parent */
                coda_dir_drop_nlink(dir);
@@ -303,14 +303,14 @@ static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
                             coda_i2f(new_dir), old_length, new_length,
                             (const char *) old_name, (const char *)new_name);
        if (!error) {
-               if (new_dentry->d_inode) {
+               if (d_really_is_positive(new_dentry)) {
                        if (d_is_dir(new_dentry)) {
                                coda_dir_drop_nlink(old_dir);
                                coda_dir_inc_nlink(new_dir);
                        }
                        coda_dir_update_mtime(old_dir);
                        coda_dir_update_mtime(new_dir);
-                       coda_flag_inode(new_dentry->d_inode, C_VATTR);
+                       coda_flag_inode(d_inode(new_dentry), C_VATTR);
                } else {
                        coda_flag_inode(old_dir, C_VATTR);
                        coda_flag_inode(new_dir, C_VATTR);
@@ -449,13 +449,13 @@ static int coda_dentry_revalidate(struct dentry *de, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       inode = de->d_inode;
+       inode = d_inode(de);
        if (!inode || is_root_inode(inode))
                goto out;
        if (is_bad_inode(inode))
                goto bad;
 
-       cii = ITOC(de->d_inode);
+       cii = ITOC(d_inode(de));
        if (!(cii->c_flags & (C_PURGE | C_FLUSH)))
                goto out;
 
@@ -487,11 +487,11 @@ static int coda_dentry_delete(const struct dentry * dentry)
 {
        int flags;
 
-       if (!dentry->d_inode
+       if (d_really_is_negative(dentry)
                return 0;
 
-       flags = (ITOC(dentry->d_inode)->c_flags) & C_PURGE;
-       if (is_bad_inode(dentry->d_inode) || flags) {
+       flags = (ITOC(d_inode(dentry))->c_flags) & C_PURGE;
+       if (is_bad_inode(d_inode(dentry)) || flags) {
                return 1;
        }
        return 0;
index 82ec68b59208282f49ece9fb06e0fdb5135c3749..cac1390b87a35a92b7089aaa574f683369088da7 100644 (file)
@@ -257,15 +257,15 @@ static void coda_evict_inode(struct inode *inode)
 
 int coda_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       int err = coda_revalidate_inode(dentry->d_inode);
+       int err = coda_revalidate_inode(d_inode(dentry));
        if (!err)
-               generic_fillattr(dentry->d_inode, stat);
+               generic_fillattr(d_inode(dentry), stat);
        return err;
 }
 
 int coda_setattr(struct dentry *de, struct iattr *iattr)
 {
-       struct inode *inode = de->d_inode;
+       struct inode *inode = d_inode(de);
        struct coda_vattr vattr;
        int error;
 
index 4326d172fc27fb697d5c94baf110f68b721401d4..f36a4040afb8019ee689bc3058957af1c75b758a 100644 (file)
@@ -72,7 +72,7 @@ static long coda_pioctl(struct file *filp, unsigned int cmd,
        if (error)
                return error;
 
-       target_inode = path.dentry->d_inode;
+       target_inode = d_inode(path.dentry);
 
        /* return if it is not a Coda inode */
        if (target_inode->i_sb != inode->i_sb) {
index 5bb6e27298a469d3a20bf3e54ef37e79d3435f76..9b1ffaa0572e5825d8c617880bfbc19be166313b 100644 (file)
@@ -820,8 +820,8 @@ int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out)
        case CODA_FLUSH:
                coda_cache_clear_all(sb);
                shrink_dcache_sb(sb);
-               if (sb->s_root->d_inode)
-                       coda_flag_inode(sb->s_root->d_inode, C_FLUSH);
+               if (d_really_is_positive(sb->s_root))
+                       coda_flag_inode(d_inode(sb->s_root), C_FLUSH);
                break;
 
        case CODA_PURGEUSER:
index acb3d63bc9dc763cf8e3518cfe66a233ee9ee63f..c81ce7f200a6d9944b4670de2729f909048e773c 100644 (file)
@@ -289,7 +289,7 @@ static int configfs_create_dir(struct config_item *item, struct dentry *dentry)
        configfs_set_dir_dirent_depth(p->d_fsdata, dentry->d_fsdata);
        error = configfs_create(dentry, mode, init_dir);
        if (!error) {
-               inc_nlink(p->d_inode);
+               inc_nlink(d_inode(p));
                item->ci_dentry = dentry;
        } else {
                struct configfs_dirent *sd = dentry->d_fsdata;
@@ -375,8 +375,8 @@ static void remove_dir(struct dentry * d)
        list_del_init(&sd->s_sibling);
        spin_unlock(&configfs_dirent_lock);
        configfs_put(sd);
-       if (d->d_inode)
-               simple_rmdir(parent->d_inode,d);
+       if (d_really_is_positive(d))
+               simple_rmdir(d_inode(parent),d);
 
        pr_debug(" o %pd removing done (%d)\n", d, d_count(d));
 
@@ -513,7 +513,7 @@ static int configfs_detach_prep(struct dentry *dentry, struct mutex **wait_mutex
                        /* Abort if racing with mkdir() */
                        if (sd->s_type & CONFIGFS_USET_IN_MKDIR) {
                                if (wait_mutex)
-                                       *wait_mutex = &sd->s_dentry->d_inode->i_mutex;
+                                       *wait_mutex = &d_inode(sd->s_dentry)->i_mutex;
                                return -EAGAIN;
                        }
 
@@ -624,13 +624,13 @@ static void detach_groups(struct config_group *group)
 
                child = sd->s_dentry;
 
-               mutex_lock(&child->d_inode->i_mutex);
+               mutex_lock(&d_inode(child)->i_mutex);
 
                configfs_detach_group(sd->s_element);
-               child->d_inode->i_flags |= S_DEAD;
+               d_inode(child)->i_flags |= S_DEAD;
                dont_mount(child);
 
-               mutex_unlock(&child->d_inode->i_mutex);
+               mutex_unlock(&d_inode(child)->i_mutex);
 
                d_delete(child);
                dput(child);
@@ -672,7 +672,7 @@ static int create_default_group(struct config_group *parent_group,
                        sd = child->d_fsdata;
                        sd->s_type |= CONFIGFS_USET_DEFAULT;
                } else {
-                       BUG_ON(child->d_inode);
+                       BUG_ON(d_inode(child));
                        d_drop(child);
                        dput(child);
                }
@@ -818,11 +818,11 @@ static int configfs_attach_item(struct config_item *parent_item,
                         * the VFS may already have hit and used them. Thus,
                         * we must lock them as rmdir() would.
                         */
-                       mutex_lock(&dentry->d_inode->i_mutex);
+                       mutex_lock(&d_inode(dentry)->i_mutex);
                        configfs_remove_dir(item);
-                       dentry->d_inode->i_flags |= S_DEAD;
+                       d_inode(dentry)->i_flags |= S_DEAD;
                        dont_mount(dentry);
-                       mutex_unlock(&dentry->d_inode->i_mutex);
+                       mutex_unlock(&d_inode(dentry)->i_mutex);
                        d_delete(dentry);
                }
        }
@@ -858,16 +858,16 @@ static int configfs_attach_group(struct config_item *parent_item,
                 * We must also lock the inode to remove it safely in case of
                 * error, as rmdir() would.
                 */
-               mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+               mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
                configfs_adjust_dir_dirent_depth_before_populate(sd);
                ret = populate_groups(to_config_group(item));
                if (ret) {
                        configfs_detach_item(item);
-                       dentry->d_inode->i_flags |= S_DEAD;
+                       d_inode(dentry)->i_flags |= S_DEAD;
                        dont_mount(dentry);
                }
                configfs_adjust_dir_dirent_depth_after_populate(sd);
-               mutex_unlock(&dentry->d_inode->i_mutex);
+               mutex_unlock(&d_inode(dentry)->i_mutex);
                if (ret)
                        d_delete(dentry);
        }
@@ -1075,7 +1075,7 @@ int configfs_depend_item(struct configfs_subsystem *subsys,
         * subsystem is really registered, and so we need to lock out
         * configfs_[un]register_subsystem().
         */
-       mutex_lock(&root->d_inode->i_mutex);
+       mutex_lock(&d_inode(root)->i_mutex);
 
        root_sd = root->d_fsdata;
 
@@ -1111,7 +1111,7 @@ int configfs_depend_item(struct configfs_subsystem *subsys,
 out_unlock_dirent_lock:
        spin_unlock(&configfs_dirent_lock);
 out_unlock_fs:
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
 
        /*
         * If we succeeded, the fs is pinned via other methods.  If not,
@@ -1453,11 +1453,11 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
        down_write(&configfs_rename_sem);
        parent = item->parent->dentry;
 
-       mutex_lock(&parent->d_inode->i_mutex);
+       mutex_lock(&d_inode(parent)->i_mutex);
 
        new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
        if (!IS_ERR(new_dentry)) {
-               if (!new_dentry->d_inode) {
+               if (d_really_is_negative(new_dentry)) {
                        error = config_item_set_name(item, "%s", new_name);
                        if (!error) {
                                d_add(new_dentry, NULL);
@@ -1469,7 +1469,7 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
                        error = -EEXIST;
                dput(new_dentry);
        }
-       mutex_unlock(&parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(parent)->i_mutex);
        up_write(&configfs_rename_sem);
 
        return error;
@@ -1482,7 +1482,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
        struct configfs_dirent * parent_sd = dentry->d_fsdata;
        int err;
 
-       mutex_lock(&dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(dentry)->i_mutex);
        /*
         * Fake invisibility if dir belongs to a group/default groups hierarchy
         * being attached
@@ -1495,7 +1495,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
                else
                        err = 0;
        }
-       mutex_unlock(&dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry)->i_mutex);
 
        return err;
 }
@@ -1505,11 +1505,11 @@ static int configfs_dir_close(struct inode *inode, struct file *file)
        struct dentry * dentry = file->f_path.dentry;
        struct configfs_dirent * cursor = file->private_data;
 
-       mutex_lock(&dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(dentry)->i_mutex);
        spin_lock(&configfs_dirent_lock);
        list_del_init(&cursor->s_sibling);
        spin_unlock(&configfs_dirent_lock);
-       mutex_unlock(&dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry)->i_mutex);
 
        release_configfs_dirent(cursor);
 
@@ -1567,7 +1567,7 @@ static int configfs_readdir(struct file *file, struct dir_context *ctx)
                spin_lock(&configfs_dirent_lock);
                dentry = next->s_dentry;
                if (dentry)
-                       inode = dentry->d_inode;
+                       inode = d_inode(dentry);
                if (inode)
                        ino = inode->i_ino;
                spin_unlock(&configfs_dirent_lock);
@@ -1590,7 +1590,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
 {
        struct dentry * dentry = file->f_path.dentry;
 
-       mutex_lock(&dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(dentry)->i_mutex);
        switch (whence) {
                case 1:
                        offset += file->f_pos;
@@ -1598,7 +1598,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                        if (offset >= 0)
                                break;
                default:
-                       mutex_unlock(&dentry->d_inode->i_mutex);
+                       mutex_unlock(&d_inode(dentry)->i_mutex);
                        return -EINVAL;
        }
        if (offset != file->f_pos) {
@@ -1624,7 +1624,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                        spin_unlock(&configfs_dirent_lock);
                }
        }
-       mutex_unlock(&dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry)->i_mutex);
        return offset;
 }
 
@@ -1654,7 +1654,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
        sd = root->d_fsdata;
        link_group(to_config_group(sd->s_element), group);
 
-       mutex_lock_nested(&root->d_inode->i_mutex, I_MUTEX_PARENT);
+       mutex_lock_nested(&d_inode(root)->i_mutex, I_MUTEX_PARENT);
 
        err = -ENOMEM;
        dentry = d_alloc_name(root, group->cg_item.ci_name);
@@ -1664,7 +1664,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
                err = configfs_attach_group(sd->s_element, &group->cg_item,
                                            dentry);
                if (err) {
-                       BUG_ON(dentry->d_inode);
+                       BUG_ON(d_inode(dentry));
                        d_drop(dentry);
                        dput(dentry);
                } else {
@@ -1674,7 +1674,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
                }
        }
 
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
 
        if (err) {
                unlink_group(group);
@@ -1695,9 +1695,9 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
                return;
        }
 
-       mutex_lock_nested(&root->d_inode->i_mutex,
+       mutex_lock_nested(&d_inode(root)->i_mutex,
                          I_MUTEX_PARENT);
-       mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+       mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
        mutex_lock(&configfs_symlink_mutex);
        spin_lock(&configfs_dirent_lock);
        if (configfs_detach_prep(dentry, NULL)) {
@@ -1706,13 +1706,13 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
        spin_unlock(&configfs_dirent_lock);
        mutex_unlock(&configfs_symlink_mutex);
        configfs_detach_group(&group->cg_item);
-       dentry->d_inode->i_flags |= S_DEAD;
+       d_inode(dentry)->i_flags |= S_DEAD;
        dont_mount(dentry);
-       mutex_unlock(&dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry)->i_mutex);
 
        d_delete(dentry);
 
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
 
        dput(dentry);
 
index 56d2cdc9ae0a7213f91bb5e332b1513fda887b79..403269ffcdf3518b45f878166270c12e3365c17e 100644 (file)
@@ -326,10 +326,10 @@ int configfs_create_file(struct config_item * item, const struct configfs_attrib
        umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
        int error = 0;
 
-       mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_NORMAL);
+       mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_NORMAL);
        error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode,
                                     CONFIGFS_ITEM_ATTR);
-       mutex_unlock(&dir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dir)->i_mutex);
 
        return error;
 }
index 5423a6a6ecc8350c0284d307ac47cf6afad9238a..8d89f5fd0331c6a8b0ff9648251199248995aa50 100644 (file)
@@ -56,7 +56,7 @@ static const struct inode_operations configfs_inode_operations ={
 
 int configfs_setattr(struct dentry * dentry, struct iattr * iattr)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        struct configfs_dirent * sd = dentry->d_fsdata;
        struct iattr * sd_iattr;
        unsigned int ia_valid = iattr->ia_valid;
@@ -186,7 +186,7 @@ int configfs_create(struct dentry * dentry, umode_t mode, void (*init)(struct in
        if (!dentry)
                return -ENOENT;
 
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                return -EEXIST;
 
        sd = dentry->d_fsdata;
@@ -194,7 +194,7 @@ int configfs_create(struct dentry * dentry, umode_t mode, void (*init)(struct in
        if (!inode)
                return -ENOMEM;
 
-       p_inode = dentry->d_parent->d_inode;
+       p_inode = d_inode(dentry->d_parent);
        p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
        configfs_set_inode_lock_class(sd, inode);
 
@@ -236,11 +236,11 @@ void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent)
 
        if (dentry) {
                spin_lock(&dentry->d_lock);
-               if (!d_unhashed(dentry) && dentry->d_inode) {
+               if (!d_unhashed(dentry) && d_really_is_positive(dentry)) {
                        dget_dlock(dentry);
                        __d_drop(dentry);
                        spin_unlock(&dentry->d_lock);
-                       simple_unlink(parent->d_inode, dentry);
+                       simple_unlink(d_inode(parent), dentry);
                } else
                        spin_unlock(&dentry->d_lock);
        }
@@ -251,11 +251,11 @@ void configfs_hash_and_remove(struct dentry * dir, const char * name)
        struct configfs_dirent * sd;
        struct configfs_dirent * parent_sd = dir->d_fsdata;
 
-       if (dir->d_inode == NULL)
+       if (d_really_is_negative(dir))
                /* no inode means this hasn't been made visible yet */
                return;
 
-       mutex_lock(&dir->d_inode->i_mutex);
+       mutex_lock(&d_inode(dir)->i_mutex);
        list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
                if (!sd->s_element)
                        continue;
@@ -268,5 +268,5 @@ void configfs_hash_and_remove(struct dentry * dir, const char * name)
                        break;
                }
        }
-       mutex_unlock(&dir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dir)->i_mutex);
 }
index 517e6493843824f716b721845075b28d8e7d229d..830a7e76f5c64067e46fad8fd368e9112ddae7a9 100644 (file)
@@ -45,7 +45,7 @@ const struct file_operations debugfs_file_operations = {
 
 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       nd_set_link(nd, dentry->d_inode->i_private);
+       nd_set_link(nd, d_inode(dentry)->i_private);
        return NULL;
 }
 
index 26856ecdea5ea2bc58cf966a41ed5b508cb1a64b..61dfe45fdb6837dab7f5359544385810819b5d9f 100644 (file)
@@ -46,7 +46,7 @@ static struct inode *debugfs_get_inode(struct super_block *sb)
 
 static inline int debugfs_positive(struct dentry *dentry)
 {
-       return dentry->d_inode && !d_unhashed(dentry);
+       return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 struct debugfs_mount_opts {
@@ -124,7 +124,7 @@ static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
 static int debugfs_apply_options(struct super_block *sb)
 {
        struct debugfs_fs_info *fsi = sb->s_fs_info;
-       struct inode *inode = sb->s_root->d_inode;
+       struct inode *inode = d_inode(sb->s_root);
        struct debugfs_mount_opts *opts = &fsi->mount_opts;
 
        inode->i_mode &= ~S_IALLUGO;
@@ -188,7 +188,7 @@ static struct vfsmount *debugfs_automount(struct path *path)
 {
        struct vfsmount *(*f)(void *);
        f = (struct vfsmount *(*)(void *))path->dentry->d_fsdata;
-       return f(path->dentry->d_inode->i_private);
+       return f(d_inode(path->dentry)->i_private);
 }
 
 static const struct dentry_operations debugfs_dops = {
@@ -267,20 +267,20 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
        if (!parent)
                parent = debugfs_mount->mnt_root;
 
-       mutex_lock(&parent->d_inode->i_mutex);
+       mutex_lock(&d_inode(parent)->i_mutex);
        dentry = lookup_one_len(name, parent, strlen(name));
-       if (!IS_ERR(dentry) && dentry->d_inode) {
+       if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
                dput(dentry);
                dentry = ERR_PTR(-EEXIST);
        }
        if (IS_ERR(dentry))
-               mutex_unlock(&parent->d_inode->i_mutex);
+               mutex_unlock(&d_inode(parent)->i_mutex);
        return dentry;
 }
 
 static struct dentry *failed_creating(struct dentry *dentry)
 {
-       mutex_unlock(&dentry->d_parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
        dput(dentry);
        simple_release_fs(&debugfs_mount, &debugfs_mount_count);
        return NULL;
@@ -288,7 +288,7 @@ static struct dentry *failed_creating(struct dentry *dentry)
 
 static struct dentry *end_creating(struct dentry *dentry)
 {
-       mutex_unlock(&dentry->d_parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
        return dentry;
 }
 
@@ -341,7 +341,7 @@ struct dentry *debugfs_create_file(const char *name, umode_t mode,
        inode->i_fop = fops ? fops : &debugfs_file_operations;
        inode->i_private = data;
        d_instantiate(dentry, inode);
-       fsnotify_create(dentry->d_parent->d_inode, dentry);
+       fsnotify_create(d_inode(dentry->d_parent), dentry);
        return end_creating(dentry);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_file);
@@ -381,7 +381,7 @@ struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
        struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
 
        if (de)
-               de->d_inode->i_size = file_size;
+               d_inode(de)->i_size = file_size;
        return de;
 }
 EXPORT_SYMBOL_GPL(debugfs_create_file_size);
@@ -423,8 +423,8 @@ struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
        /* directory inodes start off with i_nlink == 2 (for "." entry) */
        inc_nlink(inode);
        d_instantiate(dentry, inode);
-       inc_nlink(dentry->d_parent->d_inode);
-       fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
+       inc_nlink(d_inode(dentry->d_parent));
+       fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
        return end_creating(dentry);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_dir);
@@ -522,9 +522,9 @@ static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
        if (debugfs_positive(dentry)) {
                dget(dentry);
                if (d_is_dir(dentry))
-                       ret = simple_rmdir(parent->d_inode, dentry);
+                       ret = simple_rmdir(d_inode(parent), dentry);
                else
-                       simple_unlink(parent->d_inode, dentry);
+                       simple_unlink(d_inode(parent), dentry);
                if (!ret)
                        d_delete(dentry);
                dput(dentry);
@@ -554,12 +554,12 @@ void debugfs_remove(struct dentry *dentry)
                return;
 
        parent = dentry->d_parent;
-       if (!parent || !parent->d_inode)
+       if (!parent || d_really_is_negative(parent))
                return;
 
-       mutex_lock(&parent->d_inode->i_mutex);
+       mutex_lock(&d_inode(parent)->i_mutex);
        ret = __debugfs_remove(dentry, parent);
-       mutex_unlock(&parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(parent)->i_mutex);
        if (!ret)
                simple_release_fs(&debugfs_mount, &debugfs_mount_count);
 }
@@ -585,12 +585,12 @@ void debugfs_remove_recursive(struct dentry *dentry)
                return;
 
        parent = dentry->d_parent;
-       if (!parent || !parent->d_inode)
+       if (!parent || d_really_is_negative(parent))
                return;
 
        parent = dentry;
  down:
-       mutex_lock(&parent->d_inode->i_mutex);
+       mutex_lock(&d_inode(parent)->i_mutex);
  loop:
        /*
         * The parent->d_subdirs is protected by the d_lock. Outside that
@@ -605,7 +605,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
                /* perhaps simple_empty(child) makes more sense */
                if (!list_empty(&child->d_subdirs)) {
                        spin_unlock(&parent->d_lock);
-                       mutex_unlock(&parent->d_inode->i_mutex);
+                       mutex_unlock(&d_inode(parent)->i_mutex);
                        parent = child;
                        goto down;
                }
@@ -626,10 +626,10 @@ void debugfs_remove_recursive(struct dentry *dentry)
        }
        spin_unlock(&parent->d_lock);
 
-       mutex_unlock(&parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(parent)->i_mutex);
        child = parent;
        parent = parent->d_parent;
-       mutex_lock(&parent->d_inode->i_mutex);
+       mutex_lock(&d_inode(parent)->i_mutex);
 
        if (child != dentry)
                /* go up */
@@ -637,7 +637,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
 
        if (!__debugfs_remove(child, parent))
                simple_release_fs(&debugfs_mount, &debugfs_mount_count);
-       mutex_unlock(&parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(parent)->i_mutex);
 }
 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
 
@@ -669,27 +669,27 @@ struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
 
        trap = lock_rename(new_dir, old_dir);
        /* Source or destination directories don't exist? */
-       if (!old_dir->d_inode || !new_dir->d_inode)
+       if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
                goto exit;
        /* Source does not exist, cyclic rename, or mountpoint? */
-       if (!old_dentry->d_inode || old_dentry == trap ||
+       if (d_really_is_negative(old_dentry) || old_dentry == trap ||
            d_mountpoint(old_dentry))
                goto exit;
        dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
        /* Lookup failed, cyclic rename or target exists? */
-       if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
+       if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
                goto exit;
 
        old_name = fsnotify_oldname_init(old_dentry->d_name.name);
 
-       error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
+       error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
                dentry);
        if (error) {
                fsnotify_oldname_free(old_name);
                goto exit;
        }
        d_move(old_dentry, dentry);
-       fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
+       fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name,
                d_is_dir(old_dentry),
                NULL, old_dentry);
        fsnotify_oldname_free(old_name);
index cfe8466f7fef51d6ecdf338f0d71b6cc00aa19ca..add566303c684336cce3d8f9c4fa0f98678adafc 100644 (file)
@@ -253,7 +253,7 @@ static int mknod_ptmx(struct super_block *sb)
        if (!uid_valid(root_uid) || !gid_valid(root_gid))
                return -EINVAL;
 
-       mutex_lock(&root->d_inode->i_mutex);
+       mutex_lock(&d_inode(root)->i_mutex);
 
        /* If we have already created ptmx node, return */
        if (fsi->ptmx_dentry) {
@@ -290,7 +290,7 @@ static int mknod_ptmx(struct super_block *sb)
        fsi->ptmx_dentry = dentry;
        rc = 0;
 out:
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
        return rc;
 }
 
@@ -298,7 +298,7 @@ static void update_ptmx_mode(struct pts_fs_info *fsi)
 {
        struct inode *inode;
        if (fsi->ptmx_dentry) {
-               inode = fsi->ptmx_dentry->d_inode;
+               inode = d_inode(fsi->ptmx_dentry);
                inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode;
        }
 }
@@ -602,18 +602,18 @@ struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
 
        sprintf(s, "%d", index);
 
-       mutex_lock(&root->d_inode->i_mutex);
+       mutex_lock(&d_inode(root)->i_mutex);
 
        dentry = d_alloc_name(root, s);
        if (dentry) {
                d_add(dentry, inode);
-               fsnotify_create(root->d_inode, dentry);
+               fsnotify_create(d_inode(root), dentry);
        } else {
                iput(inode);
                inode = ERR_PTR(-ENOMEM);
        }
 
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
 
        return inode;
 }
@@ -658,7 +658,7 @@ void devpts_pty_kill(struct inode *inode)
 
        BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
 
-       mutex_lock(&root->d_inode->i_mutex);
+       mutex_lock(&d_inode(root)->i_mutex);
 
        dentry = d_find_alias(inode);
 
@@ -667,7 +667,7 @@ void devpts_pty_kill(struct inode *inode)
        dput(dentry);   /* d_alloc_name() in devpts_pty_new() */
        dput(dentry);           /* d_find_alias above */
 
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
 }
 
 static int __init init_devpts_fs(void)
index 719e1ce1c60930ec8e2c316631d21ec2bac03cc3..97315f2f68164f45f41176abeb1d0317467280f4 100644 (file)
@@ -1326,7 +1326,7 @@ static int ecryptfs_read_headers_virt(char *page_virt,
        if (rc)
                goto out;
        if (!(crypt_stat->flags & ECRYPTFS_I_SIZE_INITIALIZED))
-               ecryptfs_i_size_init(page_virt, ecryptfs_dentry->d_inode);
+               ecryptfs_i_size_init(page_virt, d_inode(ecryptfs_dentry));
        offset += MAGIC_ECRYPTFS_MARKER_SIZE_BYTES;
        rc = ecryptfs_process_flags(crypt_stat, (page_virt + offset),
                                    &bytes_read);
@@ -1425,7 +1425,7 @@ int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
 {
        int rc;
        char *page_virt;
-       struct inode *ecryptfs_inode = ecryptfs_dentry->d_inode;
+       struct inode *ecryptfs_inode = d_inode(ecryptfs_dentry);
        struct ecryptfs_crypt_stat *crypt_stat =
            &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
index 4000f6b3a7504505bb46d3d5ef2946b53e3d5cc9..8db0b464483f9b028f78e779a8337c3d33ca1c64 100644 (file)
@@ -54,11 +54,11 @@ static int ecryptfs_d_revalidate(struct dentry *dentry, unsigned int flags)
                return -ECHILD;
 
        rc = lower_dentry->d_op->d_revalidate(lower_dentry, flags);
-       if (dentry->d_inode) {
+       if (d_really_is_positive(dentry)) {
                struct inode *lower_inode =
-                       ecryptfs_inode_to_lower(dentry->d_inode);
+                       ecryptfs_inode_to_lower(d_inode(dentry));
 
-               fsstack_copy_attr_all(dentry->d_inode, lower_inode);
+               fsstack_copy_attr_all(d_inode(dentry), lower_inode);
        }
        return rc;
 }
index a65786e26b05ac97dbaab6a6258e533aa842cece..72afcc629d7b1fee2963fb90e1691a221eb77d8e 100644 (file)
@@ -130,7 +130,7 @@ struct kmem_cache *ecryptfs_file_info_cache;
 
 static int read_or_initialize_metadata(struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
        struct ecryptfs_crypt_stat *crypt_stat;
        int rc;
index b08b5187f6622cb6c7934d6dba9fcdfdbb0aefb6..fc850b55db67a27a99663596e1e8c711c8d71237 100644 (file)
@@ -41,13 +41,13 @@ static struct dentry *lock_parent(struct dentry *dentry)
        struct dentry *dir;
 
        dir = dget_parent(dentry);
-       mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT);
+       mutex_lock_nested(&(d_inode(dir)->i_mutex), I_MUTEX_PARENT);
        return dir;
 }
 
 static void unlock_dir(struct dentry *dir)
 {
-       mutex_unlock(&dir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dir)->i_mutex);
        dput(dir);
 }
 
@@ -131,7 +131,7 @@ struct inode *ecryptfs_get_inode(struct inode *lower_inode,
 static int ecryptfs_interpose(struct dentry *lower_dentry,
                              struct dentry *dentry, struct super_block *sb)
 {
-       struct inode *inode = ecryptfs_get_inode(lower_dentry->d_inode, sb);
+       struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
 
        if (IS_ERR(inode))
                return PTR_ERR(inode);
@@ -189,21 +189,21 @@ ecryptfs_do_create(struct inode *directory_inode,
 
        lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, true);
+       rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true);
        if (rc) {
                printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
                       "rc = [%d]\n", __func__, rc);
                inode = ERR_PTR(rc);
                goto out_lock;
        }
-       inode = __ecryptfs_get_inode(lower_dentry->d_inode,
+       inode = __ecryptfs_get_inode(d_inode(lower_dentry),
                                     directory_inode->i_sb);
        if (IS_ERR(inode)) {
-               vfs_unlink(lower_dir_dentry->d_inode, lower_dentry, NULL);
+               vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL);
                goto out_lock;
        }
-       fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);
+       fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
 out_lock:
        unlock_dir(lower_dir_dentry);
        return inode;
@@ -332,7 +332,7 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
                                     struct dentry *lower_dentry,
                                     struct inode *dir_inode)
 {
-       struct inode *inode, *lower_inode = lower_dentry->d_inode;
+       struct inode *inode, *lower_inode = d_inode(lower_dentry);
        struct ecryptfs_dentry_info *dentry_info;
        struct vfsmount *lower_mnt;
        int rc = 0;
@@ -347,14 +347,14 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
        }
 
        lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent));
-       fsstack_copy_attr_atime(dir_inode, lower_dentry->d_parent->d_inode);
+       fsstack_copy_attr_atime(dir_inode, d_inode(lower_dentry->d_parent));
        BUG_ON(!d_count(lower_dentry));
 
        ecryptfs_set_dentry_private(dentry, dentry_info);
        dentry_info->lower_path.mnt = lower_mnt;
        dentry_info->lower_path.dentry = lower_dentry;
 
-       if (!lower_dentry->d_inode) {
+       if (d_really_is_negative(lower_dentry)) {
                /* We want to add because we couldn't find in lower */
                d_add(dentry, NULL);
                return 0;
@@ -400,11 +400,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
        int rc = 0;
 
        lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
-       mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
        lower_dentry = lookup_one_len(ecryptfs_dentry->d_name.name,
                                      lower_dir_dentry,
                                      ecryptfs_dentry->d_name.len);
-       mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
        if (IS_ERR(lower_dentry)) {
                rc = PTR_ERR(lower_dentry);
                ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -412,7 +412,7 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                                ecryptfs_dentry);
                goto out;
        }
-       if (lower_dentry->d_inode)
+       if (d_really_is_positive(lower_dentry))
                goto interpose;
        mount_crypt_stat = &ecryptfs_superblock_to_private(
                                ecryptfs_dentry->d_sb)->mount_crypt_stat;
@@ -429,11 +429,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                       "filename; rc = [%d]\n", __func__, rc);
                goto out;
        }
-       mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
        lower_dentry = lookup_one_len(encrypted_and_encoded_name,
                                      lower_dir_dentry,
                                      encrypted_and_encoded_name_size);
-       mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
        if (IS_ERR(lower_dentry)) {
                rc = PTR_ERR(lower_dentry);
                ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -458,24 +458,24 @@ static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
        u64 file_size_save;
        int rc;
 
-       file_size_save = i_size_read(old_dentry->d_inode);
+       file_size_save = i_size_read(d_inode(old_dentry));
        lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
        lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
        dget(lower_old_dentry);
        dget(lower_new_dentry);
        lower_dir_dentry = lock_parent(lower_new_dentry);
-       rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
+       rc = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
                      lower_new_dentry, NULL);
-       if (rc || !lower_new_dentry->d_inode)
+       if (rc || d_really_is_negative(lower_new_dentry))
                goto out_lock;
        rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
        if (rc)
                goto out_lock;
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
-       set_nlink(old_dentry->d_inode,
-                 ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink);
-       i_size_write(new_dentry->d_inode, file_size_save);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+       set_nlink(d_inode(old_dentry),
+                 ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
+       i_size_write(d_inode(new_dentry), file_size_save);
 out_lock:
        unlock_dir(lower_dir_dentry);
        dput(lower_new_dentry);
@@ -485,7 +485,7 @@ out_lock:
 
 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
 {
-       return ecryptfs_do_unlink(dir, dentry, dentry->d_inode);
+       return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
 }
 
 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
@@ -510,20 +510,20 @@ static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
                                                  strlen(symname));
        if (rc)
                goto out_lock;
-       rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry,
+       rc = vfs_symlink(d_inode(lower_dir_dentry), lower_dentry,
                         encoded_symname);
        kfree(encoded_symname);
-       if (rc || !lower_dentry->d_inode)
+       if (rc || d_really_is_negative(lower_dentry))
                goto out_lock;
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out_lock;
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 out_lock:
        unlock_dir(lower_dir_dentry);
        dput(lower_dentry);
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
 }
@@ -536,18 +536,18 @@ static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode);
-       if (rc || !lower_dentry->d_inode)
+       rc = vfs_mkdir(d_inode(lower_dir_dentry), lower_dentry, mode);
+       if (rc || d_really_is_negative(lower_dentry))
                goto out;
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out;
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
-       set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+       set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
 out:
        unlock_dir(lower_dir_dentry);
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
 }
@@ -562,12 +562,12 @@ static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
        dget(dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
        dget(lower_dentry);
-       rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry);
+       rc = vfs_rmdir(d_inode(lower_dir_dentry), lower_dentry);
        dput(lower_dentry);
-       if (!rc && dentry->d_inode)
-               clear_nlink(dentry->d_inode);
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
+       if (!rc && d_really_is_positive(dentry))
+               clear_nlink(d_inode(dentry));
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
        unlock_dir(lower_dir_dentry);
        if (!rc)
                d_drop(dentry);
@@ -584,17 +584,17 @@ ecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        lower_dir_dentry = lock_parent(lower_dentry);
-       rc = vfs_mknod(lower_dir_dentry->d_inode, lower_dentry, mode, dev);
-       if (rc || !lower_dentry->d_inode)
+       rc = vfs_mknod(d_inode(lower_dir_dentry), lower_dentry, mode, dev);
+       if (rc || d_really_is_negative(lower_dentry))
                goto out;
        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
        if (rc)
                goto out;
-       fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-       fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
+       fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+       fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 out:
        unlock_dir(lower_dir_dentry);
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                d_drop(dentry);
        return rc;
 }
@@ -617,7 +617,7 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        dget(lower_new_dentry);
        lower_old_dir_dentry = dget_parent(lower_old_dentry);
        lower_new_dir_dentry = dget_parent(lower_new_dentry);
-       target_inode = new_dentry->d_inode;
+       target_inode = d_inode(new_dentry);
        trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
        /* source should not be ancestor of target */
        if (trap == lower_old_dentry) {
@@ -629,17 +629,17 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                rc = -ENOTEMPTY;
                goto out_lock;
        }
-       rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
-                       lower_new_dir_dentry->d_inode, lower_new_dentry,
+       rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,
+                       d_inode(lower_new_dir_dentry), lower_new_dentry,
                        NULL, 0);
        if (rc)
                goto out_lock;
        if (target_inode)
                fsstack_copy_attr_all(target_inode,
                                      ecryptfs_inode_to_lower(target_inode));
-       fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
+       fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
        if (new_dir != old_dir)
-               fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);
+               fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
 out_lock:
        unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
        dput(lower_new_dir_dentry);
@@ -662,7 +662,7 @@ static char *ecryptfs_readlink_lower(struct dentry *dentry, size_t *bufsiz)
                return ERR_PTR(-ENOMEM);
        old_fs = get_fs();
        set_fs(get_ds());
-       rc = lower_dentry->d_inode->i_op->readlink(lower_dentry,
+       rc = d_inode(lower_dentry)->i_op->readlink(lower_dentry,
                                                   (char __user *)lower_buf,
                                                   PATH_MAX);
        set_fs(old_fs);
@@ -681,8 +681,8 @@ static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd)
        char *buf = ecryptfs_readlink_lower(dentry, &len);
        if (IS_ERR(buf))
                goto out;
-       fsstack_copy_attr_atime(dentry->d_inode,
-                               ecryptfs_dentry_to_lower(dentry)->d_inode);
+       fsstack_copy_attr_atime(d_inode(dentry),
+                               d_inode(ecryptfs_dentry_to_lower(dentry)));
        buf[len] = '\0';
 out:
        nd_set_link(nd, buf);
@@ -738,7 +738,7 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
                          struct iattr *lower_ia)
 {
        int rc = 0;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ecryptfs_crypt_stat *crypt_stat;
        loff_t i_size = i_size_read(inode);
        loff_t lower_size_before_truncate;
@@ -751,7 +751,7 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
        rc = ecryptfs_get_lower_file(dentry, inode);
        if (rc)
                return rc;
-       crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
+       crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
        /* Switch on growing or shrinking file */
        if (ia->ia_size > i_size) {
                char zero[] = { 0x00 };
@@ -858,7 +858,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
        struct iattr lower_ia = { .ia_valid = 0 };
        int rc;
 
-       rc = ecryptfs_inode_newsize_ok(dentry->d_inode, new_length);
+       rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
        if (rc)
                return rc;
 
@@ -866,9 +866,9 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
        if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
                struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 
-               mutex_lock(&lower_dentry->d_inode->i_mutex);
+               mutex_lock(&d_inode(lower_dentry)->i_mutex);
                rc = notify_change(lower_dentry, &lower_ia, NULL);
-               mutex_unlock(&lower_dentry->d_inode->i_mutex);
+               mutex_unlock(&d_inode(lower_dentry)->i_mutex);
        }
        return rc;
 }
@@ -900,10 +900,10 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
        struct inode *lower_inode;
        struct ecryptfs_crypt_stat *crypt_stat;
 
-       crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
+       crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
        if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED))
                ecryptfs_init_crypt_stat(crypt_stat);
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        lower_inode = ecryptfs_inode_to_lower(inode);
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        mutex_lock(&crypt_stat->cs_mutex);
@@ -967,9 +967,9 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
        if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
                lower_ia.ia_valid &= ~ATTR_MODE;
 
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
        rc = notify_change(lower_dentry, &lower_ia, NULL);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        fsstack_copy_attr_all(inode, lower_inode);
        return rc;
@@ -983,7 +983,7 @@ static int ecryptfs_getattr_link(struct vfsmount *mnt, struct dentry *dentry,
 
        mount_crypt_stat = &ecryptfs_superblock_to_private(
                                                dentry->d_sb)->mount_crypt_stat;
-       generic_fillattr(dentry->d_inode, stat);
+       generic_fillattr(d_inode(dentry), stat);
        if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
                char *target;
                size_t targetsiz;
@@ -1007,9 +1007,9 @@ static int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
        rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat);
        if (!rc) {
-               fsstack_copy_attr_all(dentry->d_inode,
-                                     ecryptfs_inode_to_lower(dentry->d_inode));
-               generic_fillattr(dentry->d_inode, stat);
+               fsstack_copy_attr_all(d_inode(dentry),
+                                     ecryptfs_inode_to_lower(d_inode(dentry)));
+               generic_fillattr(d_inode(dentry), stat);
                stat->blocks = lower_stat.blocks;
        }
        return rc;
@@ -1023,14 +1023,14 @@ ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value,
        struct dentry *lower_dentry;
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       if (!lower_dentry->d_inode->i_op->setxattr) {
+       if (!d_inode(lower_dentry)->i_op->setxattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
 
        rc = vfs_setxattr(lower_dentry, name, value, size, flags);
-       if (!rc && dentry->d_inode)
-               fsstack_copy_attr_all(dentry->d_inode, lower_dentry->d_inode);
+       if (!rc && d_really_is_positive(dentry))
+               fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry));
 out:
        return rc;
 }
@@ -1041,14 +1041,14 @@ ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
 {
        int rc = 0;
 
-       if (!lower_dentry->d_inode->i_op->getxattr) {
+       if (!d_inode(lower_dentry)->i_op->getxattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = lower_dentry->d_inode->i_op->getxattr(lower_dentry, name, value,
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
+       rc = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, value,
                                                   size);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        return rc;
 }
@@ -1068,13 +1068,13 @@ ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
        struct dentry *lower_dentry;
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       if (!lower_dentry->d_inode->i_op->listxattr) {
+       if (!d_inode(lower_dentry)->i_op->listxattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = lower_dentry->d_inode->i_op->listxattr(lower_dentry, list, size);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
+       rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        return rc;
 }
@@ -1085,13 +1085,13 @@ static int ecryptfs_removexattr(struct dentry *dentry, const char *name)
        struct dentry *lower_dentry;
 
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
-       if (!lower_dentry->d_inode->i_op->removexattr) {
+       if (!d_inode(lower_dentry)->i_op->removexattr) {
                rc = -EOPNOTSUPP;
                goto out;
        }
-       mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = lower_dentry->d_inode->i_op->removexattr(lower_dentry, name);
-       mutex_unlock(&lower_dentry->d_inode->i_mutex);
+       mutex_lock(&d_inode(lower_dentry)->i_mutex);
+       rc = d_inode(lower_dentry)->i_op->removexattr(lower_dentry, name);
+       mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
        return rc;
 }
index f1ea610362c6c160a9d955c6a8e946da03b83ccb..866bb18efefea9953250ba1cbdc145e7d4be49af 100644 (file)
@@ -144,7 +144,7 @@ int ecryptfs_privileged_open(struct file **lower_file,
        /* Corresponding dput() and mntput() are done when the
         * lower file is fput() when all eCryptfs files for the inode are
         * released. */
-       flags |= IS_RDONLY(lower_dentry->d_inode) ? O_RDONLY : O_RDWR;
+       flags |= IS_RDONLY(d_inode(lower_dentry)) ? O_RDONLY : O_RDWR;
        (*lower_file) = dentry_open(&req.path, flags, cred);
        if (!IS_ERR(*lower_file))
                goto out;
index c095d32642599f90cf68a9437b9a10674d5cd3d9..4f4d0474bee961e456d015a08f5891b686b9033c 100644 (file)
@@ -546,11 +546,11 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
                goto out_free;
        }
 
-       if (check_ruid && !uid_eq(path.dentry->d_inode->i_uid, current_uid())) {
+       if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
                rc = -EPERM;
                printk(KERN_ERR "Mount of device (uid: %d) not owned by "
                       "requested user (uid: %d)\n",
-                       i_uid_read(path.dentry->d_inode),
+                       i_uid_read(d_inode(path.dentry)),
                        from_kuid(&init_user_ns, current_uid()));
                goto out_free;
        }
@@ -584,7 +584,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
                goto out_free;
        }
 
-       inode = ecryptfs_get_inode(path.dentry->d_inode, s);
+       inode = ecryptfs_get_inode(d_inode(path.dentry), s);
        rc = PTR_ERR(inode);
        if (IS_ERR(inode))
                goto out_free;
index 4626976794e75284b2665cfdb99b38092fecfd93..cf208522998ed9366fa981a79c8ea35af13b3123 100644 (file)
@@ -420,7 +420,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
        void *xattr_virt;
        struct dentry *lower_dentry =
                ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
-       struct inode *lower_inode = lower_dentry->d_inode;
+       struct inode *lower_inode = d_inode(lower_dentry);
        int rc;
 
        if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {
index 07ab49745e31c4c7ff945bbeb5b4cd67848ea3d3..3381b9da9ee6080881720f0500b71c74ecdf6058 100644 (file)
@@ -145,12 +145,12 @@ out:
 
 static int efivarfs_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct efivar_entry *var = dentry->d_inode->i_private;
+       struct efivar_entry *var = d_inode(dentry)->i_private;
 
        if (efivar_entry_delete(var))
                return -EINVAL;
 
-       drop_nlink(dentry->d_inode);
+       drop_nlink(d_inode(dentry));
        dput(dentry);
        return 0;
 };
index ddbce42548c9fb6c6e496b609c1fb05beb98c944..59fedbcf87984e179569914e9094db57b431611e 100644 (file)
@@ -144,7 +144,7 @@ static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor,
 
        name[len + EFI_VARIABLE_GUID_LEN+1] = '\0';
 
-       inode = efivarfs_get_inode(sb, root->d_inode, S_IFREG | 0644, 0);
+       inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0);
        if (!inode)
                goto fail_name;
 
index bbee8f063dfab1bba67b34fc07424a79c51ff47c..40ba9cc41bf74d322c563c9db1ec66a2633a1020 100644 (file)
@@ -111,9 +111,9 @@ struct dentry *efs_get_parent(struct dentry *child)
        struct dentry *parent = ERR_PTR(-ENOENT);
        efs_ino_t ino;
 
-       ino = efs_find_entry(child->d_inode, "..", 2);
+       ino = efs_find_entry(d_inode(child), "..", 2);
        if (ino)
-               parent = d_obtain_alias(efs_iget(child->d_inode->i_sb, ino));
+               parent = d_obtain_alias(efs_iget(d_inode(child)->i_sb, ino));
 
        return parent;
 }
index d7defd557601e6049ecb69fec954ea3b9d8e4ef0..4deb0b05b011266f344d7647a9cd004e085e4266 100644 (file)
@@ -379,7 +379,7 @@ ino_t exofs_parent_ino(struct dentry *child)
        struct exofs_dir_entry *de;
        ino_t ino;
 
-       de = exofs_dotdot(child->d_inode, &page);
+       de = exofs_dotdot(d_inode(child), &page);
        if (!de)
                return 0;
 
@@ -429,7 +429,7 @@ int exofs_set_link(struct inode *dir, struct exofs_dir_entry *de,
 
 int exofs_add_link(struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const unsigned char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        unsigned chunk_size = exofs_chunk_size(dir);
index 35073aaec6e08895f06ce3f7db86820d7dc982ec..786e4cc8c889cc8903f7d734ee3e255c0aeb24f8 100644 (file)
@@ -1028,7 +1028,7 @@ static int _do_truncate(struct inode *inode, loff_t newsize)
  */
 int exofs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        /* if we are about to modify an object, and it hasn't been
index 28907460e8fadaafb4975d9ea0c4903b497e28cb..5ae25e43119185e04d19a287e534921cc61bbc1c 100644 (file)
@@ -141,7 +141,7 @@ out_fail:
 static int exofs_link(struct dentry *old_dentry, struct inode *dir,
                struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
 
        inode->i_ctime = CURRENT_TIME;
        inode_inc_link_count(inode);
@@ -191,7 +191,7 @@ out_dir:
 
 static int exofs_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct exofs_dir_entry *de;
        struct page *page;
        int err = -ENOENT;
@@ -213,7 +213,7 @@ out:
 
 static int exofs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int err = -ENOTEMPTY;
 
        if (exofs_empty_dir(inode)) {
@@ -230,8 +230,8 @@ static int exofs_rmdir(struct inode *dir, struct dentry *dentry)
 static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
                struct inode *new_dir, struct dentry *new_dentry)
 {
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct page *dir_page = NULL;
        struct exofs_dir_entry *dir_de = NULL;
        struct page *old_page;
index fcc2e565f540c3d126997c181ee7c03340b075f3..b795c567b5e1df6e89a6531fabb1a493b9e541b4 100644 (file)
@@ -958,7 +958,7 @@ static struct dentry *exofs_get_parent(struct dentry *child)
        if (!ino)
                return ERR_PTR(-ESTALE);
 
-       return d_obtain_alias(exofs_iget(child->d_inode->i_sb, ino));
+       return d_obtain_alias(exofs_iget(d_inode(child)->i_sb, ino));
 }
 
 static struct inode *exofs_nfs_get_inode(struct super_block *sb,
index 832e2624b80bab95bd1440c5c8295ab13ec7859a..6f6f3a4c1365f730747e74d9c30dd83cb796b99c 100644 (file)
@@ -37,7 +37,7 @@
 
 static void *exofs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct exofs_i_info *oi = exofs_i(dentry->d_inode);
+       struct exofs_i_info *oi = exofs_i(d_inode(dentry));
 
        nd_set_link(nd, (char *)oi->i_data);
        return NULL;
index 6e1d4ab09d7226e4e519ea00a2e1941dd793ca39..796b491e69785e4b703b7c3a0cbc7e97d3510a40 100644 (file)
@@ -486,7 +486,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
  */
 int ext2_add_link (struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        unsigned chunk_size = ext2_chunk_size(dir);
index 6c14bb8322fabefa14cf6f59e51e179f66a8c71d..5c04a0ddea804e25b0548ef56272a33f48ea3318 100644 (file)
@@ -278,7 +278,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
        avefreeb = free_blocks / ngroups;
        ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
 
-       if ((parent == sb->s_root->d_inode) ||
+       if ((parent == d_inode(sb->s_root)) ||
            (EXT2_I(parent)->i_flags & EXT2_TOPDIR_FL)) {
                struct ext2_group_desc *best_desc = NULL;
                int best_ndir = inodes_per_group;
index e1abf75e994cb9b63c22a64591149b0ed39164f4..99a747cacf588a56080f5b8a2f1fa627d384557e 100644 (file)
@@ -1547,7 +1547,7 @@ int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
 
 int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        error = inode_change_ok(inode, iattr);
index 148f6e3789eaea4fa7937ef019d9dbf23af36b60..eee075d0b0cbe95837ddaaf4ce1fac8cb7167f61 100644 (file)
@@ -79,10 +79,10 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, uns
 struct dentry *ext2_get_parent(struct dentry *child)
 {
        struct qstr dotdot = QSTR_INIT("..", 2);
-       unsigned long ino = ext2_inode_by_name(child->d_inode, &dotdot);
+       unsigned long ino = ext2_inode_by_name(d_inode(child), &dotdot);
        if (!ino)
                return ERR_PTR(-ENOENT);
-       return d_obtain_alias(ext2_iget(child->d_inode->i_sb, ino));
+       return d_obtain_alias(ext2_iget(d_inode(child)->i_sb, ino));
 } 
 
 /*
@@ -214,7 +214,7 @@ out_fail:
 static int ext2_link (struct dentry * old_dentry, struct inode * dir,
        struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        int err;
 
        dquot_initialize(dir);
@@ -281,7 +281,7 @@ out_dir:
 
 static int ext2_unlink(struct inode * dir, struct dentry *dentry)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        struct ext2_dir_entry_2 * de;
        struct page * page;
        int err = -ENOENT;
@@ -305,7 +305,7 @@ out:
 
 static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        int err = -ENOTEMPTY;
 
        if (ext2_empty_dir(inode)) {
@@ -322,8 +322,8 @@ static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
 static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
        struct inode * new_dir, struct dentry * new_dentry )
 {
-       struct inode * old_inode = old_dentry->d_inode;
-       struct inode * new_inode = new_dentry->d_inode;
+       struct inode * old_inode = d_inode(old_dentry);
+       struct inode * new_inode = d_inode(new_dentry);
        struct page * dir_page = NULL;
        struct ext2_dir_entry_2 * dir_de = NULL;
        struct page * old_page;
index 565cf817bbf15d4660003f31889e51060a7044ef..20608f17c2e5144ed6283e6afe7f23dae6f51031 100644 (file)
@@ -23,7 +23,7 @@
 
 static void *ext2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct ext2_inode_info *ei = EXT2_I(dentry->d_inode);
+       struct ext2_inode_info *ei = EXT2_I(d_inode(dentry));
        nd_set_link(nd, (char *)ei->i_data);
        return NULL;
 }
index 91426141c33a32a1bd37bb95fa2414da5bcbad92..0b6bfd3a398bd320cf8bbbbe81745f364decd765 100644 (file)
@@ -243,7 +243,7 @@ cleanup:
 static int
 ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct buffer_head *bh = NULL;
        struct ext2_xattr_entry *entry;
        char *end;
@@ -319,7 +319,7 @@ cleanup:
 /*
  * Inode operation listxattr()
  *
- * dentry->d_inode->i_mutex: don't care
+ * d_inode(dentry)->i_mutex: don't care
  */
 ssize_t
 ext2_listxattr(struct dentry *dentry, char *buffer, size_t size)
index c0ebc4db88492e343a4e4f37d8e26e2b9f4480b3..702fc6840246e7484e5cc3d4c553c9dd2fa5d37e 100644 (file)
@@ -28,7 +28,7 @@ ext2_xattr_security_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_SECURITY, name,
+       return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name,
                              buffer, size);
 }
 
@@ -38,7 +38,7 @@ ext2_xattr_security_set(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_SECURITY, name,
+       return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name,
                              value, size, flags);
 }
 
index 7e192574c0013e6dbdfc591dc0395d4ac12f4886..42b6e9874bccf5501737ac53e62228ce22a6e3dd 100644 (file)
@@ -32,7 +32,7 @@ ext2_xattr_trusted_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_TRUSTED, name,
+       return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name,
                              buffer, size);
 }
 
@@ -42,7 +42,7 @@ ext2_xattr_trusted_set(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_TRUSTED, name,
+       return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name,
                              value, size, flags);
 }
 
index f470e44c4b8dbd1baefa82c4bbc9e53df15ca5cf..ecdc4605192cef4d502e6633e5537b5d06117a45 100644 (file)
@@ -36,7 +36,7 @@ ext2_xattr_user_get(struct dentry *dentry, const char *name,
                return -EINVAL;
        if (!test_opt(dentry->d_sb, XATTR_USER))
                return -EOPNOTSUPP;
-       return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_USER,
+       return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_USER,
                              name, buffer, size);
 }
 
@@ -49,7 +49,7 @@ ext2_xattr_user_set(struct dentry *dentry, const char *name,
        if (!test_opt(dentry->d_sb, XATTR_USER))
                return -EOPNOTSUPP;
 
-       return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_USER,
+       return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_USER,
                              name, value, size, flags);
 }
 
index a1b810230cc503708fa5cb2a91598684a0c3ca41..3ad242e5840e0bf0b2bec595039273e1e671afa0 100644 (file)
@@ -210,7 +210,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
        avefreeb = freeb / ngroups;
        ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
 
-       if ((parent == sb->s_root->d_inode) ||
+       if ((parent == d_inode(sb->s_root)) ||
            (EXT3_I(parent)->i_flags & EXT3_TOPDIR_FL)) {
                int best_ndir = inodes_per_group;
                int best_group = -1;
index 13c0868c7160ee572f30601939fcd6f421a01f11..2ee2dc4351d1630b375da3b9aaa062840ce1afc9 100644 (file)
@@ -3240,7 +3240,7 @@ int ext3_write_inode(struct inode *inode, struct writeback_control *wbc)
  */
 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error, rc = 0;
        const unsigned int ia_valid = attr->ia_valid;
 
index f197736dccfa16cca207fecb81e6445a18e96973..4264b9bd0002f199593308feaf7906292311e42f 100644 (file)
@@ -1049,19 +1049,19 @@ struct dentry *ext3_get_parent(struct dentry *child)
        struct ext3_dir_entry_2 * de;
        struct buffer_head *bh;
 
-       bh = ext3_find_entry(child->d_inode, &dotdot, &de);
+       bh = ext3_find_entry(d_inode(child), &dotdot, &de);
        if (!bh)
                return ERR_PTR(-ENOENT);
        ino = le32_to_cpu(de->inode);
        brelse(bh);
 
-       if (!ext3_valid_inum(child->d_inode->i_sb, ino)) {
-               ext3_error(child->d_inode->i_sb, "ext3_get_parent",
+       if (!ext3_valid_inum(d_inode(child)->i_sb, ino)) {
+               ext3_error(d_inode(child)->i_sb, "ext3_get_parent",
                           "bad inode number: %lu", ino);
                return ERR_PTR(-EIO);
        }
 
-       return d_obtain_alias(ext3_iget(child->d_inode->i_sb, ino));
+       return d_obtain_alias(ext3_iget(d_inode(child)->i_sb, ino));
 }
 
 #define S_SHIFT 12
@@ -1243,7 +1243,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
                             struct inode *inode, struct ext3_dir_entry_2 *de,
                             struct buffer_head * bh)
 {
-       struct inode    *dir = dentry->d_parent->d_inode;
+       struct inode    *dir = d_inode(dentry->d_parent);
        const char      *name = dentry->d_name.name;
        int             namelen = dentry->d_name.len;
        unsigned long   offset = 0;
@@ -1330,7 +1330,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
 static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
                            struct inode *inode, struct buffer_head *bh)
 {
-       struct inode    *dir = dentry->d_parent->d_inode;
+       struct inode    *dir = d_inode(dentry->d_parent);
        const char      *name = dentry->d_name.name;
        int             namelen = dentry->d_name.len;
        struct buffer_head *bh2;
@@ -1435,7 +1435,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
 static int ext3_add_entry (handle_t *handle, struct dentry *dentry,
        struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        struct buffer_head * bh;
        struct ext3_dir_entry_2 *de;
        struct super_block * sb;
@@ -1489,7 +1489,7 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
        struct dx_entry *entries, *at;
        struct dx_hash_info hinfo;
        struct buffer_head * bh;
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        struct super_block * sb = dir->i_sb;
        struct ext3_dir_entry_2 *de;
        int err;
@@ -2111,7 +2111,7 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */
        dquot_initialize(dir);
-       dquot_initialize(dentry->d_inode);
+       dquot_initialize(d_inode(dentry));
 
        handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
        if (IS_ERR(handle))
@@ -2125,7 +2125,7 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
        if (IS_DIRSYNC(dir))
                handle->h_sync = 1;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        retval = -EIO;
        if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -2173,7 +2173,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */
        dquot_initialize(dir);
-       dquot_initialize(dentry->d_inode);
+       dquot_initialize(d_inode(dentry));
 
        handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
        if (IS_ERR(handle))
@@ -2187,7 +2187,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
        if (!bh)
                goto end_unlink;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        retval = -EIO;
        if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -2328,7 +2328,7 @@ static int ext3_link (struct dentry * old_dentry,
                struct inode * dir, struct dentry *dentry)
 {
        handle_t *handle;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        int err, retries = 0;
 
        if (inode->i_nlink >= EXT3_LINK_MAX)
@@ -2391,8 +2391,8 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
 
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */
-       if (new_dentry->d_inode)
-               dquot_initialize(new_dentry->d_inode);
+       if (d_really_is_positive(new_dentry))
+               dquot_initialize(d_inode(new_dentry));
        handle = ext3_journal_start(old_dir, 2 *
                                        EXT3_DATA_TRANS_BLOCKS(old_dir->i_sb) +
                                        EXT3_INDEX_EXTRA_TRANS_BLOCKS + 2);
@@ -2409,12 +2409,12 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
         *  and merrily kill the link to whatever was created under the
         *  same name. Goodbye sticky bit ;-<
         */
-       old_inode = old_dentry->d_inode;
+       old_inode = d_inode(old_dentry);
        retval = -ENOENT;
        if (!old_bh || le32_to_cpu(old_de->inode) != old_inode->i_ino)
                goto end_rename;
 
-       new_inode = new_dentry->d_inode;
+       new_inode = d_inode(new_dentry);
        new_bh = ext3_find_entry(new_dir, &new_dentry->d_name, &new_de);
        if (new_bh) {
                if (!new_inode) {
index d4dbf3c259b3288a961304daff37d7e1a848e43f..30abbab2c65b2610e9c9fae5f172c494a95c9f96 100644 (file)
@@ -1170,7 +1170,7 @@ static int parse_options (char *options, struct super_block *sb,
                                return 0;
                        }
 
-                       journal_inode = path.dentry->d_inode;
+                       journal_inode = d_inode(path.dentry);
                        if (!S_ISBLK(journal_inode->i_mode)) {
                                ext3_msg(sb, KERN_ERR, "error: journal path %s "
                                        "is not a block device", journal_path);
@@ -2947,7 +2947,7 @@ static int ext3_write_info(struct super_block *sb, int type)
        handle_t *handle;
 
        /* Data block + inode block */
-       handle = ext3_journal_start(sb->s_root->d_inode, 2);
+       handle = ext3_journal_start(d_inode(sb->s_root), 2);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
        ret = dquot_commit_info(sb, type);
@@ -2994,7 +2994,7 @@ static int ext3_quota_on(struct super_block *sb, int type, int format_id,
         * When we journal data on quota file, we have to flush journal to see
         * all updates to the file when we bypass pagecache...
         */
-       if (ext3_should_journal_data(path->dentry->d_inode)) {
+       if (ext3_should_journal_data(d_inode(path->dentry))) {
                /*
                 * We don't need to lock updates but journal_flush() could
                 * otherwise be livelocked...
index 6b01c3eab1f3729fdd3293675aebabd65dcb95a1..ea96df3c58db199915e6e9b60b1d7beb9b931150 100644 (file)
@@ -23,7 +23,7 @@
 
 static void * ext3_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct ext3_inode_info *ei = EXT3_I(dentry->d_inode);
+       struct ext3_inode_info *ei = EXT3_I(d_inode(dentry));
        nd_set_link(nd, (char*)ei->i_data);
        return NULL;
 }
index c6874be6d58b41f02bcaa3b93cf182845bd85bec..a5591d721b555b3f6728ba6687accc306bf541c7 100644 (file)
@@ -137,7 +137,7 @@ ext3_xattr_handler(int name_index)
 /*
  * Inode operation listxattr()
  *
- * dentry->d_inode->i_mutex: don't care
+ * d_inode(dentry)->i_mutex: don't care
  */
 ssize_t
 ext3_listxattr(struct dentry *dentry, char *buffer, size_t size)
@@ -355,7 +355,7 @@ ext3_xattr_list_entries(struct dentry *dentry, struct ext3_xattr_entry *entry,
 static int
 ext3_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct buffer_head *bh = NULL;
        int error;
 
@@ -391,7 +391,7 @@ cleanup:
 static int
 ext3_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ext3_xattr_ibody_header *header;
        struct ext3_inode *raw_inode;
        struct ext3_iloc iloc;
@@ -432,7 +432,7 @@ ext3_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
        int i_error, b_error;
 
-       down_read(&EXT3_I(dentry->d_inode)->xattr_sem);
+       down_read(&EXT3_I(d_inode(dentry))->xattr_sem);
        i_error = ext3_xattr_ibody_list(dentry, buffer, buffer_size);
        if (i_error < 0) {
                b_error = 0;
@@ -445,7 +445,7 @@ ext3_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
                if (b_error < 0)
                        i_error = 0;
        }
-       up_read(&EXT3_I(dentry->d_inode)->xattr_sem);
+       up_read(&EXT3_I(d_inode(dentry))->xattr_sem);
        return i_error + b_error;
 }
 
index 722c2bf9645dc50e60267b9280f441cfc4b38d5b..c9506d5e3b13b523d70e66c2b8b5133452532731 100644 (file)
@@ -29,7 +29,7 @@ ext3_xattr_security_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_SECURITY,
+       return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_SECURITY,
                              name, buffer, size);
 }
 
@@ -39,7 +39,7 @@ ext3_xattr_security_set(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_SECURITY,
+       return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_SECURITY,
                              name, value, size, flags);
 }
 
index d75727cc67fab83175136e3bf0fbf35e2f878903..206cc66dc2852a59b1cc760995b87a1a9d35361b 100644 (file)
@@ -32,7 +32,7 @@ ext3_xattr_trusted_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_TRUSTED,
+       return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_TRUSTED,
                              name, buffer, size);
 }
 
@@ -42,7 +42,7 @@ ext3_xattr_trusted_set(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_TRUSTED, name,
+       return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_TRUSTED, name,
                              value, size, flags);
 }
 
index 5612af3567e0c942a389b455ed36eed91a886e89..021508ad16168c465c12324459c798837606f3e0 100644 (file)
@@ -34,7 +34,7 @@ ext3_xattr_user_get(struct dentry *dentry, const char *name, void *buffer,
                return -EINVAL;
        if (!test_opt(dentry->d_sb, XATTR_USER))
                return -EOPNOTSUPP;
-       return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_USER,
+       return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_USER,
                              name, buffer, size);
 }
 
@@ -46,7 +46,7 @@ ext3_xattr_user_set(struct dentry *dentry, const char *name,
                return -EINVAL;
        if (!test_opt(dentry->d_sb, XATTR_USER))
                return -EOPNOTSUPP;
-       return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_USER,
+       return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_USER,
                              name, value, size, flags);
 }
 
index a8bc47f75fa0946582ce5562ebdea334cead1ac6..3ceedea099ea7e82383ebf3c75b648551069a299 100644 (file)
@@ -56,7 +56,7 @@ static int ext4_sync_parent(struct inode *inode)
                dentry = d_find_any_alias(inode);
                if (!dentry)
                        break;
-               next = igrab(dentry->d_parent->d_inode);
+               next = igrab(d_inode(dentry->d_parent));
                dput(dentry);
                if (!next)
                        break;
index ac644c31ca67472f3a16f91c6107e3d06772f66f..d8d4f2929cbd95a4a3bb1509bb12442bb5452ccb 100644 (file)
@@ -444,7 +444,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent,
        ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
 
        if (S_ISDIR(mode) &&
-           ((parent == sb->s_root->d_inode) ||
+           ((parent == d_inode(sb->s_root)) ||
             (ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) {
                int best_ndir = inodes_per_group;
                int ret = -1;
index 4b143febf21f98d782892279b11731a50af5f359..f696948c548b2b8e0bcabd8624087423d35cdedd 100644 (file)
@@ -998,7 +998,7 @@ static int ext4_add_dirent_to_inline(handle_t *handle,
                                     struct ext4_iloc *iloc,
                                     void *inline_start, int inline_size)
 {
-       struct inode    *dir = dentry->d_parent->d_inode;
+       struct inode    *dir = d_inode(dentry->d_parent);
        const char      *name = dentry->d_name.name;
        int             namelen = dentry->d_name.len;
        int             err;
@@ -1251,7 +1251,7 @@ int ext4_try_add_inline_entry(handle_t *handle, struct dentry *dentry,
        int ret, inline_size;
        void *inline_start;
        struct ext4_iloc iloc;
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
 
        ret = ext4_get_inode_loc(dir, &iloc);
        if (ret)
index 42c942a950e15d7a7ac819ce9859230111bbf407..063052e4aa8ba37e0ab0c3f2479aca097c174c3c 100644 (file)
@@ -4524,7 +4524,7 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode)
  */
 int ext4_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error, rc = 0;
        int orphan = 0;
        const unsigned int ia_valid = attr->ia_valid;
@@ -4672,7 +4672,7 @@ int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
        struct inode *inode;
        unsigned long long delalloc_blocks;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        generic_fillattr(inode, stat);
 
        /*
index 3cb267aee8021a0bfaf3c46fb66efd655739e540..b52374e4210221bc02c9cb3ad23f8027f21e77ad 100644 (file)
@@ -475,7 +475,7 @@ int ext4_ext_migrate(struct inode *inode)
                EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
        owner[0] = i_uid_read(inode);
        owner[1] = i_gid_read(inode);
-       tmp_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
+       tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root),
                                   S_IFREG, NULL, goal, owner);
        if (IS_ERR(tmp_inode)) {
                retval = PTR_ERR(tmp_inode);
index 28fe71a2904c6de8c9774e67238d3a16a9b422a6..e086eebe335e7e33a37bfd3dfd7ba391a7a36b2d 100644 (file)
@@ -1429,7 +1429,7 @@ struct dentry *ext4_get_parent(struct dentry *child)
        struct ext4_dir_entry_2 * de;
        struct buffer_head *bh;
 
-       bh = ext4_find_entry(child->d_inode, &dotdot, &de, NULL);
+       bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
        if (IS_ERR(bh))
                return (struct dentry *) bh;
        if (!bh)
@@ -1437,13 +1437,13 @@ struct dentry *ext4_get_parent(struct dentry *child)
        ino = le32_to_cpu(de->inode);
        brelse(bh);
 
-       if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
-               EXT4_ERROR_INODE(child->d_inode,
+       if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
+               EXT4_ERROR_INODE(d_inode(child),
                                 "bad parent inode number: %u", ino);
                return ERR_PTR(-EIO);
        }
 
-       return d_obtain_alias(ext4_iget_normal(child->d_inode->i_sb, ino));
+       return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
 }
 
 /*
@@ -1676,7 +1676,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
                             struct inode *inode, struct ext4_dir_entry_2 *de,
                             struct buffer_head *bh)
 {
-       struct inode    *dir = dentry->d_parent->d_inode;
+       struct inode    *dir = d_inode(dentry->d_parent);
        const char      *name = dentry->d_name.name;
        int             namelen = dentry->d_name.len;
        unsigned int    blocksize = dir->i_sb->s_blocksize;
@@ -1732,7 +1732,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
 static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
                            struct inode *inode, struct buffer_head *bh)
 {
-       struct inode    *dir = dentry->d_parent->d_inode;
+       struct inode    *dir = d_inode(dentry->d_parent);
        const char      *name = dentry->d_name.name;
        int             namelen = dentry->d_name.len;
        struct buffer_head *bh2;
@@ -1864,7 +1864,7 @@ out_frames:
 static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
                          struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        struct buffer_head *bh;
        struct ext4_dir_entry_2 *de;
        struct ext4_dir_entry_tail *t;
@@ -1947,7 +1947,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
        struct dx_entry *entries, *at;
        struct dx_hash_info hinfo;
        struct buffer_head *bh;
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        struct super_block *sb = dir->i_sb;
        struct ext4_dir_entry_2 *de;
        int err;
@@ -2708,7 +2708,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */
        dquot_initialize(dir);
-       dquot_initialize(dentry->d_inode);
+       dquot_initialize(d_inode(dentry));
 
        retval = -ENOENT;
        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
@@ -2717,7 +2717,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
        if (!bh)
                goto end_rmdir;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        retval = -EIO;
        if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -2777,7 +2777,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */
        dquot_initialize(dir);
-       dquot_initialize(dentry->d_inode);
+       dquot_initialize(d_inode(dentry));
 
        retval = -ENOENT;
        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
@@ -2786,7 +2786,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
        if (!bh)
                goto end_unlink;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        retval = -EIO;
        if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -2938,7 +2938,7 @@ static int ext4_link(struct dentry *old_dentry,
                     struct inode *dir, struct dentry *dentry)
 {
        handle_t *handle;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        int err, retries = 0;
 
        if (inode->i_nlink >= EXT4_LINK_MAX)
@@ -3210,12 +3210,12 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct ext4_renament old = {
                .dir = old_dir,
                .dentry = old_dentry,
-               .inode = old_dentry->d_inode,
+               .inode = d_inode(old_dentry),
        };
        struct ext4_renament new = {
                .dir = new_dir,
                .dentry = new_dentry,
-               .inode = new_dentry->d_inode,
+               .inode = d_inode(new_dentry),
        };
        int force_reread;
        int retval;
@@ -3391,12 +3391,12 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct ext4_renament old = {
                .dir = old_dir,
                .dentry = old_dentry,
-               .inode = old_dentry->d_inode,
+               .inode = d_inode(old_dentry),
        };
        struct ext4_renament new = {
                .dir = new_dir,
                .dentry = new_dentry,
-               .inode = new_dentry->d_inode,
+               .inode = d_inode(new_dentry),
        };
        u8 new_file_type;
        int retval;
index e061e66c82800f700b7642e4c82fa2cc836be05f..386ba41fa17bcde0e16fb9b49b8f0ca009867a65 100644 (file)
@@ -1568,7 +1568,7 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
                        return -1;
                }
 
-               journal_inode = path.dentry->d_inode;
+               journal_inode = d_inode(path.dentry);
                if (!S_ISBLK(journal_inode->i_mode)) {
                        ext4_msg(sb, KERN_ERR, "error: journal path %s "
                                "is not a block device", journal_path);
@@ -5199,7 +5199,7 @@ static int ext4_write_info(struct super_block *sb, int type)
        handle_t *handle;
 
        /* Data block + inode block */
-       handle = ext4_journal_start(sb->s_root->d_inode, EXT4_HT_QUOTA, 2);
+       handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
        ret = dquot_commit_info(sb, type);
@@ -5247,7 +5247,7 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id,
         * all updates to the file when we bypass pagecache...
         */
        if (EXT4_SB(sb)->s_journal &&
-           ext4_should_journal_data(path->dentry->d_inode)) {
+           ext4_should_journal_data(d_inode(path->dentry))) {
                /*
                 * We don't need to lock updates but journal_flush() could
                 * otherwise be livelocked...
index ff371193201841aa5ffee964e09d5862a8e25796..57f50091b8d1285e7c16638504a08e6a268f9b16 100644 (file)
@@ -25,7 +25,7 @@
 
 static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct ext4_inode_info *ei = EXT4_I(dentry->d_inode);
+       struct ext4_inode_info *ei = EXT4_I(d_inode(dentry));
        nd_set_link(nd, (char *) ei->i_data);
        return NULL;
 }
index 1e09fc77395ce0c7cc20496161f09cf0d6eefdbd..19935320f7b4a4e868917f9b3f36120ddd7e9b98 100644 (file)
@@ -179,7 +179,7 @@ ext4_xattr_handler(int name_index)
 /*
  * Inode operation listxattr()
  *
- * dentry->d_inode->i_mutex: don't care
+ * d_inode(dentry)->i_mutex: don't care
  */
 ssize_t
 ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
@@ -424,7 +424,7 @@ ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
 static int
 ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct buffer_head *bh = NULL;
        int error;
        struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
@@ -461,7 +461,7 @@ cleanup:
 static int
 ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ext4_xattr_ibody_header *header;
        struct ext4_inode *raw_inode;
        struct ext4_iloc iloc;
@@ -502,7 +502,7 @@ ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
        int ret, ret2;
 
-       down_read(&EXT4_I(dentry->d_inode)->xattr_sem);
+       down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
        ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
        if (ret < 0)
                goto errout;
@@ -515,7 +515,7 @@ ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
                goto errout;
        ret += ret2;
 errout:
-       up_read(&EXT4_I(dentry->d_inode)->xattr_sem);
+       up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
        return ret;
 }
 
index d2a200624af59a61ef29b88e4320609ddf2c02d0..95d90e0560f05677279db254936a4fa086ad67d2 100644 (file)
@@ -33,7 +33,7 @@ ext4_xattr_security_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_SECURITY,
+       return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY,
                              name, buffer, size);
 }
 
@@ -43,7 +43,7 @@ ext4_xattr_security_set(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_SECURITY,
+       return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY,
                              name, value, size, flags);
 }
 
index 95f1f4ab59a4a663fa8cc7fbdc3051fd8a9e8944..891ee2ddfbd64a7b5f5201f6252edaafb3550b97 100644 (file)
@@ -36,7 +36,7 @@ ext4_xattr_trusted_get(struct dentry *dentry, const char *name, void *buffer,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_TRUSTED,
+       return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED,
                              name, buffer, size);
 }
 
@@ -46,7 +46,7 @@ ext4_xattr_trusted_set(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_TRUSTED,
+       return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED,
                              name, value, size, flags);
 }
 
index 0edb7611ffbeffbba85872625a3b456e4b955650..6ed932b3c04359b0817698ebcfcaf4a2d007b03f 100644 (file)
@@ -37,7 +37,7 @@ ext4_xattr_user_get(struct dentry *dentry, const char *name,
                return -EINVAL;
        if (!test_opt(dentry->d_sb, XATTR_USER))
                return -EOPNOTSUPP;
-       return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_USER,
+       return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_USER,
                              name, buffer, size);
 }
 
@@ -49,7 +49,7 @@ ext4_xattr_user_set(struct dentry *dentry, const char *name,
                return -EINVAL;
        if (!test_opt(dentry->d_sb, XATTR_USER))
                return -EOPNOTSUPP;
-       return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_USER,
+       return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_USER,
                              name, value, size, flags);
 }
 
index 7fa3313ab0e27381b95d48b22da8315e605ef567..02e4ab3e7d4d6b327bdd39927882eff1f7efee98 100644 (file)
@@ -1391,7 +1391,7 @@ bool f2fs_empty_dir(struct inode *);
 
 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
 {
-       return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
+       return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
                                inode);
 }
 
index df6a0596eccf210dfefbaaca2cf2f60ca57a7f6b..71a74f1e2bfb34a62b90c0d34d480d49b46ebd8d 100644 (file)
@@ -562,7 +562,7 @@ void f2fs_truncate(struct inode *inode)
 int f2fs_getattr(struct vfsmount *mnt,
                         struct dentry *dentry, struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        generic_fillattr(inode, stat);
        stat->blocks <<= 3;
        return 0;
@@ -601,7 +601,7 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 
 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct f2fs_inode_info *fi = F2FS_I(inode);
        int err;
 
index e79639a9787aab0f5d8d8b27fae7354a5cd087b6..ed7404706ca4d878464a95e1f0f39f1a852c1450 100644 (file)
@@ -150,7 +150,7 @@ out:
 static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
                struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
        int err;
 
@@ -181,10 +181,10 @@ out:
 struct dentry *f2fs_get_parent(struct dentry *child)
 {
        struct qstr dotdot = QSTR_INIT("..", 2);
-       unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot);
+       unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot);
        if (!ino)
                return ERR_PTR(-ENOENT);
-       return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino));
+       return d_obtain_alias(f2fs_iget(d_inode(child)->i_sb, ino));
 }
 
 static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
@@ -214,7 +214,7 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
 static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct f2fs_dir_entry *de;
        struct page *page;
        int err = -ENOENT;
@@ -326,7 +326,7 @@ out_fail:
 
 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        if (f2fs_empty_dir(inode))
                return f2fs_unlink(dir, dentry);
        return -ENOTEMPTY;
@@ -374,8 +374,8 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct page *old_dir_page;
        struct page *old_page, *new_page;
        struct f2fs_dir_entry *old_dir_entry = NULL;
@@ -501,8 +501,8 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
                             struct inode *new_dir, struct dentry *new_dentry)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct page *old_dir_page, *new_dir_page;
        struct page *old_page, *new_page;
        struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
index 5072bf9ae0ef841dc613202b998cbab864c969cd..62c82f35087e3a429d61bcc2fc3b2f46065b5e63 100644 (file)
@@ -83,7 +83,7 @@ static int f2fs_xattr_generic_get(struct dentry *dentry, const char *name,
        }
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return f2fs_getxattr(dentry->d_inode, type, name, buffer, size, NULL);
+       return f2fs_getxattr(d_inode(dentry), type, name, buffer, size, NULL);
 }
 
 static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
@@ -108,7 +108,7 @@ static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
        if (strcmp(name, "") == 0)
                return -EINVAL;
 
-       return f2fs_setxattr(dentry->d_inode, type, name,
+       return f2fs_setxattr(d_inode(dentry), type, name,
                                        value, size, NULL, flags);
 }
 
@@ -130,7 +130,7 @@ static size_t f2fs_xattr_advise_list(struct dentry *dentry, char *list,
 static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
                void *buffer, size_t size, int type)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (strcmp(name, "") != 0)
                return -EINVAL;
@@ -142,7 +142,7 @@ static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
 static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name,
                const void *value, size_t size, int flags, int type)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (strcmp(name, "") != 0)
                return -EINVAL;
@@ -442,7 +442,7 @@ cleanup:
 
 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct f2fs_xattr_entry *entry;
        void *base_addr;
        int error = 0;
index 1e98d333879f9952c77af87b1fe1e84177e2f6ee..54646829e08e29be7b91796093056b812c16dfb2 100644 (file)
@@ -309,7 +309,7 @@ void fat_truncate_blocks(struct inode *inode, loff_t offset)
 
 int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        generic_fillattr(inode, stat);
        stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size;
 
@@ -381,7 +381,7 @@ static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode)
 int fat_setattr(struct dentry *dentry, struct iattr *attr)
 {
        struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        unsigned int ia_valid;
        int error;
 
index a783b0e1272ad16b3bb638e35867e130a0f455b3..e68e794c71d2e2ad85cad4e3d6c3d5240b20a505 100644 (file)
@@ -310,7 +310,7 @@ out:
 static int msdos_rmdir(struct inode *dir, struct dentry *dentry)
 {
        struct super_block *sb = dir->i_sb;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct fat_slot_info sinfo;
        int err;
 
@@ -404,7 +404,7 @@ out:
 /***** Unlink a file */
 static int msdos_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = inode->i_sb;
        struct fat_slot_info sinfo;
        int err;
@@ -442,8 +442,8 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
        int err, old_attrs, is_dir, update_dotdot, corrupt = 0;
 
        old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
-       old_inode = old_dentry->d_inode;
-       new_inode = new_dentry->d_inode;
+       old_inode = d_inode(old_dentry);
+       new_inode = d_inode(new_dentry);
 
        err = fat_scan(old_dir, old_name, &old_sinfo);
        if (err) {
index b8b92c2f96834baa310a20b007557f1b9e69ae91..af400ab27d48d713fc554f8dc016d3c8db4b2d4f 100644 (file)
@@ -35,7 +35,7 @@ static int vfat_revalidate_shortname(struct dentry *dentry)
 {
        int ret = 1;
        spin_lock(&dentry->d_lock);
-       if (dentry->d_time != dentry->d_parent->d_inode->i_version)
+       if (dentry->d_time != d_inode(dentry->d_parent)->i_version)
                ret = 0;
        spin_unlock(&dentry->d_lock);
        return ret;
@@ -47,7 +47,7 @@ static int vfat_revalidate(struct dentry *dentry, unsigned int flags)
                return -ECHILD;
 
        /* This is not negative dentry. Always valid. */
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                return 1;
        return vfat_revalidate_shortname(dentry);
 }
@@ -67,7 +67,7 @@ static int vfat_revalidate_ci(struct dentry *dentry, unsigned int flags)
         * positive dentry isn't good idea. So it's unsupported like
         * rename("filename", "FILENAME") for now.
         */
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                return 1;
 
        /*
@@ -803,7 +803,7 @@ out:
 
 static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = dir->i_sb;
        struct fat_slot_info sinfo;
        int err;
@@ -834,7 +834,7 @@ out:
 
 static int vfat_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = dir->i_sb;
        struct fat_slot_info sinfo;
        int err;
@@ -917,8 +917,8 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct super_block *sb = old_dir->i_sb;
 
        old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
-       old_inode = old_dentry->d_inode;
-       new_inode = new_dentry->d_inode;
+       old_inode = d_inode(old_dentry);
+       new_inode = d_inode(new_dentry);
        mutex_lock(&MSDOS_SB(sb)->s_lock);
        err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
        if (err)
index 93e14933dcb6fc2abc24462fe9965a070e6d234d..eb192656fba2787a682acefbc9c6d9bed5c1fa2c 100644 (file)
@@ -266,7 +266,7 @@ struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
  * Find the parent for a directory that is not currently connected to
  * the filesystem root.
  *
- * On entry, the caller holds child_dir->d_inode->i_mutex.
+ * On entry, the caller holds d_inode(child_dir)->i_mutex.
  */
 static struct dentry *fat_get_parent(struct dentry *child_dir)
 {
@@ -276,7 +276,7 @@ static struct dentry *fat_get_parent(struct dentry *child_dir)
        struct inode *parent_inode = NULL;
        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 
-       if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
+       if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
                int parent_logstart = fat_get_start(sbi, de);
                parent_inode = fat_dget(sb, parent_logstart);
                if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
index c36aeaf92e41070cb905d57ffb1b6df8ce2dac4d..8b9229e2ca5cb572976a839ca20f58e0514b6726 100644 (file)
@@ -76,7 +76,7 @@ const struct address_space_operations vxfs_immed_aops = {
 static void *
 vxfs_immed_follow_link(struct dentry *dp, struct nameidata *np)
 {
-       struct vxfs_inode_info          *vip = VXFS_INO(dp->d_inode);
+       struct vxfs_inode_info          *vip = VXFS_INO(d_inode(dp));
        nd_set_link(np, vip->vii_immed.vi_immed);
        return NULL;
 }
index 205e0d5d530752532bcb045b4630ddee0ded7ffd..f863ac6647ac35506681b3a68923f09e5492b5ea 100644 (file)
@@ -244,7 +244,7 @@ int fuse_ctl_add_conn(struct fuse_conn *fc)
                return 0;
 
        parent = fuse_control_sb->s_root;
-       inc_nlink(parent->d_inode);
+       inc_nlink(d_inode(parent));
        sprintf(name, "%u", fc->dev);
        parent = fuse_ctl_add_dentry(parent, fc, name, S_IFDIR | 0500, 2,
                                     &simple_dir_inode_operations,
@@ -283,11 +283,11 @@ void fuse_ctl_remove_conn(struct fuse_conn *fc)
 
        for (i = fc->ctl_ndents - 1; i >= 0; i--) {
                struct dentry *dentry = fc->ctl_dentry[i];
-               dentry->d_inode->i_private = NULL;
+               d_inode(dentry)->i_private = NULL;
                d_drop(dentry);
                dput(dentry);
        }
-       drop_nlink(fuse_control_sb->s_root->d_inode);
+       drop_nlink(d_inode(fuse_control_sb->s_root));
 }
 
 static int fuse_ctl_fill_super(struct super_block *sb, void *data, int silent)
index 1545b711ddcfdc925410b3b553b6597b93c71a25..0572bca49f1546b3d9cd3b00fb7fc21f0369308b 100644 (file)
@@ -192,7 +192,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
        struct fuse_inode *fi;
        int ret;
 
-       inode = ACCESS_ONCE(entry->d_inode);
+       inode = d_inode_rcu(entry);
        if (inode && is_bad_inode(inode))
                goto invalid;
        else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
@@ -220,7 +220,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                attr_version = fuse_get_attr_version(fc);
 
                parent = dget_parent(entry);
-               fuse_lookup_init(fc, &args, get_node_id(parent->d_inode),
+               fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
                                 &entry->d_name, &outarg);
                ret = fuse_simple_request(fc, &args);
                dput(parent);
@@ -254,7 +254,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                                return -ECHILD;
                } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
                        parent = dget_parent(entry);
-                       fuse_advise_use_readdirplus(parent->d_inode);
+                       fuse_advise_use_readdirplus(d_inode(parent));
                        dput(parent);
                }
        }
@@ -487,7 +487,7 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
                        entry = res;
        }
 
-       if (!(flags & O_CREAT) || entry->d_inode)
+       if (!(flags & O_CREAT) || d_really_is_positive(entry))
                goto no_open;
 
        /* Only creates */
@@ -653,7 +653,7 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
        args.in.args[0].value = entry->d_name.name;
        err = fuse_simple_request(fc, &args);
        if (!err) {
-               struct inode *inode = entry->d_inode;
+               struct inode *inode = d_inode(entry);
                struct fuse_inode *fi = get_fuse_inode(inode);
 
                spin_lock(&fc->lock);
@@ -689,7 +689,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry)
        args.in.args[0].value = entry->d_name.name;
        err = fuse_simple_request(fc, &args);
        if (!err) {
-               clear_nlink(entry->d_inode);
+               clear_nlink(d_inode(entry));
                fuse_invalidate_attr(dir);
                fuse_invalidate_entry_cache(entry);
        } else if (err == -EINTR)
@@ -721,12 +721,12 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
        err = fuse_simple_request(fc, &args);
        if (!err) {
                /* ctime changes */
-               fuse_invalidate_attr(oldent->d_inode);
-               fuse_update_ctime(oldent->d_inode);
+               fuse_invalidate_attr(d_inode(oldent));
+               fuse_update_ctime(d_inode(oldent));
 
                if (flags & RENAME_EXCHANGE) {
-                       fuse_invalidate_attr(newent->d_inode);
-                       fuse_update_ctime(newent->d_inode);
+                       fuse_invalidate_attr(d_inode(newent));
+                       fuse_update_ctime(d_inode(newent));
                }
 
                fuse_invalidate_attr(olddir);
@@ -734,10 +734,10 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
                        fuse_invalidate_attr(newdir);
 
                /* newent will end up negative */
-               if (!(flags & RENAME_EXCHANGE) && newent->d_inode) {
-                       fuse_invalidate_attr(newent->d_inode);
+               if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
+                       fuse_invalidate_attr(d_inode(newent));
                        fuse_invalidate_entry_cache(newent);
-                       fuse_update_ctime(newent->d_inode);
+                       fuse_update_ctime(d_inode(newent));
                }
        } else if (err == -EINTR) {
                /* If request was interrupted, DEITY only knows if the
@@ -746,7 +746,7 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
                   directory), then there can be inconsistency between
                   the dcache and the real filesystem.  Tough luck. */
                fuse_invalidate_entry(oldent);
-               if (newent->d_inode)
+               if (d_really_is_positive(newent))
                        fuse_invalidate_entry(newent);
        }
 
@@ -788,7 +788,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir,
 {
        int err;
        struct fuse_link_in inarg;
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
        struct fuse_conn *fc = get_fuse_conn(inode);
        FUSE_ARGS(args);
 
@@ -961,9 +961,9 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
        fuse_invalidate_attr(parent);
        fuse_invalidate_entry(entry);
 
-       if (child_nodeid != 0 && entry->d_inode) {
-               mutex_lock(&entry->d_inode->i_mutex);
-               if (get_node_id(entry->d_inode) != child_nodeid) {
+       if (child_nodeid != 0 && d_really_is_positive(entry)) {
+               mutex_lock(&d_inode(entry)->i_mutex);
+               if (get_node_id(d_inode(entry)) != child_nodeid) {
                        err = -ENOENT;
                        goto badentry;
                }
@@ -977,13 +977,13 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
                                err = -ENOTEMPTY;
                                goto badentry;
                        }
-                       entry->d_inode->i_flags |= S_DEAD;
+                       d_inode(entry)->i_flags |= S_DEAD;
                }
                dont_mount(entry);
-               clear_nlink(entry->d_inode);
+               clear_nlink(d_inode(entry));
                err = 0;
  badentry:
-               mutex_unlock(&entry->d_inode->i_mutex);
+               mutex_unlock(&d_inode(entry)->i_mutex);
                if (!err)
                        d_delete(entry);
        } else {
@@ -1169,7 +1169,7 @@ static int fuse_direntplus_link(struct file *file,
        struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
        struct dentry *dentry;
        struct dentry *alias;
-       struct inode *dir = parent->d_inode;
+       struct inode *dir = d_inode(parent);
        struct fuse_conn *fc;
        struct inode *inode;
 
@@ -1205,7 +1205,7 @@ static int fuse_direntplus_link(struct file *file,
        name.hash = full_name_hash(name.name, name.len);
        dentry = d_lookup(parent, &name);
        if (dentry) {
-               inode = dentry->d_inode;
+               inode = d_inode(dentry);
                if (!inode) {
                        d_drop(dentry);
                } else if (get_node_id(inode) != o->nodeid ||
@@ -1367,7 +1367,7 @@ static int fuse_readdir(struct file *file, struct dir_context *ctx)
 
 static char *read_link(struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct fuse_conn *fc = get_fuse_conn(inode);
        FUSE_ARGS(args);
        char *link;
@@ -1712,7 +1712,7 @@ error:
 
 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 {
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
 
        if (!fuse_allow_current_process(get_fuse_conn(inode)))
                return -EACCES;
@@ -1726,7 +1726,7 @@ static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
                        struct kstat *stat)
 {
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
        struct fuse_conn *fc = get_fuse_conn(inode);
 
        if (!fuse_allow_current_process(fc))
@@ -1738,7 +1738,7 @@ static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
 static int fuse_setxattr(struct dentry *entry, const char *name,
                         const void *value, size_t size, int flags)
 {
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
        struct fuse_conn *fc = get_fuse_conn(inode);
        FUSE_ARGS(args);
        struct fuse_setxattr_in inarg;
@@ -1774,7 +1774,7 @@ static int fuse_setxattr(struct dentry *entry, const char *name,
 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
                             void *value, size_t size)
 {
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
        struct fuse_conn *fc = get_fuse_conn(inode);
        FUSE_ARGS(args);
        struct fuse_getxattr_in inarg;
@@ -1815,7 +1815,7 @@ static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
 
 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
 {
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
        struct fuse_conn *fc = get_fuse_conn(inode);
        FUSE_ARGS(args);
        struct fuse_getxattr_in inarg;
@@ -1857,7 +1857,7 @@ static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
 
 static int fuse_removexattr(struct dentry *entry, const char *name)
 {
-       struct inode *inode = entry->d_inode;
+       struct inode *inode = d_inode(entry);
        struct fuse_conn *fc = get_fuse_conn(inode);
        FUSE_ARGS(args);
        int err;
index e8799c11424b93f0581497c5774db2122780b40b..082ac1c97f397f7f8014c7896123f8c7a5eebe8f 100644 (file)
@@ -421,7 +421,7 @@ static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
        memset(&outarg, 0, sizeof(outarg));
        args.in.numargs = 0;
        args.in.h.opcode = FUSE_STATFS;
-       args.in.h.nodeid = get_node_id(dentry->d_inode);
+       args.in.h.nodeid = get_node_id(d_inode(dentry));
        args.out.numargs = 1;
        args.out.args[0].size = sizeof(outarg);
        args.out.args[0].value = &outarg;
@@ -740,7 +740,7 @@ static struct dentry *fuse_fh_to_parent(struct super_block *sb,
 
 static struct dentry *fuse_get_parent(struct dentry *child)
 {
-       struct inode *child_inode = child->d_inode;
+       struct inode *child_inode = d_inode(child);
        struct fuse_conn *fc = get_fuse_conn(child_inode);
        struct inode *inode;
        struct dentry *parent;
index 589f4ea9381c4518de238d786f56433512c57565..30822b148f3e607b97678a2e3b1224b3f30d422f 100644 (file)
@@ -48,9 +48,9 @@ static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
                return -ECHILD;
 
        parent = dget_parent(dentry);
-       sdp = GFS2_SB(parent->d_inode);
-       dip = GFS2_I(parent->d_inode);
-       inode = dentry->d_inode;
+       sdp = GFS2_SB(d_inode(parent));
+       dip = GFS2_I(d_inode(parent));
+       inode = d_inode(dentry);
 
        if (inode) {
                if (is_bad_inode(inode))
@@ -68,7 +68,7 @@ static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
                        goto fail;
        } 
 
-       error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
+       error = gfs2_dir_check(d_inode(parent), &dentry->d_name, ip);
        switch (error) {
        case 0:
                if (!inode)
@@ -113,10 +113,10 @@ static int gfs2_dentry_delete(const struct dentry *dentry)
 {
        struct gfs2_inode *ginode;
 
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                return 0;
 
-       ginode = GFS2_I(dentry->d_inode);
+       ginode = GFS2_I(d_inode(dentry));
        if (!ginode->i_iopen_gh.gh_gl)
                return 0;
 
index c41d255b6a7b58808d60b205c81ce44f2b0bc75f..5d15e9498b48364a516f7063bb41c2aee4a85a62 100644 (file)
@@ -49,7 +49,7 @@ static int gfs2_encode_fh(struct inode *inode, __u32 *p, int *len,
        fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF);
        *len = GFS2_SMALL_FH_SIZE;
 
-       if (!parent || inode == sb->s_root->d_inode)
+       if (!parent || inode == d_inode(sb->s_root))
                return *len;
 
        ip = GFS2_I(parent);
@@ -88,8 +88,8 @@ static int get_name_filldir(struct dir_context *ctx, const char *name,
 static int gfs2_get_name(struct dentry *parent, char *name,
                         struct dentry *child)
 {
-       struct inode *dir = parent->d_inode;
-       struct inode *inode = child->d_inode;
+       struct inode *dir = d_inode(parent);
+       struct inode *inode = d_inode(child);
        struct gfs2_inode *dip, *ip;
        struct get_name_filldir gnfd = {
                .ctx.actor = get_name_filldir,
@@ -128,7 +128,7 @@ static int gfs2_get_name(struct dentry *parent, char *name,
 
 static struct dentry *gfs2_get_parent(struct dentry *child)
 {
-       return d_obtain_alias(gfs2_lookupi(child->d_inode, &gfs2_qdotdot, 1));
+       return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1));
 }
 
 static struct dentry *gfs2_get_dentry(struct super_block *sb,
index 73c72253faac07f2918c08e5e20438d148160f7e..e301850255d14d088e4a3b5d93f705f8b6cf965b 100644 (file)
@@ -295,7 +295,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 
        if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
            (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
-            dir == sb->s_root->d_inode)) {
+            dir == d_inode(sb->s_root))) {
                igrab(dir);
                return dir;
        }
@@ -687,7 +687,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
        }
        gfs2_set_inode_flags(inode);
 
-       if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
+       if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
            (dip->i_diskflags & GFS2_DIF_TOPDIR))
                aflags |= GFS2_AF_ORLOV;
 
@@ -888,7 +888,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 {
        struct gfs2_inode *dip = GFS2_I(dir);
        struct gfs2_sbd *sdp = GFS2_SB(dir);
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder ghs[2];
        struct buffer_head *dibh;
@@ -1055,7 +1055,7 @@ static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 static int gfs2_unlink_inode(struct gfs2_inode *dip,
                             const struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        int error;
 
@@ -1091,7 +1091,7 @@ static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct gfs2_inode *dip = GFS2_I(dir);
        struct gfs2_sbd *sdp = GFS2_SB(dir);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder ghs[3];
        struct gfs2_rgrpd *rgd;
@@ -1241,7 +1241,7 @@ static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
                return PTR_ERR(d);
        if (d != NULL)
                dentry = d;
-       if (dentry->d_inode) {
+       if (d_really_is_positive(dentry)) {
                if (!(*opened & FILE_OPENED))
                        return finish_no_open(file, d);
                dput(d);
@@ -1282,7 +1282,7 @@ static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
                        error = -EINVAL;
                        break;
                }
-               if (dir == sb->s_root->d_inode) {
+               if (dir == d_inode(sb->s_root)) {
                        error = 0;
                        break;
                }
@@ -1321,7 +1321,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 {
        struct gfs2_inode *odip = GFS2_I(odir);
        struct gfs2_inode *ndip = GFS2_I(ndir);
-       struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
+       struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
        struct gfs2_inode *nip = NULL;
        struct gfs2_sbd *sdp = GFS2_SB(odir);
        struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
@@ -1332,8 +1332,8 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
        unsigned int x;
        int error;
 
-       if (ndentry->d_inode) {
-               nip = GFS2_I(ndentry->d_inode);
+       if (d_really_is_positive(ndentry)) {
+               nip = GFS2_I(d_inode(ndentry));
                if (ip == nip)
                        return 0;
        }
@@ -1457,7 +1457,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
        /* Check out the dir to be renamed */
 
        if (dir_rename) {
-               error = gfs2_permission(odentry->d_inode, MAY_WRITE);
+               error = gfs2_permission(d_inode(odentry), MAY_WRITE);
                if (error)
                        goto out_gunlock;
        }
@@ -1550,7 +1550,7 @@ out:
 
 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+       struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
        struct gfs2_holder i_gh;
        struct buffer_head *dibh;
        unsigned int size;
@@ -1740,7 +1740,7 @@ out:
 
 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder i_gh;
        int error;
@@ -1796,7 +1796,7 @@ out:
 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
                        struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder gh;
        int error;
@@ -1819,7 +1819,7 @@ static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
 static int gfs2_setxattr(struct dentry *dentry, const char *name,
                         const void *data, size_t size, int flags)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder gh;
        int ret;
@@ -1839,7 +1839,7 @@ static int gfs2_setxattr(struct dentry *dentry, const char *name,
 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
                             void *data, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder gh;
        int ret;
@@ -1860,7 +1860,7 @@ static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
 
 static int gfs2_removexattr(struct dentry *dentry, const char *name)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_holder gh;
        int ret;
index efc8e254787cb3ca61b059cc1e35ce5f494d2641..35b49f44c72f03f03351d397cbabb6a027ee8c23 100644 (file)
@@ -647,7 +647,7 @@ out_unlock:
 
 static int init_journal(struct gfs2_sbd *sdp, int undo)
 {
-       struct inode *master = sdp->sd_master_dir->d_inode;
+       struct inode *master = d_inode(sdp->sd_master_dir);
        struct gfs2_holder ji_gh;
        struct gfs2_inode *ip;
        int jindex = 1;
@@ -782,7 +782,7 @@ static struct lock_class_key gfs2_quota_imutex_key;
 static int init_inodes(struct gfs2_sbd *sdp, int undo)
 {
        int error = 0;
-       struct inode *master = sdp->sd_master_dir->d_inode;
+       struct inode *master = d_inode(sdp->sd_master_dir);
 
        if (undo)
                goto fail_qinode;
@@ -848,7 +848,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
        char buf[30];
        int error = 0;
        struct gfs2_inode *ip;
-       struct inode *master = sdp->sd_master_dir->d_inode;
+       struct inode *master = d_inode(sdp->sd_master_dir);
 
        if (sdp->sd_args.ar_spectator)
                return 0;
@@ -1357,7 +1357,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
                return ERR_PTR(error);
        }
        s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
-                path.dentry->d_inode->i_sb->s_bdev);
+                d_inode(path.dentry)->i_sb->s_bdev);
        path_put(&path);
        if (IS_ERR(s)) {
                pr_warn("gfs2 mount does not exist\n");
index 1666382b198db6463a75446578a7ee358ef66933..859c6edbf81a07cc0bfa5f688928301ac4f676ca 100644 (file)
@@ -1171,7 +1171,7 @@ static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *s
 
 static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-       struct super_block *sb = dentry->d_inode->i_sb;
+       struct super_block *sb = d_inode(dentry)->i_sb;
        struct gfs2_sbd *sdp = sb->s_fs_info;
        struct gfs2_statfs_change_host sc;
        int error;
index 0b81f783f78724293b174cd997d7f7b7321468b9..40a8e53b22932c98b39ea764b4d217b695120af1 100644 (file)
@@ -420,7 +420,7 @@ static int ea_list_i(struct gfs2_inode *ip, struct buffer_head *bh,
 
 ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-       struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+       struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
        struct gfs2_ea_request er;
        struct gfs2_holder i_gh;
        int error;
@@ -586,7 +586,7 @@ out:
 static int gfs2_xattr_get(struct dentry *dentry, const char *name,
                void *buffer, size_t size, int type)
 {
-       struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+       struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
        struct gfs2_ea_location el;
        int error;
 
@@ -1230,7 +1230,7 @@ int __gfs2_xattr_set(struct inode *inode, const char *name,
 static int gfs2_xattr_set(struct dentry *dentry, const char *name,
                const void *value, size_t size, int flags, int type)
 {
-       return __gfs2_xattr_set(dentry->d_inode, name, value,
+       return __gfs2_xattr_set(d_inode(dentry), name, value,
                                size, flags, type);
 }
 
index e057ec542a6ad3634d6dd240f2dfcadc3fff7a43..8d931b157bbef8bfd382d9c6878fbdb8d53da481 100644 (file)
@@ -16,7 +16,7 @@
 int hfs_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 hfs_find_data fd;
        hfs_cat_rec rec;
        struct hfs_cat_file *file;
@@ -59,7 +59,7 @@ out:
 ssize_t hfs_getxattr(struct dentry *dentry, const char *name,
                         void *value, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hfs_find_data fd;
        hfs_cat_rec rec;
        struct hfs_cat_file *file;
@@ -105,7 +105,7 @@ out:
 
 ssize_t hfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
                return -EOPNOTSUPP;
index 145566851e7a821fd1d87bbb9c111ce839ecf7db..eb2bbca945c5ba0e0e5a7b44667bda23033150b2 100644 (file)
@@ -253,7 +253,7 @@ static int hfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
  */
 static int hfs_remove(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int res;
 
        if (S_ISDIR(inode->i_mode) && inode->i_size != 2)
@@ -285,18 +285,18 @@ static int hfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        int res;
 
        /* Unlink destination if it already exists */
-       if (new_dentry->d_inode) {
+       if (d_really_is_positive(new_dentry)) {
                res = hfs_remove(new_dir, new_dentry);
                if (res)
                        return res;
        }
 
-       res = hfs_cat_move(old_dentry->d_inode->i_ino,
+       res = hfs_cat_move(d_inode(old_dentry)->i_ino,
                           old_dir, &old_dentry->d_name,
                           new_dir, &new_dentry->d_name);
        if (!res)
                hfs_cat_build_key(old_dir->i_sb,
-                                 (btree_key *)&HFS_I(old_dentry->d_inode)->cat_key,
+                                 (btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,
                                  new_dir->i_ino, &new_dentry->d_name);
        return res;
 }
index 75fd5d873c196dfd76006e77ef25405c9359c224..b99ebddb10cb5b5e2d422c0f2151fc926455d26b 100644 (file)
@@ -600,7 +600,7 @@ static int hfs_file_release(struct inode *inode, struct file *file)
 
 int hfs_inode_setattr(struct dentry *dentry, struct iattr * attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hfs_sb_info *hsb = HFS_SB(inode->i_sb);
        int error;
 
index 91b91fd3a9013a08cc7d12d5e3934b09931b1a1e..2875961fdc106fa543e25e3f9cc276b46ace35ed 100644 (file)
@@ -21,7 +21,7 @@ static int hfs_revalidate_dentry(struct dentry *dentry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        if(!inode)
                return 1;
 
index f0235c1640af7ec29edb92541f66dfc739c9b0db..e7ef1c72ef3db91a72bbb9d800c1b3ee03276a59 100644 (file)
@@ -81,7 +81,7 @@ again:
                                        HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
                                                create_date ||
                                entry.file.create_date ==
-                                       HFSPLUS_I(sb->s_root->d_inode)->
+                                       HFSPLUS_I(d_inode(sb->s_root))->
                                                create_date) &&
                                HFSPLUS_SB(sb)->hidden_dir) {
                        struct qstr str;
@@ -296,8 +296,8 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
                        struct dentry *dst_dentry)
 {
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb);
-       struct inode *inode = src_dentry->d_inode;
-       struct inode *src_dir = src_dentry->d_parent->d_inode;
+       struct inode *inode = d_inode(src_dentry);
+       struct inode *src_dir = d_inode(src_dentry->d_parent);
        struct qstr str;
        char name[32];
        u32 cnid, id;
@@ -353,7 +353,7 @@ out:
 static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct qstr str;
        char name[32];
        u32 cnid;
@@ -410,7 +410,7 @@ out:
 static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry)
 {
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int res;
 
        if (inode->i_size != 2)
@@ -529,7 +529,7 @@ static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry,
        int res;
 
        /* Unlink destination if it already exists */
-       if (new_dentry->d_inode) {
+       if (d_really_is_positive(new_dentry)) {
                if (d_is_dir(new_dentry))
                        res = hfsplus_rmdir(new_dir, new_dentry);
                else
index a43811f909353354ca9bebd3e5d13212d30ae505..8ad4c594898be9c69dc15916ecc19e204251f6bc 100644 (file)
@@ -243,7 +243,7 @@ static int hfsplus_file_release(struct inode *inode, struct file *file)
 
 static int hfsplus_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        error = inode_change_ok(inode, attr);
index d3ff5cc317d7948c956194a6e63414206167237a..ac807073c453451dae6621ea84fa1b902400759b 100644 (file)
@@ -26,7 +26,7 @@
 static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
 {
        struct dentry *dentry = file->f_path.dentry;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
        struct hfsplus_vh *vh = sbi->s_vhdr;
        struct hfsplus_vh *bvh = sbi->s_backup_vhdr;
index d98094a9f4769f698bd4495dfdc7a817c7e0065c..964d922f647edcab14cc02e2d9451c70710cec40 100644 (file)
@@ -574,7 +574,7 @@ static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
                                                char *buffer, size_t size)
 {
        ssize_t res = 0;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hfs_find_data fd;
        u16 entry_type;
        u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
@@ -642,7 +642,7 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
        ssize_t err;
        ssize_t res = 0;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hfs_find_data fd;
        u16 key_len = 0;
        struct hfsplus_attr_key attr_key;
index 288530cf80b5fe5555f05294d24710868ac3b46a..a1629cfe37d311bed47e1bfc40b85a29bbb289e4 100644 (file)
@@ -24,7 +24,7 @@ int __hfsplus_setxattr(struct inode *inode, const char *name,
 static inline int hfsplus_setxattr(struct dentry *dentry, const char *name,
                        const void *value, size_t size, int flags)
 {
-       return __hfsplus_setxattr(dentry->d_inode, name, value, size, flags);
+       return __hfsplus_setxattr(d_inode(dentry), name, value, size, flags);
 }
 
 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
@@ -35,7 +35,7 @@ static inline ssize_t hfsplus_getxattr(struct dentry *dentry,
                                        void *value,
                                        size_t size)
 {
-       return __hfsplus_getxattr(dentry->d_inode, name, value, size);
+       return __hfsplus_getxattr(d_inode(dentry), name, value, size);
 }
 
 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size);
index e021188ca110aa9561be325c22724c75034d21f9..b827aa4248d418cee70d5d3dd67cd31feda52310 100644 (file)
@@ -795,7 +795,7 @@ static int hostfs_permission(struct inode *ino, int desired)
 
 static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hostfs_iattr attrs;
        char *name;
        int err;
index 7ce4b74234a12011140fb32594bde7bac6450173..933c73780813198b8953376eaa1e595d786e36e1 100644 (file)
@@ -257,7 +257,7 @@ void hpfs_write_inode_nolock(struct inode *i)
 
 int hpfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error = -EINVAL;
 
        hpfs_lock(inode->i_sb);
index bdbc2c3080a457210c5bec65bd166e573d7889e6..a0872f239f04ff0292fe6dcd6d272673f892417a 100644 (file)
@@ -359,7 +359,7 @@ static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
        unsigned len = dentry->d_name.len;
        struct quad_buffer_head qbh;
        struct hpfs_dirent *de;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        dnode_secno dno;
        int r;
        int rep = 0;
@@ -433,7 +433,7 @@ static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
        unsigned len = dentry->d_name.len;
        struct quad_buffer_head qbh;
        struct hpfs_dirent *de;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        dnode_secno dno;
        int n_items = 0;
        int err;
@@ -522,8 +522,8 @@ static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        unsigned old_len = old_dentry->d_name.len;
        const unsigned char *new_name = new_dentry->d_name.name;
        unsigned new_len = new_dentry->d_name.len;
-       struct inode *i = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *i = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct quad_buffer_head qbh, qbh1;
        struct hpfs_dirent *dep, *nde;
        struct hpfs_dirent de;
index 043ac9d77262a858464adad185969109902c9479..fa2bd5366ecf1f4c3d9b81c2d80336a621831dcf 100644 (file)
@@ -153,9 +153,9 @@ static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
                return ERR_PTR(-ENOENT);
 
        parent = HPPFS_I(ino)->proc_dentry;
-       mutex_lock(&parent->d_inode->i_mutex);
+       mutex_lock(&d_inode(parent)->i_mutex);
        proc_dentry = lookup_one_len(name->name, parent, name->len);
-       mutex_unlock(&parent->d_inode->i_mutex);
+       mutex_unlock(&d_inode(parent)->i_mutex);
 
        if (IS_ERR(proc_dentry))
                return proc_dentry;
@@ -637,25 +637,25 @@ static const struct super_operations hppfs_sbops = {
 static int hppfs_readlink(struct dentry *dentry, char __user *buffer,
                          int buflen)
 {
-       struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
-       return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer,
+       struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
+       return d_inode(proc_dentry)->i_op->readlink(proc_dentry, buffer,
                                                    buflen);
 }
 
 static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
+       struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
 
-       return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd);
+       return d_inode(proc_dentry)->i_op->follow_link(proc_dentry, nd);
 }
 
 static void hppfs_put_link(struct dentry *dentry, struct nameidata *nd,
                           void *cookie)
 {
-       struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
+       struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
 
-       if (proc_dentry->d_inode->i_op->put_link)
-               proc_dentry->d_inode->i_op->put_link(proc_dentry, nd, cookie);
+       if (d_inode(proc_dentry)->i_op->put_link)
+               d_inode(proc_dentry)->i_op->put_link(proc_dentry, nd, cookie);
 }
 
 static const struct inode_operations hppfs_dir_iops = {
@@ -670,7 +670,7 @@ static const struct inode_operations hppfs_link_iops = {
 
 static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
 {
-       struct inode *proc_ino = dentry->d_inode;
+       struct inode *proc_ino = d_inode(dentry);
        struct inode *inode = new_inode(sb);
 
        if (!inode) {
index 8c2dad629e7c094d5808a0335b30e8f0b3abf920..7a20dbfd1e3800f2e042ecb4d7cf63d5b7c41318 100644 (file)
@@ -391,7 +391,7 @@ static int hugetlb_vmtruncate(struct inode *inode, loff_t offset)
 
 static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct hstate *h = hstate_inode(inode);
        int error;
        unsigned int ia_valid = attr->ia_valid;
@@ -585,7 +585,7 @@ static int hugetlbfs_migrate_page(struct address_space *mapping,
 static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb);
-       struct hstate *h = hstate_inode(dentry->d_inode);
+       struct hstate *h = hstate_inode(d_inode(dentry));
 
        buf->f_type = HUGETLBFS_MAGIC;
        buf->f_bsize = huge_page_size(h);
index 12088d8de3faa1984fa88db3228dfcf669bb1539..0c5f721b4e91d019d8b25a756b40dacaff0f4463 100644 (file)
@@ -44,7 +44,7 @@ static struct dentry *isofs_export_get_parent(struct dentry *child)
 {
        unsigned long parent_block = 0;
        unsigned long parent_offset = 0;
-       struct inode *child_inode = child->d_inode;
+       struct inode *child_inode = d_inode(child);
        struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
        struct iso_directory_record *de = NULL;
        struct buffer_head * bh = NULL;
index f21b6fb5e4c42f219022edb51c84a0d0674bd4d2..1ba5c97943b8751f0210870a7bb51636dd4e5ecd 100644 (file)
@@ -224,14 +224,14 @@ static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
 {
        struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
        struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
-       struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode);
+       struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry));
        int ret;
        uint32_t now = get_seconds();
 
        ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
                              dentry->d_name.len, dead_f, now);
        if (dead_f->inocache)
-               set_nlink(dentry->d_inode, dead_f->inocache->pino_nlink);
+               set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink);
        if (!ret)
                dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
        return ret;
@@ -241,8 +241,8 @@ static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
 
 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
 {
-       struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb);
-       struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
+       struct jffs2_sb_info *c = JFFS2_SB_INFO(d_inode(old_dentry)->i_sb);
+       struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
        struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
        int ret;
        uint8_t type;
@@ -256,7 +256,7 @@ static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct de
                return -EPERM;
 
        /* XXX: This is ugly */
-       type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
+       type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
        if (!type) type = DT_REG;
 
        now = get_seconds();
@@ -264,11 +264,11 @@ static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct de
 
        if (!ret) {
                mutex_lock(&f->sem);
-               set_nlink(old_dentry->d_inode, ++f->inocache->pino_nlink);
+               set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink);
                mutex_unlock(&f->sem);
-               d_instantiate(dentry, old_dentry->d_inode);
+               d_instantiate(dentry, d_inode(old_dentry));
                dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
-               ihold(old_dentry->d_inode);
+               ihold(d_inode(old_dentry));
        }
        return ret;
 }
@@ -585,7 +585,7 @@ static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
 {
        struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
        struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
-       struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
+       struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
        struct jffs2_full_dirent *fd;
        int ret;
        uint32_t now = get_seconds();
@@ -599,7 +599,7 @@ static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
                              dentry->d_name.len, f, now);
        if (!ret) {
                dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
-               clear_nlink(dentry->d_inode);
+               clear_nlink(d_inode(dentry));
                drop_nlink(dir_i);
        }
        return ret;
@@ -770,8 +770,8 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
         * the VFS can't check whether the victim is empty. The filesystem
         * needs to do that for itself.
         */
-       if (new_dentry->d_inode) {
-               victim_f = JFFS2_INODE_INFO(new_dentry->d_inode);
+       if (d_really_is_positive(new_dentry)) {
+               victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));
                if (d_is_dir(new_dentry)) {
                        struct jffs2_full_dirent *fd;
 
@@ -794,12 +794,12 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
        /* Make a hard link */
 
        /* XXX: This is ugly */
-       type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
+       type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
        if (!type) type = DT_REG;
 
        now = get_seconds();
        ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
-                           old_dentry->d_inode->i_ino, type,
+                           d_inode(old_dentry)->i_ino, type,
                            new_dentry->d_name.name, new_dentry->d_name.len, now);
 
        if (ret)
@@ -808,9 +808,9 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
        if (victim_f) {
                /* There was a victim. Kill it off nicely */
                if (d_is_dir(new_dentry))
-                       clear_nlink(new_dentry->d_inode);
+                       clear_nlink(d_inode(new_dentry));
                else
-                       drop_nlink(new_dentry->d_inode);
+                       drop_nlink(d_inode(new_dentry));
                /* Don't oops if the victim was a dirent pointing to an
                   inode which didn't exist. */
                if (victim_f->inocache) {
@@ -836,9 +836,9 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
 
        if (ret) {
                /* Oh shit. We really ought to make a single node which can do both atomically */
-               struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
+               struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
                mutex_lock(&f->sem);
-               inc_nlink(old_dentry->d_inode);
+               inc_nlink(d_inode(old_dentry));
                if (f->inocache && !d_is_dir(old_dentry))
                        f->inocache->pino_nlink++;
                mutex_unlock(&f->sem);
@@ -846,8 +846,8 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
                pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
                          __func__, ret);
                /* Might as well let the VFS know */
-               d_instantiate(new_dentry, old_dentry->d_inode);
-               ihold(old_dentry->d_inode);
+               d_instantiate(new_dentry, d_inode(old_dentry));
+               ihold(d_inode(old_dentry));
                new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
                return ret;
        }
index 601afd1afddf5bca94fb35f993e61919b6bbdcd4..fe5ea080b4ec810f29589b257f605389067dadf4 100644 (file)
@@ -190,7 +190,7 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
 
 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int rc;
 
        rc = inode_change_ok(inode, iattr);
index aca97f35b292f71be6a1a01007780c25a990551c..d4b43fb7adb18db678fc6bacf9cf9a0f3432af19 100644 (file)
@@ -54,7 +54,7 @@ static int jffs2_security_getxattr(struct dentry *dentry, const char *name,
        if (!strcmp(name, ""))
                return -EINVAL;
 
-       return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_SECURITY,
+       return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY,
                                 name, buffer, size);
 }
 
@@ -64,7 +64,7 @@ static int jffs2_security_setxattr(struct dentry *dentry, const char *name,
        if (!strcmp(name, ""))
                return -EINVAL;
 
-       return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_SECURITY,
+       return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY,
                                 name, buffer, size, flags);
 }
 
index 3d76f28a2ba9dc1d9e4b1d5b9dfde57af1b983e6..d86c5e3176a133cd898a62ff8a587010da845385 100644 (file)
@@ -140,14 +140,14 @@ static struct dentry *jffs2_get_parent(struct dentry *child)
 
        BUG_ON(!d_is_dir(child));
 
-       f = JFFS2_INODE_INFO(child->d_inode);
+       f = JFFS2_INODE_INFO(d_inode(child));
 
        pino = f->inocache->pino_nlink;
 
        JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
                    f->inocache->ino, pino);
 
-       return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino));
+       return d_obtain_alias(jffs2_iget(d_inode(child)->i_sb, pino));
 }
 
 static const struct export_operations jffs2_export_ops = {
index c7c77b0dfccde2fe5dedb619500fb8f4f4a1f866..1fefa25d0fa586a14caae06efea7363794be38fc 100644 (file)
@@ -31,7 +31,7 @@ const struct inode_operations jffs2_symlink_inode_operations =
 
 static void *jffs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
+       struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
        char *p = (char *)f->target;
 
        /*
index d72817ac51f646e50ea2e6e867a5252b540eb428..c4dd342d13a703966910057faaa0bdd1ed3f6bbb 100644 (file)
@@ -960,7 +960,7 @@ static const struct xattr_handler *xprefix_to_handler(int xprefix) {
 
 ssize_t jffs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
        struct jffs2_inode_cache *ic = f->inocache;
index 1c868194c5045b7ef2399ba89206038ddf534419..ceaf9c693225b44edeb5bb3bddea534c1b62ad51 100644 (file)
@@ -21,7 +21,7 @@ static int jffs2_trusted_getxattr(struct dentry *dentry, const char *name,
 {
        if (!strcmp(name, ""))
                return -EINVAL;
-       return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_TRUSTED,
+       return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED,
                                 name, buffer, size);
 }
 
@@ -30,7 +30,7 @@ static int jffs2_trusted_setxattr(struct dentry *dentry, const char *name,
 {
        if (!strcmp(name, ""))
                return -EINVAL;
-       return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_TRUSTED,
+       return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED,
                                 name, buffer, size, flags);
 }
 
index 916b5c96603942b718759dbda4b54b72223679a1..a71391eba51497bf7902f10ee44955e67b623e5e 100644 (file)
@@ -21,7 +21,7 @@ static int jffs2_user_getxattr(struct dentry *dentry, const char *name,
 {
        if (!strcmp(name, ""))
                return -EINVAL;
-       return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_USER,
+       return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_USER,
                                 name, buffer, size);
 }
 
@@ -30,7 +30,7 @@ static int jffs2_user_setxattr(struct dentry *dentry, const char *name,
 {
        if (!strcmp(name, ""))
                return -EINVAL;
-       return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_USER,
+       return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_USER,
                                 name, buffer, size, flags);
 }
 
index ae46788b97231efecb7eaf7d7c0a0b9c779349ef..e98d39d75cf41a3f63c889958f87804dbb6aacf2 100644 (file)
@@ -100,7 +100,7 @@ static int jfs_release(struct inode *inode, struct file *file)
 
 int jfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int rc;
 
        rc = inode_change_ok(inode, iattr);
index 38fdc533f4ecba5042f3473d0efe0454b2d52ef3..66db7bc0ed1096050c2b2f93c3aa9e16a0ba4726 100644 (file)
@@ -346,7 +346,7 @@ static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
 {
        int rc;
        tid_t tid;              /* transaction id */
-       struct inode *ip = dentry->d_inode;
+       struct inode *ip = d_inode(dentry);
        ino_t ino;
        struct component_name dname;
        struct inode *iplist[2];
@@ -472,7 +472,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
 {
        int rc;
        tid_t tid;              /* transaction id */
-       struct inode *ip = dentry->d_inode;
+       struct inode *ip = d_inode(dentry);
        ino_t ino;
        struct component_name dname;    /* object name */
        struct inode *iplist[2];
@@ -791,7 +791,7 @@ static int jfs_link(struct dentry *old_dentry,
 {
        int rc;
        tid_t tid;
-       struct inode *ip = old_dentry->d_inode;
+       struct inode *ip = d_inode(old_dentry);
        ino_t ino;
        struct component_name dname;
        struct btstack btstack;
@@ -879,7 +879,7 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
        struct component_name dname;
        int ssize;              /* source pathname size */
        struct btstack btstack;
-       struct inode *ip = dentry->d_inode;
+       struct inode *ip = d_inode(dentry);
        unchar *i_fastsymlink;
        s64 xlen = 0;
        int bmask = 0, xsize;
@@ -1086,8 +1086,8 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        dquot_initialize(old_dir);
        dquot_initialize(new_dir);
 
-       old_ip = old_dentry->d_inode;
-       new_ip = new_dentry->d_inode;
+       old_ip = d_inode(old_dentry);
+       new_ip = d_inode(new_dentry);
 
        if ((rc = get_UCSname(&old_dname, old_dentry)))
                goto out1;
@@ -1500,9 +1500,9 @@ struct dentry *jfs_get_parent(struct dentry *dentry)
        unsigned long parent_ino;
 
        parent_ino =
-               le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot);
+               le32_to_cpu(JFS_IP(d_inode(dentry))->i_dtroot.header.idotdot);
 
-       return d_obtain_alias(jfs_iget(dentry->d_inode->i_sb, parent_ino));
+       return d_obtain_alias(jfs_iget(d_inode(dentry)->i_sb, parent_ino));
 }
 
 const struct inode_operations jfs_dir_inode_operations = {
@@ -1578,7 +1578,7 @@ static int jfs_ci_revalidate(struct dentry *dentry, unsigned int flags)
         * positive dentry isn't good idea. So it's unsupported like
         * rename("filename", "FILENAME") for now.
         */
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                return 1;
 
        /*
index 205b946d8e0d3a2abd805896b93536dfc1193e39..80f42bcc4ef1295669de10ea1087384f1c98c95b 100644 (file)
@@ -24,7 +24,7 @@
 
 static void *jfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       char *s = JFS_IP(dentry->d_inode)->i_inline;
+       char *s = JFS_IP(d_inode(dentry))->i_inline;
        nd_set_link(nd, s);
        return NULL;
 }
index 46325d5c34fc37f1e2861c959e875886bfef124c..48b15a6e55586588a853018c92ce71acf329c9ba 100644 (file)
@@ -849,7 +849,7 @@ int __jfs_setxattr(tid_t tid, struct inode *inode, const char *name,
 int jfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                 size_t value_len, int flags)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct jfs_inode_info *ji = JFS_IP(inode);
        int rc;
        tid_t tid;
@@ -872,7 +872,7 @@ int jfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 
        tid = txBegin(inode->i_sb, 0);
        mutex_lock(&ji->commit_mutex);
-       rc = __jfs_setxattr(tid, dentry->d_inode, name, value, value_len,
+       rc = __jfs_setxattr(tid, d_inode(dentry), name, value, value_len,
                            flags);
        if (!rc)
                rc = txCommit(tid, 1, &inode, 0);
@@ -959,7 +959,7 @@ ssize_t jfs_getxattr(struct dentry *dentry, const char *name, void *data,
                        return -EOPNOTSUPP;
        }
 
-       err = __jfs_getxattr(dentry->d_inode, name, data, buf_size);
+       err = __jfs_getxattr(d_inode(dentry), name, data, buf_size);
 
        return err;
 }
@@ -976,7 +976,7 @@ static inline int can_list(struct jfs_ea *ea)
 
 ssize_t jfs_listxattr(struct dentry * dentry, char *data, size_t buf_size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        char *buffer;
        ssize_t size = 0;
        int xattr_size;
@@ -1029,7 +1029,7 @@ ssize_t jfs_listxattr(struct dentry * dentry, char *data, size_t buf_size)
 
 int jfs_removexattr(struct dentry *dentry, const char *name)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct jfs_inode_info *ji = JFS_IP(inode);
        int rc;
        tid_t tid;
@@ -1047,7 +1047,7 @@ int jfs_removexattr(struct dentry *dentry, const char *name)
 
        tid = txBegin(inode->i_sb, 0);
        mutex_lock(&ji->commit_mutex);
-       rc = __jfs_setxattr(tid, dentry->d_inode, name, NULL, 0, XATTR_REPLACE);
+       rc = __jfs_setxattr(tid, d_inode(dentry), name, NULL, 0, XATTR_REPLACE);
        if (!rc)
                rc = txCommit(tid, 1, &inode, 0);
        txEnd(tid);
index 6acc9648f9869727dc9fb030d281d37bffdf3277..f131fc23ffc4c18f03a9764973fa998bf0e5f79e 100644 (file)
@@ -444,7 +444,7 @@ static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
                return -ECHILD;
 
        /* Always perform fresh lookup for negatives */
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                goto out_bad_unlocked;
 
        kn = dentry->d_fsdata;
index 9000874a945b62bf4f4fded166133d5f90159823..2da8493a380b8a43a8eca65c04f4de245c4b0219 100644 (file)
@@ -111,7 +111,7 @@ int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
 
 int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct kernfs_node *kn = dentry->d_fsdata;
        int error;
 
@@ -172,11 +172,11 @@ int kernfs_iop_setxattr(struct dentry *dentry, const char *name,
 
        if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) {
                const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
-               error = security_inode_setsecurity(dentry->d_inode, suffix,
+               error = security_inode_setsecurity(d_inode(dentry), suffix,
                                                value, size, flags);
                if (error)
                        return error;
-               error = security_inode_getsecctx(dentry->d_inode,
+               error = security_inode_getsecctx(d_inode(dentry),
                                                &secdata, &secdata_len);
                if (error)
                        return error;
@@ -271,7 +271,7 @@ int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry,
                   struct kstat *stat)
 {
        struct kernfs_node *kn = dentry->d_fsdata;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        mutex_lock(&kernfs_mutex);
        kernfs_refresh_inode(kn, inode);
index 6bdc347008f5eb15d2d60ea9750202e72d380f18..4cf38f1185494115c0dcb8625f07b6593ae15fd5 100644 (file)
@@ -213,7 +213,7 @@ static void abort_transaction(struct inode *inode, struct logfs_transaction *ta)
 static int logfs_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct logfs_super *super = logfs_super(dir->i_sb);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct logfs_transaction *ta;
        struct page *page;
        pgoff_t index;
@@ -271,7 +271,7 @@ static inline int logfs_empty_dir(struct inode *dir)
 
 static int logfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (!logfs_empty_dir(inode))
                return -ENOTEMPTY;
@@ -537,7 +537,7 @@ static int logfs_symlink(struct inode *dir, struct dentry *dentry,
 static int logfs_link(struct dentry *old_dentry, struct inode *dir,
                struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
 
        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        ihold(inode);
@@ -607,7 +607,7 @@ static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry,
        /* 2. write target dd */
        mutex_lock(&super->s_dirop_mutex);
        logfs_add_transaction(new_dir, ta);
-       err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode);
+       err = logfs_write_dir(new_dir, new_dentry, d_inode(old_dentry));
        if (!err)
                err = write_inode(new_dir);
 
@@ -658,8 +658,8 @@ static int logfs_rename_target(struct inode *old_dir, struct dentry *old_dentry,
                               struct inode *new_dir, struct dentry *new_dentry)
 {
        struct logfs_super *super = logfs_super(old_dir->i_sb);
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        int isdir = S_ISDIR(old_inode->i_mode);
        struct logfs_disk_dentry dd;
        struct logfs_transaction *ta;
@@ -719,7 +719,7 @@ out:
 static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry)
 {
-       if (new_dentry->d_inode)
+       if (d_really_is_positive(new_dentry))
                return logfs_rename_target(old_dir, old_dentry,
                                           new_dir, new_dentry);
        return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);
index b2c13f739ffa27b8b8a249cadcd025737a512ce6..1a6f0167b16a7a4b657138ed7c366e8fe3151dfd 100644 (file)
@@ -241,7 +241,7 @@ int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 
 static int logfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int err = 0;
 
        err = inode_change_ok(inode, attr);
index dfaf6fa9b7b52a28bcb00ce3c4cd3df817158814..118e4e7bc9351cb3563a0ce85798301c83f0213e 100644 (file)
@@ -156,7 +156,7 @@ minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
 {
        const char * name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
-       struct inode * dir = dentry->d_parent->d_inode;
+       struct inode * dir = d_inode(dentry->d_parent);
        struct super_block * sb = dir->i_sb;
        struct minix_sb_info * sbi = minix_sb(sb);
        unsigned long n;
@@ -203,7 +203,7 @@ found:
 
 int minix_add_link(struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const char * name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        struct super_block * sb = dir->i_sb;
index 6d63e27ec961c6ed03b9bbcd46414d4436e065dd..94f0eb9a6e2c1f77db3b3d5095092cf47c655976 100644 (file)
@@ -23,7 +23,7 @@ const struct file_operations minix_file_operations = {
 
 static int minix_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        error = inode_change_ok(inode, attr);
index 3f57af196a7de36343be9249d2e883a9b162310b..1182d1e26a9ca4e1b83b76903d16e23ef7494183 100644 (file)
@@ -626,8 +626,8 @@ static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
 int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
        struct super_block *sb = dentry->d_sb;
-       generic_fillattr(dentry->d_inode, stat);
-       if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
+       generic_fillattr(d_inode(dentry), stat);
+       if (INODE_VERSION(d_inode(dentry)) == MINIX_V1)
                stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
        else
                stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
index cd950e2331b6c3164376e1b2205b3563f5703525..a795a11e50c728a9d31511fbc2849e8fb6fbeb8c 100644 (file)
@@ -104,7 +104,7 @@ out_fail:
 static int minix_link(struct dentry * old_dentry, struct inode * dir,
        struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
 
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
@@ -151,7 +151,7 @@ out_dir:
 static int minix_unlink(struct inode * dir, struct dentry *dentry)
 {
        int err = -ENOENT;
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        struct page * page;
        struct minix_dir_entry * de;
 
@@ -171,7 +171,7 @@ end_unlink:
 
 static int minix_rmdir(struct inode * dir, struct dentry *dentry)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        int err = -ENOTEMPTY;
 
        if (minix_empty_dir(inode)) {
@@ -187,8 +187,8 @@ static int minix_rmdir(struct inode * dir, struct dentry *dentry)
 static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
                           struct inode * new_dir, struct dentry *new_dentry)
 {
-       struct inode * old_inode = old_dentry->d_inode;
-       struct inode * new_inode = new_dentry->d_inode;
+       struct inode * old_inode = d_inode(old_dentry);
+       struct inode * new_inode = d_inode(new_dentry);
        struct page * dir_page = NULL;
        struct minix_dir_entry * dir_de = NULL;
        struct page * old_page;
index e7ca827d7694c130e0be25b85fa6e6aed7217ab5..80021c709af9cc02dc2d3a41a0f14fd7b6409e89 100644 (file)
@@ -127,7 +127,7 @@ static inline int ncp_case_sensitive(const struct inode *i)
 static int 
 ncp_hash_dentry(const struct dentry *dentry, struct qstr *this)
 {
-       struct inode *inode = ACCESS_ONCE(dentry->d_inode);
+       struct inode *inode = d_inode_rcu(dentry);
 
        if (!inode)
                return 0;
@@ -162,7 +162,7 @@ ncp_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
        if (len != name->len)
                return 1;
 
-       pinode = ACCESS_ONCE(parent->d_inode);
+       pinode = d_inode_rcu(parent);
        if (!pinode)
                return 1;
 
@@ -180,7 +180,7 @@ ncp_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
 static int
 ncp_delete_dentry(const struct dentry * dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (inode) {
                if (is_bad_inode(inode))
@@ -224,7 +224,7 @@ ncp_force_unlink(struct inode *dir, struct dentry* dentry)
        memset(&info, 0, sizeof(info));
        
         /* remove the Read-Only flag on the NW server */
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        old_nwattr = NCP_FINFO(inode)->nwattr;
        info.attributes = old_nwattr & ~(aRONLY|aDELETEINHIBIT|aRENAMEINHIBIT);
@@ -254,7 +254,7 @@ ncp_force_rename(struct inode *old_dir, struct dentry* old_dentry, char *_old_na
 {
        struct nw_modify_dos_info info;
         int res=0x90,res2;
-       struct inode *old_inode = old_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
        __le32 old_nwattr = NCP_FINFO(old_inode)->nwattr;
        __le32 new_nwattr = 0; /* shut compiler warning */
        int old_nwattr_changed = 0;
@@ -268,8 +268,8 @@ ncp_force_rename(struct inode *old_dir, struct dentry* old_dentry, char *_old_na
        res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode), old_inode, NULL, DM_ATTRIBUTES, &info);
        if (!res2)
                old_nwattr_changed = 1;
-       if (new_dentry && new_dentry->d_inode) {
-               new_nwattr = NCP_FINFO(new_dentry->d_inode)->nwattr;
+       if (new_dentry && d_really_is_positive(new_dentry)) {
+               new_nwattr = NCP_FINFO(d_inode(new_dentry))->nwattr;
                info.attributes = new_nwattr & ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
                res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir), new_dir, _new_name, DM_ATTRIBUTES, &info);
                if (!res2)
@@ -324,9 +324,9 @@ ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
                return -ECHILD;
 
        parent = dget_parent(dentry);
-       dir = parent->d_inode;
+       dir = d_inode(parent);
 
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                goto finished;
 
        server = NCP_SERVER(dir);
@@ -367,7 +367,7 @@ ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
         * what we remember, it's not valid any more.
         */
        if (!res) {
-               struct inode *inode = dentry->d_inode;
+               struct inode *inode = d_inode(dentry);
 
                mutex_lock(&inode->i_mutex);
                if (finfo.i.dirEntNum == NCP_FINFO(inode)->dirEntNum) {
@@ -388,7 +388,7 @@ finished:
 
 static time_t ncp_obtain_mtime(struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ncp_server *server = NCP_SERVER(inode);
        struct nw_info_struct i;
 
@@ -404,7 +404,7 @@ static time_t ncp_obtain_mtime(struct dentry *dentry)
 static inline void
 ncp_invalidate_dircache_entries(struct dentry *parent)
 {
-       struct ncp_server *server = NCP_SERVER(parent->d_inode);
+       struct ncp_server *server = NCP_SERVER(d_inode(parent));
        struct dentry *dentry;
 
        spin_lock(&parent->d_lock);
@@ -418,7 +418,7 @@ ncp_invalidate_dircache_entries(struct dentry *parent)
 static int ncp_readdir(struct file *file, struct dir_context *ctx)
 {
        struct dentry *dentry = file->f_path.dentry;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct page *page = NULL;
        struct ncp_server *server = NCP_SERVER(inode);
        union  ncp_dir_cache *cache = NULL;
@@ -491,13 +491,13 @@ static int ncp_readdir(struct file *file, struct dir_context *ctx)
                                goto invalid_cache;
                        }
                        spin_unlock(&dentry->d_lock);
-                       if (!dent->d_inode) {
+                       if (d_really_is_negative(dent)) {
                                dput(dent);
                                goto invalid_cache;
                        }
                        over = !dir_emit(ctx, dent->d_name.name,
                                        dent->d_name.len,
-                                       dent->d_inode->i_ino, DT_UNKNOWN);
+                                       d_inode(dent)->i_ino, DT_UNKNOWN);
                        dput(dent);
                        if (over)
                                goto finished;
@@ -571,7 +571,7 @@ static void ncp_d_prune(struct dentry *dentry)
 {
        if (!dentry->d_fsdata)  /* not referenced from page cache */
                return;
-       NCP_FINFO(dentry->d_parent->d_inode)->flags &= ~NCPI_DIR_CACHE;
+       NCP_FINFO(d_inode(dentry->d_parent))->flags &= ~NCPI_DIR_CACHE;
 }
 
 static int
@@ -580,7 +580,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                int inval_childs)
 {
        struct dentry *newdent, *dentry = file->f_path.dentry;
-       struct inode *dir = dentry->d_inode;
+       struct inode *dir = d_inode(dentry);
        struct ncp_cache_control ctl = *ctrl;
        struct qstr qname;
        int valid = 0;
@@ -621,7 +621,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                dentry_update_name_case(newdent, &qname);
        }
 
-       if (!newdent->d_inode) {
+       if (d_really_is_negative(newdent)) {
                struct inode *inode;
 
                entry->opened = 0;
@@ -637,7 +637,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                        spin_unlock(&dentry->d_lock);
                }
        } else {
-               struct inode *inode = newdent->d_inode;
+               struct inode *inode = d_inode(newdent);
 
                mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
                ncp_update_inode2(inode, entry);
@@ -659,10 +659,10 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                        ctl.cache = kmap(ctl.page);
        }
        if (ctl.cache) {
-               if (newdent->d_inode) {
+               if (d_really_is_positive(newdent)) {
                        newdent->d_fsdata = newdent;
                        ctl.cache->dentry[ctl.idx] = newdent;
-                       ino = newdent->d_inode->i_ino;
+                       ino = d_inode(newdent)->i_ino;
                        ncp_new_dentry(newdent);
                }
                valid = 1;
@@ -807,7 +807,7 @@ int ncp_conn_logged_in(struct super_block *sb)
                }
                dent = sb->s_root;
                if (dent) {
-                       struct inode* ino = dent->d_inode;
+                       struct inode* ino = d_inode(dent);
                        if (ino) {
                                ncp_update_known_namespace(server, volNumber, NULL);
                                NCP_FINFO(ino)->volNumber = volNumber;
@@ -815,7 +815,7 @@ int ncp_conn_logged_in(struct super_block *sb)
                                NCP_FINFO(ino)->DosDirNum = DosDirNum;
                                result = 0;
                        } else {
-                               ncp_dbg(1, "sb->s_root->d_inode == NULL!\n");
+                               ncp_dbg(1, "d_inode(sb->s_root) == NULL!\n");
                        }
                } else {
                        ncp_dbg(1, "sb->s_root == NULL!\n");
@@ -1055,7 +1055,7 @@ out:
 
 static int ncp_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ncp_server *server;
        int error;
 
index 01a9e16e97825eb67a7c761c6b7cc969bd8077d0..9605a2f635490ddf498c72049d7b40d84e7f977b 100644 (file)
@@ -812,7 +812,7 @@ static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
        if (!d) {
                goto dflt;
        }
-       i = d->d_inode;
+       i = d_inode(d);
        if (!i) {
                goto dflt;
        }
@@ -865,7 +865,7 @@ dflt:;
 
 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int result = 0;
        __le32 info_mask;
        struct nw_modify_dos_info info;
@@ -878,7 +878,7 @@ int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
                goto out;
 
        result = -EPERM;
-       if (IS_DEADDIR(dentry->d_inode))
+       if (IS_DEADDIR(d_inode(dentry)))
                goto out;
 
        /* ageing the dentry to force validation */
index cf7e043a944770a4c8e48b0b109a115a09c62023..79b113048eacdc645fb67994cb0dcb25aad84dd0 100644 (file)
@@ -376,7 +376,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                struct dentry* dentry = inode->i_sb->s_root;
 
                                if (dentry) {
-                                       struct inode* s_inode = dentry->d_inode;
+                                       struct inode* s_inode = d_inode(dentry);
 
                                        if (s_inode) {
                                                sr.volNumber = NCP_FINFO(s_inode)->volNumber;
@@ -384,7 +384,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                                sr.namespace = server->name_space[sr.volNumber];
                                                result = 0;
                                        } else
-                                               ncp_dbg(1, "s_root->d_inode==NULL\n");
+                                               ncp_dbg(1, "d_inode(s_root)==NULL\n");
                                } else
                                        ncp_dbg(1, "s_root==NULL\n");
                        } else {
@@ -431,7 +431,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                if (result == 0) {
                                        dentry = inode->i_sb->s_root;
                                        if (dentry) {
-                                               struct inode* s_inode = dentry->d_inode;
+                                               struct inode* s_inode = d_inode(dentry);
 
                                                if (s_inode) {
                                                        NCP_FINFO(s_inode)->volNumber = vnum;
@@ -439,7 +439,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                                        NCP_FINFO(s_inode)->DosDirNum = dosde;
                                                        server->root_setuped = 1;
                                                } else {
-                                                       ncp_dbg(1, "s_root->d_inode==NULL\n");
+                                                       ncp_dbg(1, "d_inode(s_root)==NULL\n");
                                                        result = -EIO;
                                                }
                                        } else {
index 2b502a0d79413ef2c01069b8dd228da14ecc354c..88dbbc9fcf4d6a5eb76a95f162481c7b88190a9b 100644 (file)
@@ -727,7 +727,7 @@ int
 ncp_del_file_or_subdir2(struct ncp_server *server,
                        struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        __u8  volnum;
        __le32 dirent;
 
index 1a63bfdb4a6584eb10d6744aabeec27e940513d7..421b6f91e8ecadc3b8105d380f84de38687194e4 100644 (file)
@@ -156,7 +156,7 @@ int ncp_symlink(struct inode *dir, struct dentry *dentry, const char *symname) {
                goto failfree;
        }
 
-       inode=dentry->d_inode;
+       inode=d_inode(dentry);
 
        if (ncp_make_open(inode, O_WRONLY))
                goto failfree;
index c19e16f0b2d049f972acee413a287d9f73759ba3..1e51ecd618544186d9d013a39ea666ee46ec7a0e 100644 (file)
@@ -416,15 +416,14 @@ int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
 {
        struct nfs_inode *nfsi;
 
-       if (dentry->d_inode == NULL)
-               goto different;
+       if (d_really_is_negative(dentry))
+               return 0;
 
-       nfsi = NFS_I(dentry->d_inode);
+       nfsi = NFS_I(d_inode(dentry));
        if (entry->fattr->fileid == nfsi->fileid)
                return 1;
        if (nfs_compare_fh(entry->fh, &nfsi->fh) == 0)
                return 1;
-different:
        return 0;
 }
 
@@ -473,7 +472,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
        struct qstr filename = QSTR_INIT(entry->name, entry->len);
        struct dentry *dentry;
        struct dentry *alias;
-       struct inode *dir = parent->d_inode;
+       struct inode *dir = d_inode(parent);
        struct inode *inode;
        int status;
 
@@ -497,9 +496,9 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
                        goto out;
                if (nfs_same_file(dentry, entry)) {
                        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-                       status = nfs_refresh_inode(dentry->d_inode, entry->fattr);
+                       status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
                        if (!status)
-                               nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label);
+                               nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
                        goto out;
                } else {
                        d_invalidate(dentry);
@@ -870,7 +869,7 @@ static bool nfs_dir_mapping_need_revalidate(struct inode *dir)
 static int nfs_readdir(struct file *file, struct dir_context *ctx)
 {
        struct dentry   *dentry = file->f_path.dentry;
-       struct inode    *inode = dentry->d_inode;
+       struct inode    *inode = d_inode(dentry);
        nfs_readdir_descriptor_t my_desc,
                        *desc = &my_desc;
        struct nfs_open_dir_context *dir_ctx = file->private_data;
@@ -1118,15 +1117,15 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 
        if (flags & LOOKUP_RCU) {
                parent = ACCESS_ONCE(dentry->d_parent);
-               dir = ACCESS_ONCE(parent->d_inode);
+               dir = d_inode_rcu(parent);
                if (!dir)
                        return -ECHILD;
        } else {
                parent = dget_parent(dentry);
-               dir = parent->d_inode;
+               dir = d_inode(parent);
        }
        nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        if (!inode) {
                if (nfs_neg_need_reval(dir, dentry, flags)) {
@@ -1242,7 +1241,7 @@ out_error:
 }
 
 /*
- * A weaker form of d_revalidate for revalidating just the dentry->d_inode
+ * A weaker form of d_revalidate for revalidating just the d_inode(dentry)
  * when we don't really care about the dentry name. This is called when a
  * pathwalk ends on a dentry that was not found via a normal lookup in the
  * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
@@ -1253,7 +1252,7 @@ out_error:
 static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
 {
        int error;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        /*
         * I believe we can only get a negative dentry here in the case of a
@@ -1287,7 +1286,7 @@ static int nfs_dentry_delete(const struct dentry *dentry)
                dentry, dentry->d_flags);
 
        /* Unhash any dentry with a stale inode */
-       if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
+       if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
                return 1;
 
        if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
@@ -1491,7 +1490,7 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
        int err;
 
        /* Expect a negative dentry */
-       BUG_ON(dentry->d_inode);
+       BUG_ON(d_inode(dentry));
 
        dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
                        dir->i_sb->s_id, dir->i_ino, dentry);
@@ -1587,7 +1586,7 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
        if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1)
                goto no_open;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        /* We can't create new files in nfs_open_revalidate(), so we
         * optimize away revalidation of negative dentries.
@@ -1598,12 +1597,12 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 
                if (flags & LOOKUP_RCU) {
                        parent = ACCESS_ONCE(dentry->d_parent);
-                       dir = ACCESS_ONCE(parent->d_inode);
+                       dir = d_inode_rcu(parent);
                        if (!dir)
                                return -ECHILD;
                } else {
                        parent = dget_parent(dentry);
-                       dir = parent->d_inode;
+                       dir = d_inode(parent);
                }
                if (!nfs_neg_need_reval(dir, dentry, flags))
                        ret = 1;
@@ -1643,14 +1642,14 @@ int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
                                struct nfs4_label *label)
 {
        struct dentry *parent = dget_parent(dentry);
-       struct inode *dir = parent->d_inode;
+       struct inode *dir = d_inode(parent);
        struct inode *inode;
        int error = -EACCES;
 
        d_drop(dentry);
 
        /* We may have been initialized further down */
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                goto out;
        if (fhandle->size == 0) {
                error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
@@ -1768,7 +1767,7 @@ EXPORT_SYMBOL_GPL(nfs_mkdir);
 
 static void nfs_dentry_handle_enoent(struct dentry *dentry)
 {
-       if (dentry->d_inode != NULL && !d_unhashed(dentry))
+       if (d_really_is_positive(dentry) && !d_unhashed(dentry))
                d_delete(dentry);
 }
 
@@ -1780,13 +1779,13 @@ int nfs_rmdir(struct inode *dir, struct dentry *dentry)
                        dir->i_sb->s_id, dir->i_ino, dentry);
 
        trace_nfs_rmdir_enter(dir, dentry);
-       if (dentry->d_inode) {
+       if (d_really_is_positive(dentry)) {
                nfs_wait_on_sillyrename(dentry);
                error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
                /* Ensure the VFS deletes this inode */
                switch (error) {
                case 0:
-                       clear_nlink(dentry->d_inode);
+                       clear_nlink(d_inode(dentry));
                        break;
                case -ENOENT:
                        nfs_dentry_handle_enoent(dentry);
@@ -1808,8 +1807,8 @@ EXPORT_SYMBOL_GPL(nfs_rmdir);
  */
 static int nfs_safe_remove(struct dentry *dentry)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
-       struct inode *inode = dentry->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
+       struct inode *inode = d_inode(dentry);
        int error = -EBUSY;
                
        dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
@@ -1853,7 +1852,7 @@ int nfs_unlink(struct inode *dir, struct dentry *dentry)
        if (d_count(dentry) > 1) {
                spin_unlock(&dentry->d_lock);
                /* Start asynchronous writeout of the inode */
-               write_inode_now(dentry->d_inode, 0);
+               write_inode_now(d_inode(dentry), 0);
                error = nfs_sillyrename(dir, dentry);
                goto out;
        }
@@ -1931,7 +1930,7 @@ int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
         * No big deal if we can't add this page to the page cache here.
         * READLINK will get the missing page from the server if needed.
         */
-       if (!add_to_page_cache_lru(page, dentry->d_inode->i_mapping, 0,
+       if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0,
                                                        GFP_KERNEL)) {
                SetPageUptodate(page);
                unlock_page(page);
@@ -1950,7 +1949,7 @@ EXPORT_SYMBOL_GPL(nfs_symlink);
 int
 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        int error;
 
        dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
@@ -1997,8 +1996,8 @@ EXPORT_SYMBOL_GPL(nfs_link);
 int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                      struct inode *new_dir, struct dentry *new_dentry)
 {
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct dentry *dentry = NULL, *rehash = NULL;
        struct rpc_task *task;
        int error = -EBUSY;
index 682f65fe09b5177dcd64bcd2970bbfcef9824ac3..ed0e6031be88eb2d291f7105a4112560c39caf2b 100644 (file)
@@ -403,8 +403,8 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)
 static void nfs_direct_readpage_release(struct nfs_page *req)
 {
        dprintk("NFS: direct read done (%s/%llu %d@%lld)\n",
-               req->wb_context->dentry->d_inode->i_sb->s_id,
-               (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+               d_inode(req->wb_context->dentry)->i_sb->s_id,
+               (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
                req->wb_bytes,
                (long long)req_offset(req));
        nfs_release_request(req);
index 9ac3846cb59e4d90d9979e46f198b8bd23f0e1c5..a608ffd28accd68a9c0db14bb02da23a5067db78 100644 (file)
@@ -56,11 +56,11 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
                 * This again causes shrink_dcache_for_umount_subtree() to
                 * Oops, since the test for IS_ROOT() will fail.
                 */
-               spin_lock(&sb->s_root->d_inode->i_lock);
+               spin_lock(&d_inode(sb->s_root)->i_lock);
                spin_lock(&sb->s_root->d_lock);
                hlist_del_init(&sb->s_root->d_u.d_alias);
                spin_unlock(&sb->s_root->d_lock);
-               spin_unlock(&sb->s_root->d_inode->i_lock);
+               spin_unlock(&d_inode(sb->s_root)->i_lock);
        }
        return 0;
 }
index d42dff6d5e983f65c2e2f299e12d5353f54236c7..3689e95da79aea3cf4ad68feb54001f156a931fa 100644 (file)
@@ -495,7 +495,7 @@ EXPORT_SYMBOL_GPL(nfs_fhget);
 int
 nfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct nfs_fattr *fattr;
        int error = -ENOMEM;
 
@@ -621,7 +621,7 @@ static void nfs_request_parent_use_readdirplus(struct dentry *dentry)
        struct dentry *parent;
 
        parent = dget_parent(dentry);
-       nfs_force_use_readdirplus(parent->d_inode);
+       nfs_force_use_readdirplus(d_inode(parent));
        dput(parent);
 }
 
@@ -637,7 +637,7 @@ static bool nfs_need_revalidate_inode(struct inode *inode)
 
 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
        int err = 0;
 
@@ -708,7 +708,7 @@ static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context
 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 {
        struct nfs_lock_context *res, *new = NULL;
-       struct inode *inode = ctx->dentry->d_inode;
+       struct inode *inode = d_inode(ctx->dentry);
 
        spin_lock(&inode->i_lock);
        res = __nfs_find_lock_context(ctx);
@@ -736,7 +736,7 @@ EXPORT_SYMBOL_GPL(nfs_get_lock_context);
 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
 {
        struct nfs_open_context *ctx = l_ctx->open_context;
-       struct inode *inode = ctx->dentry->d_inode;
+       struct inode *inode = d_inode(ctx->dentry);
 
        if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
                return;
@@ -763,7 +763,7 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
                return;
        if (!is_sync)
                return;
-       inode = ctx->dentry->d_inode;
+       inode = d_inode(ctx->dentry);
        if (!list_empty(&NFS_I(inode)->open_files))
                return;
        server = NFS_SERVER(inode);
@@ -810,7 +810,7 @@ EXPORT_SYMBOL_GPL(get_nfs_open_context);
 
 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
 {
-       struct inode *inode = ctx->dentry->d_inode;
+       struct inode *inode = d_inode(ctx->dentry);
        struct super_block *sb = ctx->dentry->d_sb;
 
        if (!list_empty(&ctx->list)) {
@@ -842,7 +842,7 @@ EXPORT_SYMBOL_GPL(put_nfs_open_context);
  */
 void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
 {
-       struct inode *inode = ctx->dentry->d_inode;
+       struct inode *inode = d_inode(ctx->dentry);
        struct nfs_inode *nfsi = NFS_I(inode);
 
        spin_lock(&inode->i_lock);
@@ -885,7 +885,7 @@ static void nfs_file_clear_open_context(struct file *filp)
        struct nfs_open_context *ctx = nfs_file_open_context(filp);
 
        if (ctx) {
-               struct inode *inode = ctx->dentry->d_inode;
+               struct inode *inode = d_inode(ctx->dentry);
 
                filp->private_data = NULL;
                spin_lock(&inode->i_lock);
index b5a0afc3ee101b988fc18df2b009c20e56812534..c8162c660c440bb28eb7e31fbd33ce1b4c3b1438 100644 (file)
@@ -139,7 +139,7 @@ EXPORT_SYMBOL_GPL(nfs_path);
 struct vfsmount *nfs_d_automount(struct path *path)
 {
        struct vfsmount *mnt;
-       struct nfs_server *server = NFS_SERVER(path->dentry->d_inode);
+       struct nfs_server *server = NFS_SERVER(d_inode(path->dentry));
        struct nfs_fh *fh = NULL;
        struct nfs_fattr *fattr = NULL;
 
@@ -180,16 +180,16 @@ out_nofree:
 static int
 nfs_namespace_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       if (NFS_FH(dentry->d_inode)->size != 0)
+       if (NFS_FH(d_inode(dentry))->size != 0)
                return nfs_getattr(mnt, dentry, stat);
-       generic_fillattr(dentry->d_inode, stat);
+       generic_fillattr(d_inode(dentry), stat);
        return 0;
 }
 
 static int
 nfs_namespace_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       if (NFS_FH(dentry->d_inode)->size != 0)
+       if (NFS_FH(d_inode(dentry))->size != 0)
                return nfs_setattr(dentry, attr);
        return -EACCES;
 }
@@ -279,7 +279,7 @@ struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,
        struct dentry *parent = dget_parent(dentry);
 
        /* Look it up again to get its attributes */
-       err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr, NULL);
+       err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name, fh, fattr, NULL);
        dput(parent);
        if (err != 0)
                return ERR_PTR(err);
index 658e586ca438bc2964c0edc75242a373c2239f50..1ebe2fc7cda2778edfb968da2c8f079dd2870431 100644 (file)
@@ -279,7 +279,7 @@ nfs3_list_one_acl(struct inode *inode, int type, const char *name, void *data,
 ssize_t
 nfs3_listxattr(struct dentry *dentry, char *data, size_t size)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        ssize_t result = 0;
        int error;
 
index 1f11d2533ee4107bd9ae3f8de460b38ecdbaae74..cb28cceefebe01462adbff860e52c43630d0dca2 100644 (file)
@@ -120,7 +120,7 @@ static int
 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                        struct iattr *sattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct nfs3_sattrargs   arg = {
                .fh             = NFS_FH(inode),
                .sattr          = sattr,
@@ -386,13 +386,13 @@ nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 * not sure this buys us anything (and I'd have
                 * to revamp the NFSv3 XDR code) */
                status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
-               nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
+               nfs_post_op_update_inode(d_inode(dentry), data->res.fattr);
                dprintk("NFS reply setattr (post-create): %d\n", status);
                if (status != 0)
                        goto out_release_acls;
        }
 
-       status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
+       status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 
 out_release_acls:
        posix_acl_release(acl);
@@ -570,7 +570,7 @@ nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
        if (status != 0)
                goto out_release_acls;
 
-       status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
+       status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 
 out_release_acls:
        posix_acl_release(acl);
@@ -623,7 +623,7 @@ static int
 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                  u64 cookie, struct page **pages, unsigned int count, int plus)
 {
-       struct inode            *dir = dentry->d_inode;
+       struct inode            *dir = d_inode(dentry);
        __be32                  *verf = NFS_I(dir)->cookieverf;
        struct nfs3_readdirargs arg = {
                .fh             = NFS_FH(dir),
@@ -715,7 +715,7 @@ nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
        if (status != 0)
                goto out_release_acls;
 
-       status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
+       status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 
 out_release_acls:
        posix_acl_release(acl);
index 86d6214ea022fee66f16f976a17451590edde7b8..51c2dbd1e942dd14c588e3020c6cd5fc6e956f97 100644 (file)
@@ -1130,7 +1130,7 @@ error:
  */
 static int nfs_probe_destination(struct nfs_server *server)
 {
-       struct inode *inode = server->super->s_root->d_inode;
+       struct inode *inode = d_inode(server->super->s_root);
        struct nfs_fattr *fattr;
        int error;
 
index 0181cde1d102ab5340ef7be230dc2e3ca036993c..619eca34e70fcc258b04b824f62d95b2f142765a 100644 (file)
@@ -46,7 +46,7 @@ nfs4_file_open(struct inode *inode, struct file *filp)
        openflags &= ~(O_CREAT|O_EXCL);
 
        parent = dget_parent(dentry);
-       dir = parent->d_inode;
+       dir = d_inode(parent);
 
        ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
        err = PTR_ERR(ctx);
@@ -74,7 +74,7 @@ nfs4_file_open(struct inode *inode, struct file *filp)
                        goto out_drop;
                }
        }
-       if (inode != dentry->d_inode)
+       if (inode != d_inode(dentry))
                goto out_drop;
 
        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
index 3d83cb1fdc700ee95f120eee7286ff63f17e17e2..f592672373cbb09c1ba18a0a7aedc1267dbd69b2 100644 (file)
@@ -375,7 +375,7 @@ static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *
        dprintk("%s: getting locations for %pd2\n",
                __func__, dentry);
 
-       err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
+       err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page);
        dput(parent);
        if (err != 0 ||
            fs_locations->nlocations <= 0 ||
@@ -396,7 +396,7 @@ struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
 {
        rpc_authflavor_t flavor = server->client->cl_auth->au_flavor;
        struct dentry *parent = dget_parent(dentry);
-       struct inode *dir = parent->d_inode;
+       struct inode *dir = d_inode(parent);
        struct qstr *name = &dentry->d_name;
        struct rpc_clnt *client;
        struct vfsmount *mnt;
index 627f37c44456752d6bd90a8882ae373ec6d70718..98e533f2c94a60c5bd0dd5ea5af66b1974fac197 100644 (file)
@@ -293,7 +293,7 @@ static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dent
                *p++ = xdr_one;                         /* bitmap length */
                *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
                *p++ = htonl(8);              /* attribute buffer length */
-               p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
+               p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
        }
        
        *p++ = xdr_one;                                  /* next */
@@ -305,7 +305,7 @@ static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dent
        *p++ = xdr_one;                         /* bitmap length */
        *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
        *p++ = htonl(8);              /* attribute buffer length */
-       p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
+       p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
 
        readdir->pgbase = (char *)p - (char *)start;
        readdir->count -= readdir->pgbase;
@@ -1004,7 +1004,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
                gfp_t gfp_mask)
 {
        struct dentry *parent = dget_parent(dentry);
-       struct inode *dir = parent->d_inode;
+       struct inode *dir = d_inode(parent);
        struct nfs_server *server = NFS_SERVER(dir);
        struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
        struct nfs4_opendata *p;
@@ -1057,7 +1057,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
        case NFS4_OPEN_CLAIM_FH:
        case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
        case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
-               p->o_arg.fh = NFS_FH(dentry->d_inode);
+               p->o_arg.fh = NFS_FH(d_inode(dentry));
        }
        if (attrs != NULL && attrs->ia_valid != 0) {
                __u32 verf[2];
@@ -1794,7 +1794,7 @@ static const struct rpc_call_ops nfs4_open_confirm_ops = {
  */
 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
 {
-       struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
+       struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
        struct rpc_task *task;
        struct  rpc_message msg = {
                .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
@@ -1951,7 +1951,7 @@ static const struct rpc_call_ops nfs4_open_ops = {
 
 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
 {
-       struct inode *dir = data->dir->d_inode;
+       struct inode *dir = d_inode(data->dir);
        struct nfs_server *server = NFS_SERVER(dir);
        struct nfs_openargs *o_arg = &data->o_arg;
        struct nfs_openres *o_res = &data->o_res;
@@ -1998,7 +1998,7 @@ static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
 
 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
 {
-       struct inode *dir = data->dir->d_inode;
+       struct inode *dir = d_inode(data->dir);
        struct nfs_openres *o_res = &data->o_res;
         int status;
 
@@ -2067,7 +2067,7 @@ static int nfs4_opendata_access(struct rpc_cred *cred,
  */
 static int _nfs4_proc_open(struct nfs4_opendata *data)
 {
-       struct inode *dir = data->dir->d_inode;
+       struct inode *dir = d_inode(data->dir);
        struct nfs_server *server = NFS_SERVER(dir);
        struct nfs_openargs *o_arg = &data->o_arg;
        struct nfs_openres *o_res = &data->o_res;
@@ -2314,7 +2314,7 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
 
        dentry = opendata->dentry;
-       if (dentry->d_inode == NULL) {
+       if (d_really_is_negative(dentry)) {
                /* FIXME: Is this d_drop() ever needed? */
                d_drop(dentry);
                dentry = d_add_unique(dentry, igrab(state->inode));
@@ -2325,7 +2325,7 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                        ctx->dentry = dget(dentry);
                }
                nfs_set_verifier(dentry,
-                               nfs_save_change_attribute(opendata->dir->d_inode));
+                               nfs_save_change_attribute(d_inode(opendata->dir)));
        }
 
        ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
@@ -2333,7 +2333,7 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                goto out;
 
        ctx->state = state;
-       if (dentry->d_inode == state->inode) {
+       if (d_inode(dentry) == state->inode) {
                nfs_inode_attach_open_context(ctx);
                if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
                        nfs4_schedule_stateid_recovery(server, state);
@@ -2374,10 +2374,10 @@ static int _nfs4_do_open(struct inode *dir,
        status = nfs4_recover_expired_lease(server);
        if (status != 0)
                goto err_put_state_owner;
-       if (dentry->d_inode != NULL)
-               nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
+       if (d_really_is_positive(dentry))
+               nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
        status = -ENOMEM;
-       if (dentry->d_inode)
+       if (d_really_is_positive(dentry))
                claim = NFS4_OPEN_CLAIM_FH;
        opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
                        label, claim, GFP_KERNEL);
@@ -2400,8 +2400,8 @@ static int _nfs4_do_open(struct inode *dir,
                }
                opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
        }
-       if (dentry->d_inode != NULL)
-               opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
+       if (d_really_is_positive(dentry))
+               opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
 
        status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
        if (status != 0)
@@ -3254,7 +3254,7 @@ static int
 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                  struct iattr *sattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct rpc_cred *cred = NULL;
        struct nfs4_state *state = NULL;
        struct nfs4_label *label = NULL;
@@ -3871,13 +3871,13 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                u64 cookie, struct page **pages, unsigned int count, int plus)
 {
-       struct inode            *dir = dentry->d_inode;
+       struct inode            *dir = d_inode(dentry);
        struct nfs4_readdir_arg args = {
                .fh = NFS_FH(dir),
                .pages = pages,
                .pgbase = 0,
                .count = count,
-               .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
+               .bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
                .plus = plus,
        };
        struct nfs4_readdir_res res;
@@ -3914,8 +3914,8 @@ static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
        do {
                err = _nfs4_proc_readdir(dentry, cred, cookie,
                                pages, count, plus);
-               trace_nfs4_readdir(dentry->d_inode, err);
-               err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err,
+               trace_nfs4_readdir(d_inode(dentry), err);
+               err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
                                &exception);
        } while (exception.retry);
        return err;
@@ -4830,7 +4830,7 @@ nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
        struct nfs4_label ilabel, *olabel = NULL;
        struct nfs_fattr fattr;
        struct rpc_cred *cred;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int status;
 
        if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
@@ -5670,7 +5670,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
        data->rpc_status = task->tk_status;
        switch (task->tk_status) {
        case 0:
-               renew_lease(NFS_SERVER(data->ctx->dentry->d_inode),
+               renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
                                data->timestamp);
                if (data->arg.new_lock) {
                        data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
@@ -6112,7 +6112,7 @@ static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
        if (strcmp(key, "") != 0)
                return -EINVAL;
 
-       return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
+       return nfs4_proc_set_acl(d_inode(dentry), buf, buflen);
 }
 
 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
@@ -6121,7 +6121,7 @@ static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
        if (strcmp(key, "") != 0)
                return -EINVAL;
 
-       return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
+       return nfs4_proc_get_acl(d_inode(dentry), buf, buflen);
 }
 
 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
@@ -6130,7 +6130,7 @@ static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
 {
        size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
 
-       if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
+       if (!nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry))))
                return 0;
 
        if (list && len <= list_len)
@@ -6158,7 +6158,7 @@ static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key,
                                   void *buf, size_t buflen, int type)
 {
        if (security_ismaclabel(key))
-               return nfs4_get_security_label(dentry->d_inode, buf, buflen);
+               return nfs4_get_security_label(d_inode(dentry), buf, buflen);
        return -EOPNOTSUPP;
 }
 
@@ -6168,10 +6168,10 @@ static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list,
 {
        size_t len = 0;
 
-       if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) {
-               len = security_inode_listsecurity(dentry->d_inode, NULL, 0);
+       if (nfs_server_capable(d_inode(dentry), NFS_CAP_SECURITY_LABEL)) {
+               len = security_inode_listsecurity(d_inode(dentry), NULL, 0);
                if (list && len <= list_len)
-                       security_inode_listsecurity(dentry->d_inode, list, len);
+                       security_inode_listsecurity(d_inode(dentry), list, len);
        }
        return len;
 }
index f95e3b58bbc304ae381df2a5f1721d8074789c51..3b2b20534a3a78c965d023d4c6eef1860b513ef6 100644 (file)
@@ -1902,7 +1902,7 @@ static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
                goto out;
        }
 
-       inode = server->super->s_root->d_inode;
+       inode = d_inode(server->super->s_root);
        result = nfs4_proc_get_locations(inode, locations, page, cred);
        if (result) {
                dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
@@ -2021,7 +2021,7 @@ restart:
 
                rcu_read_unlock();
 
-               inode = server->super->s_root->d_inode;
+               inode = d_inode(server->super->s_root);
                status = nfs4_proc_fsid_present(inode, cred);
                if (status != -NFS4ERR_MOVED)
                        goto restart;   /* wasn't this one */
index 1c32adbe728df548bcc92ee175b4d6061b3b4489..470af1a78becf206c6e2de9aae89b61b35eb8452 100644 (file)
@@ -418,7 +418,7 @@ DECLARE_EVENT_CLASS(nfs4_open_event,
                                __entry->fileid = 0;
                                __entry->fhandle = 0;
                        }
-                       __entry->dir = NFS_FILEID(ctx->dentry->d_parent->d_inode);
+                       __entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
                        __assign_str(name, ctx->dentry->d_name.name);
                ),
 
@@ -1110,7 +1110,7 @@ TRACE_EVENT(nfs4_layoutget,
                ),
 
                TP_fast_assign(
-                       const struct inode *inode = ctx->dentry->d_inode;
+                       const struct inode *inode = d_inode(ctx->dentry);
                        __entry->dev = inode->i_sb->s_dev;
                        __entry->fileid = NFS_FILEID(inode);
                        __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
index d57190a0d533134c2376c6556a8102e88996dd18..282b3936951060a2c8a6216c4c690e166a5fcb8d 100644 (file)
@@ -938,7 +938,7 @@ static bool nfs_can_coalesce_requests(struct nfs_page *prev,
        if (prev) {
                if (!nfs_match_open_context(req->wb_context, prev->wb_context))
                        return false;
-               flctx = req->wb_context->dentry->d_inode->i_flctx;
+               flctx = d_inode(req->wb_context->dentry)->i_flctx;
                if (flctx != NULL &&
                    !(list_empty_careful(&flctx->flc_posix) &&
                      list_empty_careful(&flctx->flc_flock)) &&
index 635f0865671cf38b27eea4a49261c9405a4a4731..084c9144f86db477330c7504158efd476bf80137 100644 (file)
@@ -426,7 +426,7 @@ static inline bool
 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
                         struct nfs_commit_info *cinfo, u32 ds_commit_idx)
 {
-       struct inode *inode = req->wb_context->dentry->d_inode;
+       struct inode *inode = d_inode(req->wb_context->dentry);
        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
        if (lseg == NULL || ld->mark_request_commit == NULL)
@@ -438,7 +438,7 @@ pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
 static inline bool
 pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
 {
-       struct inode *inode = req->wb_context->dentry->d_inode;
+       struct inode *inode = d_inode(req->wb_context->dentry);
        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
        if (ld == NULL || ld->clear_request_commit == NULL)
index c63189acd0523cf733ab494dc85c1acf0cdb8f33..b417bbcd970465069afcd820a414b19e4493e7e7 100644 (file)
@@ -118,7 +118,7 @@ static int
 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                 struct iattr *sattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct nfs_sattrargs    arg = { 
                .fh     = NFS_FH(inode),
                .sattr  = sattr
@@ -487,7 +487,7 @@ static int
 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                 u64 cookie, struct page **pages, unsigned int count, int plus)
 {
-       struct inode            *dir = dentry->d_inode;
+       struct inode            *dir = d_inode(dentry);
        struct nfs_readdirargs  arg = {
                .fh             = NFS_FH(dir),
                .cookie         = cookie,
index b8f5c63f77b2780b51d410ae4d3928ddf2bd1a76..a5b7427c37548dab4d7c3625c9f3e6096f3fde5c 100644 (file)
@@ -117,7 +117,7 @@ int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
 
 static void nfs_readpage_release(struct nfs_page *req)
 {
-       struct inode *inode = req->wb_context->dentry->d_inode;
+       struct inode *inode = d_inode(req->wb_context->dentry);
 
        dprintk("NFS: read done (%s/%llu %d@%lld)\n", inode->i_sb->s_id,
                (unsigned long long)NFS_FILEID(inode), req->wb_bytes,
index 322b2de02988fa6479c2d2831a5e5d70dfdad7c9..21f8f52bf37d02b509294a940cdfa0456e970ea7 100644 (file)
@@ -433,7 +433,7 @@ int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        struct nfs_server *server = NFS_SB(dentry->d_sb);
        unsigned char blockbits;
        unsigned long blockres;
-       struct nfs_fh *fh = NFS_FH(dentry->d_inode);
+       struct nfs_fh *fh = NFS_FH(d_inode(dentry));
        struct nfs_fsstat res;
        int error = -ENOMEM;
 
@@ -447,7 +447,7 @@ int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 
                pd_dentry = dget_parent(dentry);
                if (pd_dentry != NULL) {
-                       nfs_zap_caches(pd_dentry->d_inode);
+                       nfs_zap_caches(d_inode(pd_dentry));
                        dput(pd_dentry);
                }
        }
@@ -2526,7 +2526,7 @@ int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
                          struct nfs_mount_info *mount_info)
 {
        /* clone any lsm security options from the parent to the new sb */
-       if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
+       if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
                return -ESTALE;
        return security_sb_clone_mnt_opts(mount_info->cloned->sb, s);
 }
index 05c9e02f4153e340d94035bfdef6cc8db34b5a06..2d56200655fe600ae73d11c382af5815285fab48 100644 (file)
@@ -45,7 +45,7 @@ error:
 
 static void *nfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct page *page;
        void *err;
 
index de54129336c6d095984fd34c548491a2916e902b..fa538b2ba25183c46aaf62b96c35a647a829479f 100644 (file)
@@ -143,7 +143,7 @@ static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct n
                nfs_free_dname(data);
                ret = nfs_copy_dname(alias, data);
                spin_lock(&alias->d_lock);
-               if (ret == 0 && alias->d_inode != NULL &&
+               if (ret == 0 && d_really_is_positive(alias) &&
                    !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
                        devname_garbage = alias->d_fsdata;
                        alias->d_fsdata = data;
@@ -190,7 +190,7 @@ static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data)
        parent = dget_parent(dentry);
        if (parent == NULL)
                goto out_free;
-       dir = parent->d_inode;
+       dir = d_inode(parent);
        /* Non-exclusive lock protects against concurrent lookup() calls */
        spin_lock(&dir->i_lock);
        if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) {
@@ -210,21 +210,21 @@ out_free:
 
 void nfs_wait_on_sillyrename(struct dentry *dentry)
 {
-       struct nfs_inode *nfsi = NFS_I(dentry->d_inode);
+       struct nfs_inode *nfsi = NFS_I(d_inode(dentry));
 
        wait_event(nfsi->waitqueue, atomic_read(&nfsi->silly_count) <= 1);
 }
 
 void nfs_block_sillyrename(struct dentry *dentry)
 {
-       struct nfs_inode *nfsi = NFS_I(dentry->d_inode);
+       struct nfs_inode *nfsi = NFS_I(d_inode(dentry));
 
        wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1);
 }
 
 void nfs_unblock_sillyrename(struct dentry *dentry)
 {
-       struct inode *dir = dentry->d_inode;
+       struct inode *dir = d_inode(dentry);
        struct nfs_inode *nfsi = NFS_I(dir);
        struct nfs_unlinkdata *data;
 
@@ -367,8 +367,8 @@ static void nfs_async_rename_release(void *calldata)
        struct nfs_renamedata   *data = calldata;
        struct super_block *sb = data->old_dir->i_sb;
 
-       if (data->old_dentry->d_inode)
-               nfs_mark_for_revalidate(data->old_dentry->d_inode);
+       if (d_really_is_positive(data->old_dentry))
+               nfs_mark_for_revalidate(d_inode(data->old_dentry));
 
        dput(data->old_dentry);
        dput(data->new_dentry);
@@ -529,10 +529,10 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
        if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
                goto out;
 
-       fileid = NFS_FILEID(dentry->d_inode);
+       fileid = NFS_FILEID(d_inode(dentry));
 
        /* Return delegation in anticipation of the rename */
-       NFS_PROTO(dentry->d_inode)->return_delegation(dentry->d_inode);
+       NFS_PROTO(d_inode(dentry))->return_delegation(d_inode(dentry));
 
        sdentry = NULL;
        do {
@@ -554,7 +554,7 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
                 */
                if (IS_ERR(sdentry))
                        goto out;
-       } while (sdentry->d_inode != NULL); /* need negative lookup */
+       } while (d_inode(sdentry) != NULL); /* need negative lookup */
 
        /* queue unlink first. Can't do this from rpc_release as it
         * has to allocate memory
index 849ed784d6ac1fc6b923c32278e089f87575b8db..e8f675d4b2fb30a9db9864f504b0a88f7c0897db 100644 (file)
@@ -702,7 +702,7 @@ static void nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
  */
 static void nfs_inode_remove_request(struct nfs_page *req)
 {
-       struct inode *inode = req->wb_context->dentry->d_inode;
+       struct inode *inode = d_inode(req->wb_context->dentry);
        struct nfs_inode *nfsi = NFS_I(inode);
        struct nfs_page *head;
 
@@ -861,7 +861,7 @@ static void
 nfs_clear_request_commit(struct nfs_page *req)
 {
        if (test_bit(PG_CLEAN, &req->wb_flags)) {
-               struct inode *inode = req->wb_context->dentry->d_inode;
+               struct inode *inode = d_inode(req->wb_context->dentry);
                struct nfs_commit_info cinfo;
 
                nfs_init_cinfo_from_inode(&cinfo, inode);
@@ -1591,7 +1591,7 @@ void nfs_init_commit(struct nfs_commit_data *data,
                     struct nfs_commit_info *cinfo)
 {
        struct nfs_page *first = nfs_list_entry(head->next);
-       struct inode *inode = first->wb_context->dentry->d_inode;
+       struct inode *inode = d_inode(first->wb_context->dentry);
 
        /* Set up the RPC argument and reply structs
         * NB: take care not to mess about with data->commit et al. */
@@ -1690,7 +1690,7 @@ static void nfs_commit_release_pages(struct nfs_commit_data *data)
 
                dprintk("NFS:       commit (%s/%llu %d@%lld)",
                        req->wb_context->dentry->d_sb->s_id,
-                       (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                       (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
                        req->wb_bytes,
                        (long long)req_offset(req));
                if (status < 0) {
index c3e3b6e55ae28d01ee4922b98b021dfd45151e02..77c4c723534cd54413da54aa8e6ddca17e5cf5a2 100644 (file)
@@ -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;
@@ -891,7 +891,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,
index ac54ea60b3f690c1803a3abd91b38d1250a06f54..d54701f6dc7873440b2c11d375b96323484ba259 100644 (file)
@@ -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);
index 34cbbab6abd76ff4ec08a46aec25616516fda556..882b1a14bc3e85961fbd628009c7618b13263a88 100644 (file)
@@ -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;
index 12f2aab4f614deb86d5a4e9d4edbc4a8da5ee869..7b755b7f785ceb4deff9fd9a5fbafccef15efa3f 100644 (file)
@@ -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) {
index 39c5eb3ad33ad76be9d92302bf6bfadb308dbab4..e4b2b4322553d05e44d17719f33ab3938b57c0d1 100644 (file)
@@ -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:
index 59fd7665178146c6dc188651f8a7eca96d3489aa..64466dcc71d173c94aed7f5edf9983647b9f9772 100644 (file)
@@ -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;
@@ -828,7 +828,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;
index 92b9d97aff4f1adfe24ed607d11661196a500ffc..000f962d15f18f5e12724e27889c7b6e80149167 100644 (file)
@@ -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
@@ -1308,7 +1308,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;
@@ -1342,7 +1342,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) {
index 1c307f02baa89e79f0a6d2889631d3ef50ed0a48..d88ea7b9a85cbf4557d7689872150d08d33e4e64 100644 (file)
@@ -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);
index 8ba1d888f1e624d672453bd1eea20c40e054f746..7e08aabd56e54dd962258dc2f7e6a857e99c2f02 100644 (file)
@@ -4473,7 +4473,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;
@@ -5169,7 +5169,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;
 
index 5fb7e78169a6b27a1a5a4d5e9ec354c9e32f6c43..ff9be0743b88794ef1dbf12ec84fd3ee2ef837be 100644 (file)
@@ -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);
index e9fa966fc37fe5415f9fba50b61b37d459172303..350041a40fe519ac22fa14901c84a6dfddcec9c1 100644 (file)
@@ -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);
index f2292044217225391aa45f8f83b87ea2942bddd0..1e90dad4926b4aa2e5158d5d0e7acb7c26d73472 100644 (file)
@@ -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;
        }
 }
index b8680738f5884e7ee94d46c95c89ff68faa9a95f..aecbcd34d3360fb1c6e925ce317ee14f7c48224c 100644 (file)
@@ -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) {
index 412d7061f9e5ec764cade00584ac87308b7caf3d..79d964aa8079f354fcadf50ac2a1d3d216668d4a 100644 (file)
@@ -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);
index 36852658242943051f1a1cac7d4b6a8c1945f84c..84d770be056ee7b1a4db58e3ca0acb648b91a18d 100644 (file)
@@ -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)
index 0bda93e58e1b786a9426bb68fabe4c869090922d..056f23a78ffd4cff7bc3fa776e861521da35dd4f 100644 (file)
@@ -632,7 +632,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;
index 197a63e9d10215b54e28179b7976e6c0b56b5384..0ee0bed3649baf1f8974c15e42916294ab55ff6c 100644 (file)
@@ -435,7 +435,7 @@ void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
  */
 int nilfs_add_link(struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const unsigned char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        unsigned chunk_size = nilfs_chunk_size(dir);
index 36f057fa8aa3be305ec0bb155a2924e8a9088957..310d87c51b401a0c14d26757b436715bc9ad23ed 100644 (file)
@@ -834,7 +834,7 @@ void nilfs_evict_inode(struct inode *inode)
 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
        struct nilfs_transaction_info ti;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = inode->i_sb;
        int err;
 
index 0f84b257932c2351569db8fc87432dfb9bcfebe9..22180836ec2201c0687c1faeb0ccc59315c2d6dd 100644 (file)
@@ -192,7 +192,7 @@ out_fail:
 static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
                      struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct nilfs_transaction_info ti;
        int err;
 
@@ -283,7 +283,7 @@ static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
        if (!de)
                goto out;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        err = -EIO;
        if (le64_to_cpu(de->inode) != inode->i_ino)
                goto out;
@@ -318,7 +318,7 @@ static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
 
        if (!err) {
                nilfs_mark_inode_dirty(dir);
-               nilfs_mark_inode_dirty(dentry->d_inode);
+               nilfs_mark_inode_dirty(d_inode(dentry));
                err = nilfs_transaction_commit(dir->i_sb);
        } else
                nilfs_transaction_abort(dir->i_sb);
@@ -328,7 +328,7 @@ static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
 
 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct nilfs_transaction_info ti;
        int err;
 
@@ -358,8 +358,8 @@ static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir,  struct dentry *new_dentry)
 {
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct page *dir_page = NULL;
        struct nilfs_dir_entry *dir_de = NULL;
        struct page *old_page;
@@ -453,13 +453,13 @@ static struct dentry *nilfs_get_parent(struct dentry *child)
        struct qstr dotdot = QSTR_INIT("..", 2);
        struct nilfs_root *root;
 
-       ino = nilfs_inode_by_name(child->d_inode, &dotdot);
+       ino = nilfs_inode_by_name(d_inode(child), &dotdot);
        if (!ino)
                return ERR_PTR(-ENOENT);
 
-       root = NILFS_I(child->d_inode)->i_root;
+       root = NILFS_I(d_inode(child))->i_root;
 
-       inode = nilfs_iget(child->d_inode->i_sb, root, ino);
+       inode = nilfs_iget(d_inode(child)->i_sb, root, ino);
        if (IS_ERR(inode))
                return ERR_CAST(inode);
 
index 5bc2a1cf73c35311013a3e97636f5366ee131a8e..282fb1037823365e0c62fa758ce0152a96f91096 100644 (file)
@@ -610,7 +610,7 @@ static int nilfs_unfreeze(struct super_block *sb)
 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct super_block *sb = dentry->d_sb;
-       struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root;
+       struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;
        struct the_nilfs *nilfs = root->nilfs;
        u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
        unsigned long long blocks;
@@ -681,7 +681,7 @@ static int nilfs_show_options(struct seq_file *seq, struct dentry *dentry)
 {
        struct super_block *sb = dentry->d_sb;
        struct the_nilfs *nilfs = sb->s_fs_info;
-       struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root;
+       struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;
 
        if (!nilfs_test_opt(nilfs, BARRIER))
                seq_puts(seq, ",nobarrier");
@@ -1190,7 +1190,7 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data)
 
                sb->s_flags &= ~MS_RDONLY;
 
-               root = NILFS_I(sb->s_root->d_inode)->i_root;
+               root = NILFS_I(d_inode(sb->s_root))->i_root;
                err = nilfs_attach_log_writer(sb, root);
                if (err)
                        goto restore_opts;
index 1d0c21df0d805cd73248afd42dc05c1108c49700..d284f07eda7754e721bfd2782ba410f04ae145e4 100644 (file)
@@ -2889,7 +2889,7 @@ void ntfs_truncate_vfs(struct inode *vi) {
  */
 int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *vi = dentry->d_inode;
+       struct inode *vi = d_inode(dentry);
        int err;
        unsigned int ia_valid = attr->ia_valid;
 
index b3973c2fd19007e01bc7260a72b43e769849dd75..0f35b80d17fe019cdae356ecaba8359ac9f9a9a2 100644 (file)
@@ -292,14 +292,14 @@ const struct inode_operations ntfs_dir_inode_ops = {
  * The code is based on the ext3 ->get_parent() implementation found in
  * fs/ext3/namei.c::ext3_get_parent().
  *
- * Note: ntfs_get_parent() is called with @child_dent->d_inode->i_mutex down.
+ * Note: ntfs_get_parent() is called with @d_inode(child_dent)->i_mutex down.
  *
  * Return the dentry of the parent directory on success or the error code on
  * error (IS_ERR() is true).
  */
 static struct dentry *ntfs_get_parent(struct dentry *child_dent)
 {
-       struct inode *vi = child_dent->d_inode;
+       struct inode *vi = d_inode(child_dent);
        ntfs_inode *ni = NTFS_I(vi);
        MFT_RECORD *mrec;
        ntfs_attr_search_ctx *ctx;
index 4fda7a5f3088a7144240193508369ba259875a72..290373024d9d6798ce761a2c89aba0892bde4db7 100644 (file)
@@ -42,8 +42,8 @@
 void ocfs2_dentry_attach_gen(struct dentry *dentry)
 {
        unsigned long gen =
-               OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen;
-       BUG_ON(dentry->d_inode);
+               OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;
+       BUG_ON(d_inode(dentry));
        dentry->d_fsdata = (void *)gen;
 }
 
@@ -57,7 +57,7 @@ static int ocfs2_dentry_revalidate(struct dentry *dentry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        osb = OCFS2_SB(dentry->d_sb);
 
        trace_ocfs2_dentry_revalidate(dentry, dentry->d_name.len,
@@ -71,7 +71,7 @@ static int ocfs2_dentry_revalidate(struct dentry *dentry, unsigned int flags)
                unsigned long gen = (unsigned long) dentry->d_fsdata;
                unsigned long pgen;
                spin_lock(&dentry->d_lock);
-               pgen = OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen;
+               pgen = OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;
                spin_unlock(&dentry->d_lock);
                trace_ocfs2_dentry_revalidate_negative(dentry->d_name.len,
                                                       dentry->d_name.name,
@@ -146,7 +146,7 @@ static int ocfs2_match_dentry(struct dentry *dentry,
        if (skip_unhashed && d_unhashed(dentry))
                return 0;
 
-       parent = dentry->d_parent->d_inode;
+       parent = d_inode(dentry->d_parent);
        /* Negative parent dentry? */
        if (!parent)
                return 0;
@@ -243,7 +243,7 @@ int ocfs2_dentry_attach_lock(struct dentry *dentry,
        if (!inode)
                return 0;
 
-       if (!dentry->d_inode && dentry->d_fsdata) {
+       if (d_really_is_negative(dentry) && dentry->d_fsdata) {
                /* Converting a negative dentry to positive
                   Clear dentry->d_fsdata */
                dentry->d_fsdata = dl = NULL;
@@ -446,7 +446,7 @@ void ocfs2_dentry_move(struct dentry *dentry, struct dentry *target,
 {
        int ret;
        struct ocfs2_super *osb = OCFS2_SB(old_dir->i_sb);
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        /*
         * Move within the same directory, so the actual lock info won't
index f0344b75b14d26631993f260bc2e9f8aa9204892..3d8639f3897377dea5649155cfa6cfcb484a9195 100644 (file)
@@ -72,7 +72,7 @@ static inline int ocfs2_add_entry(handle_t *handle,
                                  struct buffer_head *parent_fe_bh,
                                  struct ocfs2_dir_lookup_result *lookup)
 {
-       return __ocfs2_add_entry(handle, dentry->d_parent->d_inode,
+       return __ocfs2_add_entry(handle, d_inode(dentry->d_parent),
                                 dentry->d_name.name, dentry->d_name.len,
                                 inode, blkno, parent_fe_bh, lookup);
 }
index 061ba6a91bf2faa66ef1ea3ad797e47e202deeb7..b5cf27dcb18a78c71c3ef62410c3e4e7e7e641f9 100644 (file)
@@ -208,7 +208,7 @@ static int dlmfs_file_release(struct inode *inode,
 static int dlmfs_file_setattr(struct dentry *dentry, struct iattr *attr)
 {
        int error;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        attr->ia_valid &= ~ATTR_SIZE;
        error = inode_change_ok(inode, attr);
@@ -549,7 +549,7 @@ static int dlmfs_unlink(struct inode *dir,
                        struct dentry *dentry)
 {
        int status;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        mlog(0, "unlink inode %lu\n", inode->i_ino);
 
index 29651167190dd15032a5aaa71d2fe066a7bbab97..facf456c481ad5e664692165d8dcbb5bf70bada0 100644 (file)
@@ -147,7 +147,7 @@ static struct dentry *ocfs2_get_parent(struct dentry *child)
        int status;
        u64 blkno;
        struct dentry *parent;
-       struct inode *dir = child->d_inode;
+       struct inode *dir = d_inode(child);
 
        trace_ocfs2_get_parent(child, child->d_name.len, child->d_name.name,
                               (unsigned long long)OCFS2_I(dir)->ip_blkno);
index 913fc250d85a178b569f4d8ddd31b96a539208e0..d8b670cbd909292a6da33e5b16d3c16467727cb3 100644 (file)
@@ -1126,7 +1126,7 @@ out:
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
        int status = 0, size_change;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct super_block *sb = inode->i_sb;
        struct ocfs2_super *osb = OCFS2_SB(sb);
        struct buffer_head *bh = NULL;
@@ -1275,8 +1275,8 @@ int ocfs2_getattr(struct vfsmount *mnt,
                  struct dentry *dentry,
                  struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
-       struct super_block *sb = dentry->d_inode->i_sb;
+       struct inode *inode = d_inode(dentry);
+       struct super_block *sb = d_inode(dentry)->i_sb;
        struct ocfs2_super *osb = sb->s_fs_info;
        int err;
 
@@ -2114,7 +2114,7 @@ static int ocfs2_prepare_inode_for_write(struct file *file,
 {
        int ret = 0, meta_level = 0;
        struct dentry *dentry = file->f_path.dentry;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        loff_t end;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        int full_coherency = !(osb->s_mount_opt &
index 3025c0da6b8abd6358a60581087a257dd4f24e6f..751736109489c0fe0f25e389290b0d2e70bfaf2a 100644 (file)
@@ -1209,7 +1209,7 @@ int ocfs2_drop_inode(struct inode *inode)
  */
 int ocfs2_inode_revalidate(struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int status = 0;
 
        trace_ocfs2_inode_revalidate(inode,
index b5c3a5ea3ee60e264cf7523e8626ac3b61f9421b..c0727037c6f9be41d984fc4dd723a0e8fafff218 100644 (file)
@@ -689,8 +689,8 @@ static int ocfs2_link(struct dentry *old_dentry,
                      struct dentry *dentry)
 {
        handle_t *handle;
-       struct inode *inode = old_dentry->d_inode;
-       struct inode *old_dir = old_dentry->d_parent->d_inode;
+       struct inode *inode = d_inode(old_dentry);
+       struct inode *old_dir = d_inode(old_dentry->d_parent);
        int err;
        struct buffer_head *fe_bh = NULL;
        struct buffer_head *old_dir_bh = NULL;
@@ -879,7 +879,7 @@ static int ocfs2_unlink(struct inode *dir,
        int status;
        int child_locked = 0;
        bool is_unlinkable = false;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct inode *orphan_dir = NULL;
        struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
        u64 blkno;
@@ -898,7 +898,7 @@ static int ocfs2_unlink(struct inode *dir,
 
        dquot_initialize(dir);
 
-       BUG_ON(dentry->d_parent->d_inode != dir);
+       BUG_ON(d_inode(dentry->d_parent) != dir);
 
        if (inode == osb->root_inode)
                return -EPERM;
@@ -1209,8 +1209,8 @@ static int ocfs2_rename(struct inode *old_dir,
 {
        int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
        int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct inode *orphan_dir = NULL;
        struct ocfs2_dinode *newfe = NULL;
        char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
@@ -1454,7 +1454,7 @@ static int ocfs2_rename(struct inode *old_dir,
                        should_add_orphan = true;
                }
        } else {
-               BUG_ON(new_dentry->d_parent->d_inode != new_dir);
+               BUG_ON(d_inode(new_dentry->d_parent) != new_dir);
 
                status = ocfs2_check_dir_for_entry(new_dir,
                                                   new_dentry->d_name.name,
index ee541f92dab40308352f22cc5794056d44beb432..2dc801255c4d37cb28456d634599f3b93f112dab 100644 (file)
@@ -4194,7 +4194,7 @@ static int __ocfs2_reflink(struct dentry *old_dentry,
                           bool preserve)
 {
        int ret;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct buffer_head *new_bh = NULL;
 
        if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
@@ -4263,7 +4263,7 @@ static int ocfs2_reflink(struct dentry *old_dentry, struct inode *dir,
                         struct dentry *new_dentry, bool preserve)
 {
        int error;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct buffer_head *old_bh = NULL;
        struct inode *new_orphan_inode = NULL;
        struct posix_acl *default_acl, *acl;
@@ -4357,7 +4357,7 @@ out:
 /* copied from may_create in VFS. */
 static inline int ocfs2_may_create(struct inode *dir, struct dentry *child)
 {
-       if (child->d_inode)
+       if (d_really_is_positive(child))
                return -EEXIST;
        if (IS_DEADDIR(dir))
                return -ENOENT;
@@ -4375,7 +4375,7 @@ static inline int ocfs2_may_create(struct inode *dir, struct dentry *child)
 static int ocfs2_vfs_reflink(struct dentry *old_dentry, struct inode *dir,
                             struct dentry *new_dentry, bool preserve)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        int error;
 
        if (!inode)
@@ -4463,7 +4463,7 @@ int ocfs2_reflink_ioctl(struct inode *inode,
        }
 
        error = ocfs2_vfs_reflink(old_path.dentry,
-                                 new_path.dentry->d_inode,
+                                 d_inode(new_path.dentry),
                                  new_dentry, preserve);
 out_dput:
        done_path_create(&new_path, new_dentry);
index 85b190dc132f3a3cc52dc19eb5a31ab094060aef..4bbeb90863b76aab5d3a4f84c3110bcbc3e19ba5 100644 (file)
@@ -1020,7 +1020,7 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
        int ret = 0, i_ret = 0, b_ret = 0;
        struct buffer_head *di_bh = NULL;
        struct ocfs2_dinode *di = NULL;
-       struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode);
+       struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry));
 
        if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb)))
                return -EOPNOTSUPP;
@@ -1028,7 +1028,7 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
        if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
                return ret;
 
-       ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0);
+       ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
@@ -1037,7 +1037,7 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
        di = (struct ocfs2_dinode *)di_bh->b_data;
 
        down_read(&oi->ip_xattr_sem);
-       i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size);
+       i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size);
        if (i_ret < 0)
                b_ret = 0;
        else {
@@ -1045,13 +1045,13 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
                        buffer += i_ret;
                        size -= i_ret;
                }
-               b_ret = ocfs2_xattr_block_list(dentry->d_inode, di,
+               b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,
                                               buffer, size);
                if (b_ret < 0)
                        i_ret = 0;
        }
        up_read(&oi->ip_xattr_sem);
-       ocfs2_inode_unlock(dentry->d_inode, 0);
+       ocfs2_inode_unlock(d_inode(dentry), 0);
 
        brelse(di_bh);
 
@@ -7249,7 +7249,7 @@ static int ocfs2_xattr_security_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
+       return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
                               name, buffer, size);
 }
 
@@ -7259,7 +7259,7 @@ static int ocfs2_xattr_security_set(struct dentry *dentry, const char *name,
        if (strcmp(name, "") == 0)
                return -EINVAL;
 
-       return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
+       return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
                               name, value, size, flags);
 }
 
@@ -7339,7 +7339,7 @@ static int ocfs2_xattr_trusted_get(struct dentry *dentry, const char *name,
 {
        if (strcmp(name, "") == 0)
                return -EINVAL;
-       return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
+       return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
                               name, buffer, size);
 }
 
@@ -7349,7 +7349,7 @@ static int ocfs2_xattr_trusted_set(struct dentry *dentry, const char *name,
        if (strcmp(name, "") == 0)
                return -EINVAL;
 
-       return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
+       return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
                               name, value, size, flags);
 }
 
@@ -7391,7 +7391,7 @@ static int ocfs2_xattr_user_get(struct dentry *dentry, const char *name,
                return -EINVAL;
        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                return -EOPNOTSUPP;
-       return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_USER, name,
+       return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_USER, name,
                               buffer, size);
 }
 
@@ -7405,7 +7405,7 @@ static int ocfs2_xattr_user_set(struct dentry *dentry, const char *name,
        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                return -EOPNOTSUPP;
 
-       return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_USER,
+       return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_USER,
                               name, value, size, flags);
 }
 
index 1b8e9e8405b230169318a1d60df41c5b0b4f502d..f833bf8d5792928ff9cecacfe83f1efd3300df68 100644 (file)
@@ -110,7 +110,7 @@ int omfs_make_empty(struct inode *inode, struct super_block *sb)
 
 static int omfs_add_link(struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        struct omfs_inode *oi;
@@ -155,7 +155,7 @@ out:
 
 static int omfs_delete_entry(struct dentry *dentry)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        struct inode *dirty;
        const char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
@@ -237,7 +237,7 @@ static int omfs_dir_is_empty(struct inode *inode)
 
 static int omfs_remove(struct inode *dir, struct dentry *dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int ret;
 
 
@@ -373,8 +373,8 @@ static bool omfs_fill_chain(struct inode *dir, struct dir_context *ctx,
 static int omfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                struct inode *new_dir, struct dentry *new_dentry)
 {
-       struct inode *new_inode = new_dentry->d_inode;
-       struct inode *old_inode = old_dentry->d_inode;
+       struct inode *new_inode = d_inode(new_dentry);
+       struct inode *old_inode = d_inode(old_dentry);
        int err;
 
        if (new_inode) {
index f993be7f2156fcd863fcc28261add1326efd0146..d9e26cfbb793113f15b73bde769e49b69932bc9c 100644 (file)
@@ -346,7 +346,7 @@ const struct file_operations omfs_file_operations = {
 
 static int omfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        error = inode_change_ok(inode, attr);
index 3f3d7aeb071257a15afaa9a65f88642e307f80f3..a3d6b559178b5163c288394092c7b3ad317ae3d1 100644 (file)
@@ -169,7 +169,7 @@ static int get_task_root(struct task_struct *task, struct path *root)
 
 static int proc_cwd_link(struct dentry *dentry, struct path *path)
 {
-       struct task_struct *task = get_proc_task(dentry->d_inode);
+       struct task_struct *task = get_proc_task(d_inode(dentry));
        int result = -ENOENT;
 
        if (task) {
@@ -186,7 +186,7 @@ static int proc_cwd_link(struct dentry *dentry, struct path *path)
 
 static int proc_root_link(struct dentry *dentry, struct path *path)
 {
-       struct task_struct *task = get_proc_task(dentry->d_inode);
+       struct task_struct *task = get_proc_task(d_inode(dentry));
        int result = -ENOENT;
 
        if (task) {
@@ -505,7 +505,7 @@ static int proc_fd_access_allowed(struct inode *inode)
 int proc_setattr(struct dentry *dentry, struct iattr *attr)
 {
        int error;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
 
        if (attr->ia_valid & ATTR_MODE)
                return -EPERM;
@@ -1353,7 +1353,7 @@ static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
        struct mm_struct *mm;
        struct file *exe_file;
 
-       task = get_proc_task(dentry->d_inode);
+       task = get_proc_task(d_inode(dentry));
        if (!task)
                return -ENOENT;
        mm = get_task_mm(task);
@@ -1373,7 +1373,7 @@ static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
 
 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct path path;
        int error = -EACCES;
 
@@ -1418,7 +1418,7 @@ static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
 static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
 {
        int error = -EACCES;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct path path;
 
        /* Are we allowed to snoop on the tasks file descriptors? */
@@ -1488,7 +1488,7 @@ out_unlock:
 
 int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct task_struct *task;
        const struct cred *cred;
        struct pid_namespace *pid = dentry->d_sb->s_fs_info;
@@ -1545,7 +1545,7 @@ int pid_revalidate(struct dentry *dentry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        task = get_proc_task(inode);
 
        if (task) {
@@ -1579,7 +1579,7 @@ int pid_delete_dentry(const struct dentry *dentry)
         * If so, then don't put the dentry on the lru list,
         * kill it immediately.
         */
-       return proc_inode_is_dead(dentry->d_inode);
+       return proc_inode_is_dead(d_inode(dentry));
 }
 
 const struct dentry_operations pid_dentry_operations =
@@ -1617,12 +1617,12 @@ bool proc_fill_cache(struct file *file, struct dir_context *ctx,
                child = d_alloc(dir, &qname);
                if (!child)
                        goto end_instantiate;
-               if (instantiate(dir->d_inode, child, task, ptr) < 0) {
+               if (instantiate(d_inode(dir), child, task, ptr) < 0) {
                        dput(child);
                        goto end_instantiate;
                }
        }
-       inode = child->d_inode;
+       inode = d_inode(child);
        ino = inode->i_ino;
        type = inode->i_mode >> 12;
        dput(child);
@@ -1665,7 +1665,7 @@ static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
                goto out_notask;
        }
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        task = get_proc_task(inode);
        if (!task)
                goto out_notask;
@@ -1718,7 +1718,7 @@ static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
        int rc;
 
        rc = -ENOENT;
-       task = get_proc_task(dentry->d_inode);
+       task = get_proc_task(d_inode(dentry));
        if (!task)
                goto out;
 
@@ -2851,13 +2851,13 @@ int proc_pid_readdir(struct file *file, struct dir_context *ctx)
                return 0;
 
        if (pos == TGID_OFFSET - 2) {
-               struct inode *inode = ns->proc_self->d_inode;
+               struct inode *inode = d_inode(ns->proc_self);
                if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
                        return 0;
                ctx->pos = pos = pos + 1;
        }
        if (pos == TGID_OFFSET - 1) {
-               struct inode *inode = ns->proc_thread_self->d_inode;
+               struct inode *inode = d_inode(ns->proc_thread_self);
                if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK))
                        return 0;
                ctx->pos = pos = pos + 1;
@@ -3176,7 +3176,7 @@ static int proc_task_readdir(struct file *file, struct dir_context *ctx)
 
 static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct task_struct *p = get_proc_task(inode);
        generic_fillattr(inode, stat);
 
index 8e5ad83b629aad2ebe8f1d1bc01c764147f69be1..a205904a27ae12cf113f9fe7a1b220c2f0061879 100644 (file)
@@ -84,7 +84,7 @@ static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
        if (flags & LOOKUP_RCU)
                return -ECHILD;
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
        task = get_proc_task(inode);
        fd = proc_fd(inode);
 
@@ -144,14 +144,14 @@ static int proc_fd_link(struct dentry *dentry, struct path *path)
        struct task_struct *task;
        int ret = -ENOENT;
 
-       task = get_proc_task(dentry->d_inode);
+       task = get_proc_task(d_inode(dentry));
        if (task) {
                files = get_files_struct(task);
                put_task_struct(task);
        }
 
        if (files) {
-               int fd = proc_fd(dentry->d_inode);
+               int fd = proc_fd(d_inode(dentry));
                struct file *fd_file;
 
                spin_lock(&files->file_lock);
index be65b208213518f267d9fe16b5652b5021700cf5..df6327a2b86507b371608a752f65bf12241bf38c 100644 (file)
@@ -101,7 +101,7 @@ static bool pde_subdir_insert(struct proc_dir_entry *dir,
 
 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct proc_dir_entry *de = PDE(inode);
        int error;
 
@@ -120,7 +120,7 @@ static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
                        struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct proc_dir_entry *de = PDE(inode);
        if (de && de->nlink)
                set_nlink(inode, de->nlink);
index 7697b6621cfd5b13051318ba15920646942ed528..8272aaba1bb06fd4b65416979155f18b590291a4 100644 (file)
@@ -396,7 +396,7 @@ static const struct file_operations proc_reg_file_ops_no_compat = {
 
 static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct proc_dir_entry *pde = PDE(dentry->d_inode);
+       struct proc_dir_entry *pde = PDE(d_inode(dentry));
        if (unlikely(!use_pde(pde)))
                return ERR_PTR(-EINVAL);
        nd_set_link(nd, pde->data);
index c9eac4563fa8ab497dfbc492d4d63f2c6105df9b..e512642dbbdcb3cfe37f97b586770d695e2a755f 100644 (file)
@@ -32,7 +32,7 @@ static const struct proc_ns_operations *ns_entries[] = {
 
 static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
        struct task_struct *task;
        struct path ns_path;
@@ -53,7 +53,7 @@ static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
 
 static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
        struct task_struct *task;
        char name[50];
index 1bde894bc6248f4c8eba370ae062fa6115e6a492..350984a19c83440e09b6b1dafd87dc150dd078da 100644 (file)
@@ -142,7 +142,7 @@ static struct dentry *proc_tgid_net_lookup(struct inode *dir,
 static int proc_tgid_net_getattr(struct vfsmount *mnt, struct dentry *dentry,
                struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct net *net;
 
        net = get_proc_task_net(inode);
index f92d5dd578a4a5289aab9e29dcd37b09ee775c46..fea2561d773bbce01c9858f91ec5fec58f9f7481 100644 (file)
@@ -604,7 +604,7 @@ static bool proc_sys_fill_cache(struct file *file,
                        return false;
                }
        }
-       inode = child->d_inode;
+       inode = d_inode(child);
        ino  = inode->i_ino;
        type = inode->i_mode >> 12;
        dput(child);
@@ -710,7 +710,7 @@ static int proc_sys_permission(struct inode *inode, int mask)
 
 static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
@@ -727,7 +727,7 @@ static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
 
 static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ctl_table_header *head = grab_header(inode);
        struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 
@@ -773,12 +773,12 @@ static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
 {
        if (flags & LOOKUP_RCU)
                return -ECHILD;
-       return !PROC_I(dentry->d_inode)->sysctl->unregistering;
+       return !PROC_I(d_inode(dentry))->sysctl->unregistering;
 }
 
 static int proc_sys_delete(const struct dentry *dentry)
 {
-       return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
+       return !!PROC_I(d_inode(dentry))->sysctl->unregistering;
 }
 
 static int sysctl_is_seen(struct ctl_table_header *p)
@@ -805,7 +805,7 @@ static int proc_sys_compare(const struct dentry *parent, const struct dentry *de
        /* Although proc doesn't have negative dentries, rcu-walk means
         * that inode here can be NULL */
        /* AV: can it, indeed? */
-       inode = ACCESS_ONCE(dentry->d_inode);
+       inode = d_inode_rcu(dentry);
        if (!inode)
                return 1;
        if (name->len != len)
index e74ac9f1a2c09cdec0621b244b0d9abc8de44699..b7fa4bfe896a2c17f05dd97add756bed889fd2b6 100644 (file)
@@ -195,7 +195,7 @@ void __init proc_root_init(void)
 static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat
 )
 {
-       generic_fillattr(dentry->d_inode, stat);
+       generic_fillattr(d_inode(dentry), stat);
        stat->nlink = proc_root.nlink + nr_processes();
        return 0;
 }
index 4348bb8907c20a6abc211b9fa944eca005d6f47c..6195b4a7c3b17f8c7feb09542e7e435b2cd59356 100644 (file)
@@ -46,7 +46,7 @@ static unsigned self_inum;
 
 int proc_setup_self(struct super_block *s)
 {
-       struct inode *root_inode = s->s_root->d_inode;
+       struct inode *root_inode = d_inode(s->s_root);
        struct pid_namespace *ns = s->s_fs_info;
        struct dentry *self;
        
index 59075b509df31df6777ee7c22928b976e0801418..a8371993b4fb7822b865cd4b2a02bc63d9642fa7 100644 (file)
@@ -47,7 +47,7 @@ static unsigned thread_self_inum;
 
 int proc_setup_thread_self(struct super_block *s)
 {
-       struct inode *root_inode = s->s_root->d_inode;
+       struct inode *root_inode = d_inode(s->s_root);
        struct pid_namespace *ns = s->s_fs_info;
        struct dentry *thread_self;
 
index b32ce53d24ee5d7e07af71ee35873b5f7cb27ad4..9f73797f95a6c89222b55a3419931b6f8209782d 100644 (file)
@@ -190,7 +190,7 @@ static const struct file_operations pstore_file_operations = {
  */
 static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct pstore_private *p = dentry->d_inode->i_private;
+       struct pstore_private *p = d_inode(dentry)->i_private;
        int err;
 
        err = pstore_check_syslog_permissions(p);
@@ -199,7 +199,7 @@ static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 
        if (p->psi->erase)
                p->psi->erase(p->type, p->id, p->count,
-                             dentry->d_inode->i_ctime, p->psi);
+                             d_inode(dentry)->i_ctime, p->psi);
        else
                return -EPERM;
 
@@ -373,7 +373,7 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
                break;
        }
 
-       mutex_lock(&root->d_inode->i_mutex);
+       mutex_lock(&d_inode(root)->i_mutex);
 
        dentry = d_alloc_name(root, name);
        if (!dentry)
@@ -393,12 +393,12 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
        list_add(&private->list, &allpstore);
        spin_unlock_irqrestore(&allpstore_lock, flags);
 
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
 
        return 0;
 
 fail_lockedalloc:
-       mutex_unlock(&root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(root)->i_mutex);
        kfree(private);
 fail_alloc:
        iput(inode);
index 44e73923670d59a0c7663804d8710fb3262c6106..32d2e1a9774ca66005d92786df99a70865efb3fa 100644 (file)
@@ -182,7 +182,7 @@ static const char *qnx6_checkroot(struct super_block *s)
        static char match_root[2][3] = {".\0\0", "..\0"};
        int i, error = 0;
        struct qnx6_dir_entry *dir_entry;
-       struct inode *root = s->s_root->d_inode;
+       struct inode *root = d_inode(s->s_root);
        struct address_space *mapping = root->i_mapping;
        struct page *page = read_mapping_page(mapping, 0, NULL);
        if (IS_ERR(page))
index 0b38befa69f356b03b34175f9f629feaf4c8d0fa..ba1323a94924962299d27cbe67d76ff4e0056bb9 100644 (file)
@@ -163,7 +163,7 @@ static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size)
  */
 static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        unsigned int old_ia_valid = ia->ia_valid;
        int ret = 0;
 
index 0a7dc941aaf4dc7190b4ac3864765f6688b11683..4a024e2ceb9f76fbf9156d0dc84c3e09a4a1ff15 100644 (file)
@@ -53,8 +53,8 @@ static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
 static inline bool is_privroot_deh(struct inode *dir, struct reiserfs_de_head *deh)
 {
        struct dentry *privroot = REISERFS_SB(dir->i_sb)->priv_root;
-       return (privroot->d_inode &&
-               deh->deh_objectid == INODE_PKEY(privroot->d_inode)->k_objectid);
+       return (d_really_is_positive(privroot) &&
+               deh->deh_objectid == INODE_PKEY(d_inode(privroot))->k_objectid);
 }
 
 int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
index 742242b60972671c50926f9a0dd0db48c4e7aeca..f6f2fbad9777d3cc9fd50e9295973ed6f10577a2 100644 (file)
@@ -3308,7 +3308,7 @@ static ssize_t reiserfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 
 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        unsigned int ia_valid;
        int error;
 
index cd11358b10c7a1e427394f78ca8334e67f3c9467..b55a074653d7a4ae7722b1df6d31655566527734 100644 (file)
@@ -400,7 +400,7 @@ struct dentry *reiserfs_get_parent(struct dentry *child)
        struct inode *inode = NULL;
        struct reiserfs_dir_entry de;
        INITIALIZE_PATH(path_to_entry);
-       struct inode *dir = child->d_inode;
+       struct inode *dir = d_inode(child);
 
        if (dir->i_nlink == 0) {
                return ERR_PTR(-ENOENT);
@@ -917,7 +917,7 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
                goto end_rmdir;
        }
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);
@@ -987,7 +987,7 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
 
        dquot_initialize(dir);
 
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        /*
         * in this transaction we can be doing at max two balancings and
@@ -1174,7 +1174,7 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
                         struct dentry *dentry)
 {
        int retval;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct reiserfs_transaction_handle th;
        /*
         * We need blocks for transaction + update of quotas for
@@ -1311,8 +1311,8 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        dquot_initialize(old_dir);
        dquot_initialize(new_dir);
 
-       old_inode = old_dentry->d_inode;
-       new_dentry_inode = new_dentry->d_inode;
+       old_inode = d_inode(old_dentry);
+       new_dentry_inode = d_inode(new_dentry);
 
        /*
         * make sure that oldname still exists and points to an object we
index 71fbbe3e2dab310481ef97ca12885a4a2137e8cf..558ef2ce1bddaad0e4045ff49a28a2dcdd6e48ce 100644 (file)
@@ -1687,7 +1687,7 @@ static __u32 find_hash_out(struct super_block *s)
        __u32 hash = DEFAULT_HASH;
        __u32 deh_hashval, teahash, r5hash, yurahash;
 
-       inode = s->s_root->d_inode;
+       inode = d_inode(s->s_root);
 
        make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
        retval = search_by_entry_key(s, &key, &path, &de);
@@ -2347,7 +2347,7 @@ static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
                err = -EXDEV;
                goto out;
        }
-       inode = path->dentry->d_inode;
+       inode = d_inode(path->dentry);
        /*
         * We must not pack tails for quota files on reiserfs for quota
         * IO to work
index 4e781e697c90bce3b42f0e0097fe46965bbb5258..e87f9b52bf069af087979782767b6c3471689fd5 100644 (file)
@@ -87,9 +87,9 @@ static int xattr_unlink(struct inode *dir, struct dentry *dentry)
 
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
 
-       mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+       mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
        error = dir->i_op->unlink(dir, dentry);
-       mutex_unlock(&dentry->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dentry)->i_mutex);
 
        if (!error)
                d_delete(dentry);
@@ -102,11 +102,11 @@ static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
 
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
 
-       mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+       mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
        error = dir->i_op->rmdir(dir, dentry);
        if (!error)
-               dentry->d_inode->i_flags |= S_DEAD;
-       mutex_unlock(&dentry->d_inode->i_mutex);
+               d_inode(dentry)->i_flags |= S_DEAD;
+       mutex_unlock(&d_inode(dentry)->i_mutex);
        if (!error)
                d_delete(dentry);
 
@@ -120,26 +120,26 @@ static struct dentry *open_xa_root(struct super_block *sb, int flags)
        struct dentry *privroot = REISERFS_SB(sb)->priv_root;
        struct dentry *xaroot;
 
-       if (!privroot->d_inode)
+       if (d_really_is_negative(privroot))
                return ERR_PTR(-ENODATA);
 
-       mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR);
+       mutex_lock_nested(&d_inode(privroot)->i_mutex, I_MUTEX_XATTR);
 
        xaroot = dget(REISERFS_SB(sb)->xattr_root);
        if (!xaroot)
                xaroot = ERR_PTR(-ENODATA);
-       else if (!xaroot->d_inode) {
+       else if (d_really_is_negative(xaroot)) {
                int err = -ENODATA;
 
                if (xattr_may_create(flags))
-                       err = xattr_mkdir(privroot->d_inode, xaroot, 0700);
+                       err = xattr_mkdir(d_inode(privroot), xaroot, 0700);
                if (err) {
                        dput(xaroot);
                        xaroot = ERR_PTR(err);
                }
        }
 
-       mutex_unlock(&privroot->d_inode->i_mutex);
+       mutex_unlock(&d_inode(privroot)->i_mutex);
        return xaroot;
 }
 
@@ -156,21 +156,21 @@ static struct dentry *open_xa_dir(const struct inode *inode, int flags)
                 le32_to_cpu(INODE_PKEY(inode)->k_objectid),
                 inode->i_generation);
 
-       mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR);
+       mutex_lock_nested(&d_inode(xaroot)->i_mutex, I_MUTEX_XATTR);
 
        xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
-       if (!IS_ERR(xadir) && !xadir->d_inode) {
+       if (!IS_ERR(xadir) && d_really_is_negative(xadir)) {
                int err = -ENODATA;
 
                if (xattr_may_create(flags))
-                       err = xattr_mkdir(xaroot->d_inode, xadir, 0700);
+                       err = xattr_mkdir(d_inode(xaroot), xadir, 0700);
                if (err) {
                        dput(xadir);
                        xadir = ERR_PTR(err);
                }
        }
 
-       mutex_unlock(&xaroot->d_inode->i_mutex);
+       mutex_unlock(&d_inode(xaroot)->i_mutex);
        dput(xaroot);
        return xadir;
 }
@@ -195,7 +195,7 @@ fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
                container_of(ctx, struct reiserfs_dentry_buf, ctx);
        struct dentry *dentry;
 
-       WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex));
+       WARN_ON_ONCE(!mutex_is_locked(&d_inode(dbuf->xadir)->i_mutex));
 
        if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
                return -ENOSPC;
@@ -207,7 +207,7 @@ fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
        dentry = lookup_one_len(name, dbuf->xadir, namelen);
        if (IS_ERR(dentry)) {
                return PTR_ERR(dentry);
-       } else if (!dentry->d_inode) {
+       } else if (d_really_is_negative(dentry)) {
                /* A directory entry exists, but no file? */
                reiserfs_error(dentry->d_sb, "xattr-20003",
                               "Corrupted directory: xattr %pd listed but "
@@ -249,16 +249,16 @@ static int reiserfs_for_each_xattr(struct inode *inode,
        if (IS_ERR(dir)) {
                err = PTR_ERR(dir);
                goto out;
-       } else if (!dir->d_inode) {
+       } else if (d_really_is_negative(dir)) {
                err = 0;
                goto out_dir;
        }
 
-       mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
+       mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR);
 
        buf.xadir = dir;
        while (1) {
-               err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
+               err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
                if (err)
                        break;
                if (!buf.count)
@@ -276,7 +276,7 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                        break;
                buf.count = 0;
        }
-       mutex_unlock(&dir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(dir)->i_mutex);
 
        cleanup_dentry_buf(&buf);
 
@@ -298,13 +298,13 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                if (!err) {
                        int jerror;
 
-                       mutex_lock_nested(&dir->d_parent->d_inode->i_mutex,
+                       mutex_lock_nested(&d_inode(dir->d_parent)->i_mutex,
                                          I_MUTEX_XATTR);
                        err = action(dir, data);
                        reiserfs_write_lock(inode->i_sb);
                        jerror = journal_end(&th);
                        reiserfs_write_unlock(inode->i_sb);
-                       mutex_unlock(&dir->d_parent->d_inode->i_mutex);
+                       mutex_unlock(&d_inode(dir->d_parent)->i_mutex);
                        err = jerror ?: err;
                }
        }
@@ -319,7 +319,7 @@ out:
 
 static int delete_one_xattr(struct dentry *dentry, void *data)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
 
        /* This is the xattr dir, handle specially. */
        if (d_is_dir(dentry))
@@ -384,27 +384,27 @@ static struct dentry *xattr_lookup(struct inode *inode, const char *name,
        if (IS_ERR(xadir))
                return ERR_CAST(xadir);
 
-       mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
+       mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR);
        xafile = lookup_one_len(name, xadir, strlen(name));
        if (IS_ERR(xafile)) {
                err = PTR_ERR(xafile);
                goto out;
        }
 
-       if (xafile->d_inode && (flags & XATTR_CREATE))
+       if (d_really_is_positive(xafile) && (flags & XATTR_CREATE))
                err = -EEXIST;
 
-       if (!xafile->d_inode) {
+       if (d_really_is_negative(xafile)) {
                err = -ENODATA;
                if (xattr_may_create(flags))
-                       err = xattr_create(xadir->d_inode, xafile,
+                       err = xattr_create(d_inode(xadir), xafile,
                                              0700|S_IFREG);
        }
 
        if (err)
                dput(xafile);
 out:
-       mutex_unlock(&xadir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(xadir)->i_mutex);
        dput(xadir);
        if (err)
                return ERR_PTR(err);
@@ -469,21 +469,21 @@ static int lookup_and_delete_xattr(struct inode *inode, const char *name)
        if (IS_ERR(xadir))
                return PTR_ERR(xadir);
 
-       mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
+       mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR);
        dentry = lookup_one_len(name, xadir, strlen(name));
        if (IS_ERR(dentry)) {
                err = PTR_ERR(dentry);
                goto out_dput;
        }
 
-       if (dentry->d_inode) {
-               err = xattr_unlink(xadir->d_inode, dentry);
+       if (d_really_is_positive(dentry)) {
+               err = xattr_unlink(d_inode(xadir), dentry);
                update_ctime(inode);
        }
 
        dput(dentry);
 out_dput:
-       mutex_unlock(&xadir->d_inode->i_mutex);
+       mutex_unlock(&d_inode(xadir)->i_mutex);
        dput(xadir);
        return err;
 }
@@ -533,7 +533,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
                else
                        chunk = buffer_size - buffer_pos;
 
-               page = reiserfs_get_page(dentry->d_inode, file_pos);
+               page = reiserfs_get_page(d_inode(dentry), file_pos);
                if (IS_ERR(page)) {
                        err = PTR_ERR(page);
                        goto out_unlock;
@@ -573,18 +573,18 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
        }
 
        new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
-       if (!err && new_size < i_size_read(dentry->d_inode)) {
+       if (!err && new_size < i_size_read(d_inode(dentry))) {
                struct iattr newattrs = {
                        .ia_ctime = current_fs_time(inode->i_sb),
                        .ia_size = new_size,
                        .ia_valid = ATTR_SIZE | ATTR_CTIME,
                };
 
-               mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
-               inode_dio_wait(dentry->d_inode);
+               mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_XATTR);
+               inode_dio_wait(d_inode(dentry));
 
                err = reiserfs_setattr(dentry, &newattrs);
-               mutex_unlock(&dentry->d_inode->i_mutex);
+               mutex_unlock(&d_inode(dentry)->i_mutex);
        } else
                update_ctime(inode);
 out_unlock:
@@ -657,7 +657,7 @@ reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
 
        down_read(&REISERFS_I(inode)->i_xattr_sem);
 
-       isize = i_size_read(dentry->d_inode);
+       isize = i_size_read(d_inode(dentry));
 
        /* Just return the size needed */
        if (buffer == NULL) {
@@ -680,7 +680,7 @@ reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
                else
                        chunk = isize - file_pos;
 
-               page = reiserfs_get_page(dentry->d_inode, file_pos);
+               page = reiserfs_get_page(d_inode(dentry), file_pos);
                if (IS_ERR(page)) {
                        err = PTR_ERR(page);
                        goto out_unlock;
@@ -775,7 +775,7 @@ reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
 
        handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
 
-       if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+       if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                return -EOPNOTSUPP;
 
        return handler->get(dentry, name, buffer, size, handler->flags);
@@ -784,7 +784,7 @@ reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
 /*
  * Inode operation setxattr()
  *
- * dentry->d_inode->i_mutex down
+ * d_inode(dentry)->i_mutex down
  */
 int
 reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
@@ -794,7 +794,7 @@ reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 
        handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
 
-       if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+       if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                return -EOPNOTSUPP;
 
        return handler->set(dentry, name, value, size, flags, handler->flags);
@@ -803,7 +803,7 @@ reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 /*
  * Inode operation removexattr()
  *
- * dentry->d_inode->i_mutex down
+ * d_inode(dentry)->i_mutex down
  */
 int reiserfs_removexattr(struct dentry *dentry, const char *name)
 {
@@ -811,7 +811,7 @@ int reiserfs_removexattr(struct dentry *dentry, const char *name)
 
        handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
 
-       if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+       if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                return -EOPNOTSUPP;
 
        return handler->set(dentry, name, NULL, 0, XATTR_REPLACE, handler->flags);
@@ -875,14 +875,14 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                .size = buffer ? size : 0,
        };
 
-       if (!dentry->d_inode)
+       if (d_really_is_negative(dentry))
                return -EINVAL;
 
        if (!dentry->d_sb->s_xattr ||
-           get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+           get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                return -EOPNOTSUPP;
 
-       dir = open_xa_dir(dentry->d_inode, XATTR_REPLACE);
+       dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE);
        if (IS_ERR(dir)) {
                err = PTR_ERR(dir);
                if (err == -ENODATA)
@@ -890,9 +890,9 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                goto out;
        }
 
-       mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
-       err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
-       mutex_unlock(&dir->d_inode->i_mutex);
+       mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR);
+       err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
+       mutex_unlock(&d_inode(dir)->i_mutex);
 
        if (!err)
                err = buf.pos;
@@ -905,12 +905,12 @@ out:
 static int create_privroot(struct dentry *dentry)
 {
        int err;
-       struct inode *inode = dentry->d_parent->d_inode;
+       struct inode *inode = d_inode(dentry->d_parent);
 
        WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
 
        err = xattr_mkdir(inode, dentry, 0700);
-       if (err || !dentry->d_inode) {
+       if (err || d_really_is_negative(dentry)) {
                reiserfs_warning(dentry->d_sb, "jdm-20006",
                                 "xattrs/ACLs enabled and couldn't "
                                 "find/create .reiserfs_priv. "
@@ -918,7 +918,7 @@ static int create_privroot(struct dentry *dentry)
                return -EOPNOTSUPP;
        }
 
-       dentry->d_inode->i_flags |= S_PRIVATE;
+       d_inode(dentry)->i_flags |= S_PRIVATE;
        reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr "
                      "storage.\n", PRIVROOT_NAME);
 
@@ -997,17 +997,17 @@ int reiserfs_lookup_privroot(struct super_block *s)
        int err = 0;
 
        /* If we don't have the privroot located yet - go find it */
-       mutex_lock(&s->s_root->d_inode->i_mutex);
+       mutex_lock(&d_inode(s->s_root)->i_mutex);
        dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
                                strlen(PRIVROOT_NAME));
        if (!IS_ERR(dentry)) {
                REISERFS_SB(s)->priv_root = dentry;
                d_set_d_op(dentry, &xattr_lookup_poison_ops);
-               if (dentry->d_inode)
-                       dentry->d_inode->i_flags |= S_PRIVATE;
+               if (d_really_is_positive(dentry))
+                       d_inode(dentry)->i_flags |= S_PRIVATE;
        } else
                err = PTR_ERR(dentry);
-       mutex_unlock(&s->s_root->d_inode->i_mutex);
+       mutex_unlock(&d_inode(s->s_root)->i_mutex);
 
        return err;
 }
@@ -1026,15 +1026,15 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
        if (err)
                goto error;
 
-       if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) {
-               mutex_lock(&s->s_root->d_inode->i_mutex);
+       if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) {
+               mutex_lock(&d_inode(s->s_root)->i_mutex);
                err = create_privroot(REISERFS_SB(s)->priv_root);
-               mutex_unlock(&s->s_root->d_inode->i_mutex);
+               mutex_unlock(&d_inode(s->s_root)->i_mutex);
        }
 
-       if (privroot->d_inode) {
+       if (d_really_is_positive(privroot)) {
                s->s_xattr = reiserfs_xattr_handlers;
-               mutex_lock(&privroot->d_inode->i_mutex);
+               mutex_lock(&d_inode(privroot)->i_mutex);
                if (!REISERFS_SB(s)->xattr_root) {
                        struct dentry *dentry;
 
@@ -1045,7 +1045,7 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
                        else
                                err = PTR_ERR(dentry);
                }
-               mutex_unlock(&privroot->d_inode->i_mutex);
+               mutex_unlock(&d_inode(privroot)->i_mutex);
        }
 
 error:
index f620e9678dd541a3786d031f9774583693f15341..15dde6262c00e3d93b765f79198d93bfe79c3646 100644 (file)
@@ -78,7 +78,7 @@ static inline size_t reiserfs_xattr_jcreate_nblocks(struct inode *inode)
 
        if ((REISERFS_I(inode)->i_flags & i_has_xattr_dir) == 0) {
                nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
-               if (!REISERFS_SB(inode->i_sb)->xattr_root->d_inode)
+               if (d_really_is_negative(REISERFS_SB(inode->i_sb)->xattr_root))
                        nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
        }
 
index e7f8939a4cb5786cc1c8df46996c8926afcc066a..9a3b0616f2838848c88dbf90497ebb9af0a68e2a 100644 (file)
@@ -15,10 +15,10 @@ security_get(struct dentry *dentry, const char *name, void *buffer, size_t size,
        if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
                return -EINVAL;
 
-       if (IS_PRIVATE(dentry->d_inode))
+       if (IS_PRIVATE(d_inode(dentry)))
                return -EPERM;
 
-       return reiserfs_xattr_get(dentry->d_inode, name, buffer, size);
+       return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
 }
 
 static int
@@ -28,10 +28,10 @@ security_set(struct dentry *dentry, const char *name, const void *buffer,
        if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
                return -EINVAL;
 
-       if (IS_PRIVATE(dentry->d_inode))
+       if (IS_PRIVATE(d_inode(dentry)))
                return -EPERM;
 
-       return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags);
+       return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t security_list(struct dentry *dentry, char *list, size_t list_len,
@@ -39,7 +39,7 @@ static size_t security_list(struct dentry *dentry, char *list, size_t list_len,
 {
        const size_t len = namelen + 1;
 
-       if (IS_PRIVATE(dentry->d_inode))
+       if (IS_PRIVATE(d_inode(dentry)))
                return 0;
 
        if (list && len <= list_len) {
index 5eeb0c48ba46deb225ec2cc94518746aebceabd3..e4f1343714e0ea8a89598bb776dc8a3f6b42c67d 100644 (file)
@@ -14,10 +14,10 @@ trusted_get(struct dentry *dentry, const char *name, void *buffer, size_t size,
        if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
                return -EINVAL;
 
-       if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode))
+       if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                return -EPERM;
 
-       return reiserfs_xattr_get(dentry->d_inode, name, buffer, size);
+       return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
 }
 
 static int
@@ -27,10 +27,10 @@ trusted_set(struct dentry *dentry, const char *name, const void *buffer,
        if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
                return -EINVAL;
 
-       if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode))
+       if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                return -EPERM;
 
-       return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags);
+       return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t trusted_list(struct dentry *dentry, char *list, size_t list_size,
@@ -38,7 +38,7 @@ static size_t trusted_list(struct dentry *dentry, char *list, size_t list_size,
 {
        const size_t len = name_len + 1;
 
-       if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode))
+       if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                return 0;
 
        if (list && len <= list_size) {
index e50eab0464711f6ebe363ca9f2bd7ff7767aab12..d0b08d3e5689d39aeffbd1d86e13711b50e56f22 100644 (file)
@@ -15,7 +15,7 @@ user_get(struct dentry *dentry, const char *name, void *buffer, size_t size,
                return -EINVAL;
        if (!reiserfs_xattrs_user(dentry->d_sb))
                return -EOPNOTSUPP;
-       return reiserfs_xattr_get(dentry->d_inode, name, buffer, size);
+       return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
 }
 
 static int
@@ -27,7 +27,7 @@ user_set(struct dentry *dentry, const char *name, const void *buffer,
 
        if (!reiserfs_xattrs_user(dentry->d_sb))
                return -EOPNOTSUPP;
-       return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags);
+       return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t user_list(struct dentry *dentry, char *list, size_t list_size,
index 5e1101ff276f940eeda02c596dcbdc9acff98d04..8073b6532cf0473f7cb16d75764b3aa93d985a32 100644 (file)
@@ -110,7 +110,7 @@ static struct dentry *squashfs_fh_to_parent(struct super_block *sb,
 
 static struct dentry *squashfs_get_parent(struct dentry *child)
 {
-       struct inode *inode = child->d_inode;
+       struct inode *inode = d_inode(child);
        unsigned int parent_ino = squashfs_i(inode)->parent;
 
        return squashfs_export_iget(inode->i_sb, parent_ino);
index 92fcde7b4d6189c3d88f341d170dbd0fa3441012..e5e0ddf5b1430d335075220824897c2e38d1b289 100644 (file)
@@ -39,7 +39,7 @@ static const struct xattr_handler *squashfs_xattr_handler(int);
 ssize_t squashfs_listxattr(struct dentry *d, char *buffer,
        size_t buffer_size)
 {
-       struct inode *inode = d->d_inode;
+       struct inode *inode = d_inode(d);
        struct super_block *sb = inode->i_sb;
        struct squashfs_sb_info *msblk = sb->s_fs_info;
        u64 start = SQUASHFS_XATTR_BLK(squashfs_i(inode)->xattr)
@@ -229,7 +229,7 @@ static int squashfs_user_get(struct dentry *d, const char *name, void *buffer,
        if (name[0] == '\0')
                return  -EINVAL;
 
-       return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_USER, name,
+       return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_USER, name,
                buffer, size);
 }
 
@@ -259,7 +259,7 @@ static int squashfs_trusted_get(struct dentry *d, const char *name,
        if (name[0] == '\0')
                return  -EINVAL;
 
-       return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_TRUSTED, name,
+       return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_TRUSTED, name,
                buffer, size);
 }
 
@@ -286,7 +286,7 @@ static int squashfs_security_get(struct dentry *d, const char *name,
        if (name[0] == '\0')
                return  -EINVAL;
 
-       return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_SECURITY, name,
+       return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_SECURITY, name,
                buffer, size);
 }
 
index d42291d08215abd016d4e3b5aac03fa753ce70b6..8f3555f00c54276aa1f0e1d443b7dd375850bf23 100644 (file)
@@ -132,7 +132,7 @@ struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_
 {
        const char * name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
-       struct inode * dir = dentry->d_parent->d_inode;
+       struct inode * dir = d_inode(dentry->d_parent);
        unsigned long start, n;
        unsigned long npages = dir_pages(dir);
        struct page *page = NULL;
@@ -176,7 +176,7 @@ found:
 
 int sysv_add_link(struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const char * name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        struct page *page = NULL;
index a48e30410ad1979eaf1068cd59ddfa2dcc89c69a..82ddc09061e2891cec1a877d43dc2c248719114e 100644 (file)
@@ -30,7 +30,7 @@ const struct file_operations sysv_file_operations = {
 
 static int sysv_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        error = inode_change_ok(inode, attr);
index 66bc316927e8a01f60a387aa19bac4ab81abcd87..2fde40acf024173b1f4fc68131ca97cb921588b0 100644 (file)
@@ -443,7 +443,7 @@ static unsigned sysv_nblocks(struct super_block *s, loff_t size)
 int sysv_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
        struct super_block *s = dentry->d_sb;
-       generic_fillattr(dentry->d_inode, stat);
+       generic_fillattr(d_inode(dentry), stat);
        stat->blocks = (s->s_blocksize / 512) * sysv_nblocks(s, stat->size);
        stat->blksize = s->s_blocksize;
        return 0;
index 731b2bbcaab37f7e8d4da84dcc9e9600d3b4e969..11e83ed0b4bf495c39a2d6f0128f8fce3793256f 100644 (file)
@@ -118,7 +118,7 @@ out_fail:
 static int sysv_link(struct dentry * old_dentry, struct inode * dir, 
        struct dentry * dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
 
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
@@ -166,7 +166,7 @@ out_dir:
 
 static int sysv_unlink(struct inode * dir, struct dentry * dentry)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        struct page * page;
        struct sysv_dir_entry * de;
        int err = -ENOENT;
@@ -187,7 +187,7 @@ out:
 
 static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int err = -ENOTEMPTY;
 
        if (sysv_empty_dir(inode)) {
@@ -208,8 +208,8 @@ static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
 static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
                  struct inode * new_dir, struct dentry * new_dentry)
 {
-       struct inode * old_inode = old_dentry->d_inode;
-       struct inode * new_inode = new_dentry->d_inode;
+       struct inode * old_inode = d_inode(old_dentry);
+       struct inode * new_inode = d_inode(new_dentry);
        struct page * dir_page = NULL;
        struct sysv_dir_entry * dir_de = NULL;
        struct page * old_page;
index 00d2f8a43e4eaefea0e35ba6108ef561d2852b52..d3fa0d703314bc3dafa9b5dd6c9d34a2f2c11f1d 100644 (file)
@@ -10,7 +10,7 @@
 
 static void *sysv_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       nd_set_link(nd, (char *)SYSV_I(dentry->d_inode)->i_data);
+       nd_set_link(nd, (char *)SYSV_I(d_inode(dentry))->i_data);
        return NULL;
 }
 
index 0fa6c803992ea2a6d791c7eb20d128038ca20b37..20ae94d37acd62a83aa25eefe174038e3b38b140 100644 (file)
@@ -498,7 +498,7 @@ static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
                      struct dentry *dentry)
 {
        struct ubifs_info *c = dir->i_sb->s_fs_info;
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct ubifs_inode *ui = ubifs_inode(inode);
        struct ubifs_inode *dir_ui = ubifs_inode(dir);
        int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
@@ -553,7 +553,7 @@ out_cancel:
 static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct ubifs_info *c = dir->i_sb->s_fs_info;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ubifs_inode *dir_ui = ubifs_inode(dir);
        int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
        int err, budgeted = 1;
@@ -645,7 +645,7 @@ static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
 static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
 {
        struct ubifs_info *c = dir->i_sb->s_fs_info;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
        int err, budgeted = 1;
        struct ubifs_inode *dir_ui = ubifs_inode(dir);
@@ -661,7 +661,7 @@ static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
                inode->i_ino, dir->i_ino);
        ubifs_assert(mutex_is_locked(&dir->i_mutex));
        ubifs_assert(mutex_is_locked(&inode->i_mutex));
-       err = check_dir_empty(c, dentry->d_inode);
+       err = check_dir_empty(c, d_inode(dentry));
        if (err)
                return err;
 
@@ -967,8 +967,8 @@ static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry)
 {
        struct ubifs_info *c = old_dir->i_sb->s_fs_info;
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
        int err, release, sync = 0, move = (new_dir != old_dir);
        int is_dir = S_ISDIR(old_inode->i_mode);
@@ -1133,7 +1133,7 @@ int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat)
 {
        loff_t size;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ubifs_inode *ui = ubifs_inode(inode);
 
        mutex_lock(&ui->ui_mutex);
index 475b15635f11654f40ddbc23dfc0f76aeb2a1099..b5c69414e6943765ef924d46352a26414751bc39 100644 (file)
@@ -1256,7 +1256,7 @@ static int do_setattr(struct ubifs_info *c, struct inode *inode,
 int ubifs_setattr(struct dentry *dentry, struct iattr *attr)
 {
        int err;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct ubifs_info *c = inode->i_sb->s_fs_info;
 
        dbg_gen("ino %lu, mode %#x, ia_valid %#x",
@@ -1301,7 +1301,7 @@ static void ubifs_invalidatepage(struct page *page, unsigned int offset,
 
 static void *ubifs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct ubifs_inode *ui = ubifs_inode(dentry->d_inode);
+       struct ubifs_inode *ui = ubifs_inode(d_inode(dentry));
 
        nd_set_link(nd, ui->data);
        return NULL;
index f6ac3f29323cdacd7a72e92c7c0babcd4fc8642f..4f657e15c46e2bbff815feb7669c55c7ffb3e4a0 100644 (file)
@@ -930,8 +930,8 @@ int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
        union ubifs_key key;
        struct ubifs_dent_node *dent, *dent2;
        int err, dlen1, dlen2, ilen, lnum, offs, len;
-       const struct inode *old_inode = old_dentry->d_inode;
-       const struct inode *new_inode = new_dentry->d_inode;
+       const struct inode *old_inode = d_inode(old_dentry);
+       const struct inode *new_inode = d_inode(new_dentry);
        int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
        int last_reference = !!(new_inode && new_inode->i_nlink == 0);
        int move = (old_dir != new_dir);
index a92be244a6fbb682d300287143320afc0ce18bf1..dd2d872189da6185c92a18531f701156cb7daecc 100644 (file)
@@ -364,15 +364,15 @@ int ubifs_setxattr(struct dentry *dentry, const char *name,
                   const void *value, size_t size, int flags)
 {
        dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
-               name, dentry->d_inode->i_ino, dentry, size);
+               name, d_inode(dentry)->i_ino, dentry, size);
 
-       return setxattr(dentry->d_inode, name, value, size, flags);
+       return setxattr(d_inode(dentry), name, value, size, flags);
 }
 
 ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
                       size_t size)
 {
-       struct inode *inode, *host = dentry->d_inode;
+       struct inode *inode, *host = d_inode(dentry);
        struct ubifs_info *c = host->i_sb->s_fs_info;
        struct qstr nm = QSTR_INIT(name, strlen(name));
        struct ubifs_inode *ui;
@@ -432,7 +432,7 @@ out_unlock:
 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
        union ubifs_key key;
-       struct inode *host = dentry->d_inode;
+       struct inode *host = d_inode(dentry);
        struct ubifs_info *c = host->i_sb->s_fs_info;
        struct ubifs_inode *host_ui = ubifs_inode(host);
        struct ubifs_dent_node *xent, *pxent = NULL;
@@ -535,7 +535,7 @@ out_cancel:
 
 int ubifs_removexattr(struct dentry *dentry, const char *name)
 {
-       struct inode *inode, *host = dentry->d_inode;
+       struct inode *inode, *host = d_inode(dentry);
        struct ubifs_info *c = host->i_sb->s_fs_info;
        struct qstr nm = QSTR_INIT(name, strlen(name));
        struct ubifs_dent_node *xent;
index 3de2edafff73738d233d4634e4561d1943bdaee3..a84cdd2ef6184a7cf6f28e42ca9bdcc48359f21c 100644 (file)
@@ -250,7 +250,7 @@ const struct file_operations udf_file_operations = {
 
 static int udf_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        int error;
 
        error = inode_change_ok(inode, attr);
index 33b246b82c98510289d533fcdcbc59154d38589f..b159b769bf51d3eb304a9686db878bf7860c6c56 100644 (file)
@@ -552,7 +552,7 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
 static int udf_add_nondir(struct dentry *dentry, struct inode *inode)
 {
        struct udf_inode_info *iinfo = UDF_I(inode);
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        struct udf_fileident_bh fibh;
        struct fileIdentDesc cfi, *fi;
        int err;
@@ -767,7 +767,7 @@ static int empty_dir(struct inode *dir)
 static int udf_rmdir(struct inode *dir, struct dentry *dentry)
 {
        int retval;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct udf_fileident_bh fibh;
        struct fileIdentDesc *fi, cfi;
        struct kernel_lb_addr tloc;
@@ -809,7 +809,7 @@ out:
 static int udf_unlink(struct inode *dir, struct dentry *dentry)
 {
        int retval;
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        struct udf_fileident_bh fibh;
        struct fileIdentDesc *fi;
        struct fileIdentDesc cfi;
@@ -999,7 +999,7 @@ out_no_entry:
 static int udf_link(struct dentry *old_dentry, struct inode *dir,
                    struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        struct udf_fileident_bh fibh;
        struct fileIdentDesc cfi, *fi;
        int err;
@@ -1036,8 +1036,8 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                      struct inode *new_dir, struct dentry *new_dentry)
 {
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct udf_fileident_bh ofibh, nfibh;
        struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
        struct fileIdentDesc ocfi, ncfi;
@@ -1175,7 +1175,7 @@ static struct dentry *udf_get_parent(struct dentry *child)
        struct fileIdentDesc cfi;
        struct udf_fileident_bh fibh;
 
-       if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
+       if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi))
                return ERR_PTR(-EACCES);
 
        if (fibh.sbh != fibh.ebh)
@@ -1183,7 +1183,7 @@ static struct dentry *udf_get_parent(struct dentry *child)
        brelse(fibh.sbh);
 
        tloc = lelb_to_cpu(cfi.icb.extLocation);
-       inode = udf_iget(child->d_inode->i_sb, &tloc);
+       inode = udf_iget(d_inode(child)->i_sb, &tloc);
        if (IS_ERR(inode))
                return ERR_CAST(inode);
 
index 0ecc2cebed8ffec60bc9ccdb408519253d7fc3a6..1bfe8cabff0f660d107c6bc97446a0cceaf940eb 100644 (file)
@@ -311,7 +311,7 @@ found:
  */
 int ufs_add_link(struct dentry *dentry, struct inode *inode)
 {
-       struct inode *dir = dentry->d_parent->d_inode;
+       struct inode *dir = d_inode(dentry->d_parent);
        const unsigned char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
        struct super_block *sb = dir->i_sb;
index fd65deb4b5f095e3103028b83f214ffba73707f7..e491a93a7e9af14c4227ee5072fa4a9d0bc17709 100644 (file)
@@ -165,7 +165,7 @@ out_fail:
 static int ufs_link (struct dentry * old_dentry, struct inode * dir,
        struct dentry *dentry)
 {
-       struct inode *inode = old_dentry->d_inode;
+       struct inode *inode = d_inode(old_dentry);
        int error;
 
        lock_ufs(dir->i_sb);
@@ -222,7 +222,7 @@ out_fail:
 
 static int ufs_unlink(struct inode *dir, struct dentry *dentry)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        struct ufs_dir_entry *de;
        struct page *page;
        int err = -ENOENT;
@@ -244,7 +244,7 @@ out:
 
 static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
 {
-       struct inode * inode = dentry->d_inode;
+       struct inode * inode = d_inode(dentry);
        int err= -ENOTEMPTY;
 
        lock_ufs(dir->i_sb);
@@ -263,8 +263,8 @@ static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
                      struct inode *new_dir, struct dentry *new_dentry)
 {
-       struct inode *old_inode = old_dentry->d_inode;
-       struct inode *new_inode = new_dentry->d_inode;
+       struct inode *old_inode = d_inode(old_dentry);
+       struct inode *new_inode = d_inode(new_dentry);
        struct page *dir_page = NULL;
        struct ufs_dir_entry * dir_de = NULL;
        struct page *old_page;
index 8092d3759a5e560001ad75bdb9a5238c053a8523..b3bc3e7ae79db3c1542f8e8cf3ac549aa0deed62 100644 (file)
@@ -144,10 +144,10 @@ static struct dentry *ufs_get_parent(struct dentry *child)
        struct qstr dot_dot = QSTR_INIT("..", 2);
        ino_t ino;
 
-       ino = ufs_inode_by_name(child->d_inode, &dot_dot);
+       ino = ufs_inode_by_name(d_inode(child), &dot_dot);
        if (!ino)
                return ERR_PTR(-ENOENT);
-       return d_obtain_alias(ufs_iget(child->d_inode->i_sb, ino));
+       return d_obtain_alias(ufs_iget(d_inode(child)->i_sb, ino));
 }
 
 static const struct export_operations ufs_export_ops = {
index d283628b4778bc4fef3a07d8bf8b267458c1e389..5b537e2fdda385a0da9aa346e93e05e83084e1dd 100644 (file)
@@ -34,7 +34,7 @@
 
 static void *ufs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-       struct ufs_inode_info *p = UFS_I(dentry->d_inode);
+       struct ufs_inode_info *p = UFS_I(d_inode(dentry));
        nd_set_link(nd, (char*)p->i_u1.i_symlink);
        return NULL;
 }
index f04f89fbd4d9914b0a1a16f2cce8c8e0799e020e..21154704c16801ea6525f4152637dc3d16b4bdd8 100644 (file)
@@ -492,7 +492,7 @@ out:
 
 int ufs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-       struct inode *inode = dentry->d_inode;
+       struct inode *inode = d_inode(dentry);
        unsigned int ia_valid = attr->ia_valid;
        int error;
 
index b97359ba2648f12fca1bfa98e25be6efc719c8e3..652cd3c5b58c1cac1562239c9c644a19dbe588b7 100644 (file)
@@ -215,7 +215,7 @@ xfs_fs_get_parent(
        int                     error;
        struct xfs_inode        *cip;
 
-       error = xfs_lookup(XFS_I(child->d_inode), &xfs_name_dotdot, &cip, NULL);
+       error = xfs_lookup(XFS_I(d_inode(child)), &xfs_name_dotdot, &cip, NULL);
        if (unlikely(error))
                return ERR_PTR(error);
 
index a2e86e8a0feac8fabf316fb8a790fc805153469a..22807e1e9cca97a3a66f0cc7d285cd1795bd4ca2 100644 (file)
@@ -294,7 +294,7 @@ xfs_filestream_get_parent(
        if (!parent)
                goto out_dput;
 
-       dir = igrab(parent->d_inode);
+       dir = igrab(d_inode(parent));
        dput(parent);
 
 out_dput:
index ac4feae45eb308c39629f177c0b6620fae77fb69..ed97bd48cf32da40797b0c76f3f18108ad6c59f6 100644 (file)
@@ -82,7 +82,7 @@ xfs_find_handle(
                error = user_lpath((const char __user *)hreq->path, &path);
                if (error)
                        return error;
-               inode = path.dentry->d_inode;
+               inode = d_inode(path.dentry);
        }
        ip = XFS_I(inode);
 
@@ -210,7 +210,7 @@ xfs_open_by_handle(
        dentry = xfs_handlereq_to_dentry(parfilp, hreq);
        if (IS_ERR(dentry))
                return PTR_ERR(dentry);
-       inode = dentry->d_inode;
+       inode = d_inode(dentry);
 
        /* Restrict xfs_open_by_handle to directories & regular files. */
        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
@@ -303,7 +303,7 @@ xfs_readlink_by_handle(
                goto out_dput;
        }
 
-       error = xfs_readlink(XFS_I(dentry->d_inode), link);
+       error = xfs_readlink(XFS_I(d_inode(dentry)), link);
        if (error)
                goto out_kfree;
        error = readlink_copy(hreq->ohandle, olen, link);
@@ -376,7 +376,7 @@ xfs_fssetdm_by_handle(
                return PTR_ERR(dentry);
        }
 
-       if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
+       if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
                error = -EPERM;
                goto out;
        }
@@ -386,7 +386,7 @@ xfs_fssetdm_by_handle(
                goto out;
        }
 
-       error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+       error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
                                 fsd.fsd_dmstate);
 
  out:
@@ -429,7 +429,7 @@ xfs_attrlist_by_handle(
                goto out_dput;
 
        cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-       error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+       error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
                                        al_hreq.flags, cursor);
        if (error)
                goto out_kfree;
@@ -559,7 +559,7 @@ xfs_attrmulti_by_handle(
                switch (ops[i].am_opcode) {
                case ATTR_OP_GET:
                        ops[i].am_error = xfs_attrmulti_attr_get(
-                                       dentry->d_inode, attr_name,
+                                       d_inode(dentry), attr_name,
                                        ops[i].am_attrvalue, &ops[i].am_length,
                                        ops[i].am_flags);
                        break;
@@ -568,7 +568,7 @@ xfs_attrmulti_by_handle(
                        if (ops[i].am_error)
                                break;
                        ops[i].am_error = xfs_attrmulti_attr_set(
-                                       dentry->d_inode, attr_name,
+                                       d_inode(dentry), attr_name,
                                        ops[i].am_attrvalue, ops[i].am_length,
                                        ops[i].am_flags);
                        mnt_drop_write_file(parfilp);
@@ -578,7 +578,7 @@ xfs_attrmulti_by_handle(
                        if (ops[i].am_error)
                                break;
                        ops[i].am_error = xfs_attrmulti_attr_remove(
-                                       dentry->d_inode, attr_name,
+                                       d_inode(dentry), attr_name,
                                        ops[i].am_flags);
                        mnt_drop_write_file(parfilp);
                        break;
index bfc7c7c8a0c884a2ebcc30194a1ccb30373d0955..b88bdc85dd3db365230d51e31fc97030ed2de38d 100644 (file)
@@ -375,7 +375,7 @@ xfs_compat_attrlist_by_handle(
                goto out_dput;
 
        cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-       error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+       error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
                                        al_hreq.flags, cursor);
        if (error)
                goto out_kfree;
@@ -445,7 +445,7 @@ xfs_compat_attrmulti_by_handle(
                switch (ops[i].am_opcode) {
                case ATTR_OP_GET:
                        ops[i].am_error = xfs_attrmulti_attr_get(
-                                       dentry->d_inode, attr_name,
+                                       d_inode(dentry), attr_name,
                                        compat_ptr(ops[i].am_attrvalue),
                                        &ops[i].am_length, ops[i].am_flags);
                        break;
@@ -454,7 +454,7 @@ xfs_compat_attrmulti_by_handle(
                        if (ops[i].am_error)
                                break;
                        ops[i].am_error = xfs_attrmulti_attr_set(
-                                       dentry->d_inode, attr_name,
+                                       d_inode(dentry), attr_name,
                                        compat_ptr(ops[i].am_attrvalue),
                                        ops[i].am_length, ops[i].am_flags);
                        mnt_drop_write_file(parfilp);
@@ -464,7 +464,7 @@ xfs_compat_attrmulti_by_handle(
                        if (ops[i].am_error)
                                break;
                        ops[i].am_error = xfs_attrmulti_attr_remove(
-                                       dentry->d_inode, attr_name,
+                                       d_inode(dentry), attr_name,
                                        ops[i].am_flags);
                        mnt_drop_write_file(parfilp);
                        break;
@@ -504,7 +504,7 @@ xfs_compat_fssetdm_by_handle(
        if (IS_ERR(dentry))
                return PTR_ERR(dentry);
 
-       if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
+       if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
                error = -EPERM;
                goto out;
        }
@@ -514,7 +514,7 @@ xfs_compat_fssetdm_by_handle(
                goto out;
        }
 
-       error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+       error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
                                 fsd.fsd_dmstate);
 
 out:
index e53a903314225c030c45f694b4ffdaa509fa1ce8..54b95232d94662124bf38f932bd28817bb3529fe 100644 (file)
@@ -301,7 +301,7 @@ xfs_vn_link(
        struct inode    *dir,
        struct dentry   *dentry)
 {
-       struct inode    *inode = old_dentry->d_inode;
+       struct inode    *inode = d_inode(old_dentry);
        struct xfs_name name;
        int             error;
 
@@ -326,7 +326,7 @@ xfs_vn_unlink(
 
        xfs_dentry_to_name(&name, dentry, 0);
 
-       error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
+       error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry)));
        if (error)
                return error;
 
@@ -384,7 +384,7 @@ xfs_vn_rename(
        struct dentry   *ndentry,
        unsigned int    flags)
 {
-       struct inode    *new_inode = ndentry->d_inode;
+       struct inode    *new_inode = d_inode(ndentry);
        int             omode = 0;
        struct xfs_name oname;
        struct xfs_name nname;
@@ -394,12 +394,12 @@ xfs_vn_rename(
 
        /* if we are exchanging files, we need to set i_mode of both files */
        if (flags & RENAME_EXCHANGE)
-               omode = ndentry->d_inode->i_mode;
+               omode = d_inode(ndentry)->i_mode;
 
        xfs_dentry_to_name(&oname, odentry, omode);
-       xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode);
+       xfs_dentry_to_name(&nname, ndentry, d_inode(odentry)->i_mode);
 
-       return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
+       return xfs_rename(XFS_I(odir), &oname, XFS_I(d_inode(odentry)),
                          XFS_I(ndir), &nname,
                          new_inode ? XFS_I(new_inode) : NULL, flags);
 }
@@ -421,7 +421,7 @@ xfs_vn_follow_link(
        if (!link)
                goto out_err;
 
-       error = xfs_readlink(XFS_I(dentry->d_inode), link);
+       error = xfs_readlink(XFS_I(d_inode(dentry)), link);
        if (unlikely(error))
                goto out_kfree;
 
@@ -441,7 +441,7 @@ xfs_vn_getattr(
        struct dentry           *dentry,
        struct kstat            *stat)
 {
-       struct inode            *inode = dentry->d_inode;
+       struct inode            *inode = d_inode(dentry);
        struct xfs_inode        *ip = XFS_I(inode);
        struct xfs_mount        *mp = ip->i_mount;
 
@@ -968,14 +968,14 @@ xfs_vn_setattr(
        struct dentry           *dentry,
        struct iattr            *iattr)
 {
-       struct xfs_inode        *ip = XFS_I(dentry->d_inode);
+       struct xfs_inode        *ip = XFS_I(d_inode(dentry));
        int                     error;
 
        if (iattr->ia_valid & ATTR_SIZE) {
                uint            iolock = XFS_IOLOCK_EXCL;
 
                xfs_ilock(ip, iolock);
-               error = xfs_break_layouts(dentry->d_inode, &iolock);
+               error = xfs_break_layouts(d_inode(dentry), &iolock);
                if (!error)
                        error = xfs_setattr_size(ip, iattr);
                xfs_iunlock(ip, iolock);
index 8fcc4ccc5c791224e0d9325a5ad0557390a14d71..72e97e31d3b17be91c719ca894bccc658c3df76b 100644 (file)
@@ -1083,7 +1083,7 @@ xfs_fs_statfs(
 {
        struct xfs_mount        *mp = XFS_M(dentry->d_sb);
        xfs_sb_t                *sbp = &mp->m_sb;
-       struct xfs_inode        *ip = XFS_I(dentry->d_inode);
+       struct xfs_inode        *ip = XFS_I(d_inode(dentry));
        __uint64_t              fakeinos, id;
        xfs_extlen_t            lsize;
        __int64_t               ffree;
index 69f6e475de97cacba39f85cdd0c2058539260447..c036815183cb69bd82c58a0300c243e7e7ca7f32 100644 (file)
@@ -35,7 +35,7 @@ static int
 xfs_xattr_get(struct dentry *dentry, const char *name,
                void *value, size_t size, int xflags)
 {
-       struct xfs_inode *ip = XFS_I(dentry->d_inode);
+       struct xfs_inode *ip = XFS_I(d_inode(dentry));
        int error, asize = size;
 
        if (strcmp(name, "") == 0)
@@ -57,7 +57,7 @@ static int
 xfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
                size_t size, int flags, int xflags)
 {
-       struct xfs_inode *ip = XFS_I(dentry->d_inode);
+       struct xfs_inode *ip = XFS_I(d_inode(dentry));
 
        if (strcmp(name, "") == 0)
                return -EINVAL;
@@ -197,7 +197,7 @@ xfs_vn_listxattr(struct dentry *dentry, char *data, size_t size)
 {
        struct xfs_attr_list_context context;
        struct attrlist_cursor_kern cursor = { 0 };
-       struct inode            *inode = dentry->d_inode;
+       struct inode            *inode = d_inode(dentry);
        int                     error;
 
        /*
index 1faecea101f3e85a84c247ec997af8216de2523d..9134bba9f2180a4f3538f160216e22227f9ab13d 100644 (file)
@@ -407,10 +407,10 @@ TRACE_EVENT(btrfs_sync_file,
 
        TP_fast_assign(
                struct dentry *dentry = file->f_path.dentry;
-               struct inode *inode = dentry->d_inode;
+               struct inode *inode = d_inode(dentry);
 
                __entry->ino            = inode->i_ino;
-               __entry->parent         = dentry->d_parent->d_inode->i_ino;
+               __entry->parent         = d_inode(dentry->d_parent)->i_ino;
                __entry->datasync       = datasync;
                __entry->root_objectid  =
                                 BTRFS_I(inode)->root->root_key.objectid;
index 6797b9de90edeac929c5c234558434cc16d1d877..4a633258cab682fd19b51f8bd18e98f011e55a85 100644 (file)
@@ -439,10 +439,10 @@ TRACE_EVENT(ext3_sync_file_enter,
        TP_fast_assign(
                struct dentry *dentry = file->f_path.dentry;
 
-               __entry->dev            = dentry->d_inode->i_sb->s_dev;
-               __entry->ino            = dentry->d_inode->i_ino;
+               __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+               __entry->ino            = d_inode(dentry)->i_ino;
                __entry->datasync       = datasync;
-               __entry->parent         = dentry->d_parent->d_inode->i_ino;
+               __entry->parent         = d_inode(dentry->d_parent)->i_ino;
        ),
 
        TP_printk("dev %d,%d ino %lu parent %ld datasync %d ",
@@ -710,9 +710,9 @@ TRACE_EVENT(ext3_unlink_enter,
 
        TP_fast_assign(
                __entry->parent         = parent->i_ino;
-               __entry->ino            = dentry->d_inode->i_ino;
-               __entry->size           = dentry->d_inode->i_size;
-               __entry->dev            = dentry->d_inode->i_sb->s_dev;
+               __entry->ino            = d_inode(dentry)->i_ino;
+               __entry->size           = d_inode(dentry)->i_size;
+               __entry->dev            = d_inode(dentry)->i_sb->s_dev;
        ),
 
        TP_printk("dev %d,%d ino %lu size %lld parent %ld",
@@ -734,8 +734,8 @@ TRACE_EVENT(ext3_unlink_exit,
        ),
 
        TP_fast_assign(
-               __entry->ino            = dentry->d_inode->i_ino;
-               __entry->dev            = dentry->d_inode->i_sb->s_dev;
+               __entry->ino            = d_inode(dentry)->i_ino;
+               __entry->dev            = d_inode(dentry)->i_sb->s_dev;
                __entry->ret            = ret;
        ),
 
index 6e5abd6d38a2b7839aca39f961df6818b9330e42..68d2a677c04ca574e7d77319202e542b486fdc94 100644 (file)
@@ -872,10 +872,10 @@ TRACE_EVENT(ext4_sync_file_enter,
        TP_fast_assign(
                struct dentry *dentry = file->f_path.dentry;
 
-               __entry->dev            = dentry->d_inode->i_sb->s_dev;
-               __entry->ino            = dentry->d_inode->i_ino;
+               __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+               __entry->ino            = d_inode(dentry)->i_ino;
                __entry->datasync       = datasync;
-               __entry->parent         = dentry->d_parent->d_inode->i_ino;
+               __entry->parent         = d_inode(dentry->d_parent)->i_ino;
        ),
 
        TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
@@ -1453,10 +1453,10 @@ TRACE_EVENT(ext4_unlink_enter,
        ),
 
        TP_fast_assign(
-               __entry->dev            = dentry->d_inode->i_sb->s_dev;
-               __entry->ino            = dentry->d_inode->i_ino;
+               __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+               __entry->ino            = d_inode(dentry)->i_ino;
                __entry->parent         = parent->i_ino;
-               __entry->size           = dentry->d_inode->i_size;
+               __entry->size           = d_inode(dentry)->i_size;
        ),
 
        TP_printk("dev %d,%d ino %lu size %lld parent %lu",
@@ -1477,8 +1477,8 @@ TRACE_EVENT(ext4_unlink_exit,
        ),
 
        TP_fast_assign(
-               __entry->dev            = dentry->d_inode->i_sb->s_dev;
-               __entry->ino            = dentry->d_inode->i_ino;
+               __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+               __entry->ino            = d_inode(dentry)->i_ino;
                __entry->ret            = ret;
        ),