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>

3 files changed, 45 insertions, 45 deletions

diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index acb3d63bc9dc..c81ce7f200a6 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -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);
 
diff --git a/fs/configfs/file.c b/fs/configfs/file.c
index 56d2cdc9ae0a..403269ffcdf3 100644
--- a/fs/configfs/file.c
+++ b/fs/configfs/file.c
@@ -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;
 }
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index 5423a6a6ecc8..8d89f5fd0331 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -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);
 }