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

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

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

5 files changed, 19 insertions, 19 deletions

diff --git a/fs/coda/cache.c b/fs/coda/cache.c
index 46ee6f238985..5bb630a769e0 100644
--- a/fs/coda/cache.c
+++ b/fs/coda/cache.c
@@ -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; 
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 60cb88c1dd2b..fda9f4311212 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -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;
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 82ec68b59208..cac1390b87a3 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -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;
 
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index 4326d172fc27..f36a4040afb8 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -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) {
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index 5bb6e27298a4..9b1ffaa0572e 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -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: