VFS: fs/cachefiles: d_backing_inode() annotations

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

6 files changed, 62 insertions, 62 deletions

diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c
index fbb08e97438d..6af790fc3df8 100644
--- a/fs/cachefiles/bind.c
+++ b/fs/cachefiles/bind.c
@@ -123,11 +123,11 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache)
 
         /* check parameters */
         ret = -EOPNOTSUPP;
-        if (!root->d_inode ||
-            !root->d_inode->i_op->lookup ||
-            !root->d_inode->i_op->mkdir ||
-            !root->d_inode->i_op->setxattr ||
-            !root->d_inode->i_op->getxattr ||
+        if (d_is_negative(root) ||
+            !d_backing_inode(root)->i_op->lookup ||
+            !d_backing_inode(root)->i_op->mkdir ||
+            !d_backing_inode(root)->i_op->setxattr ||
+            !d_backing_inode(root)->i_op->getxattr ||
             !root->d_sb->s_op->statfs ||
             !root->d_sb->s_op->sync_fs)
                 goto error_unsupported;
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index f1fb0a21bb5a..afa023dded5b 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -441,7 +441,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
 
         fscache_set_store_limit(&object->fscache, ni_size);
 
-        oi_size = i_size_read(object->backer->d_inode);
+        oi_size = i_size_read(d_backing_inode(object->backer));
         if (oi_size == ni_size)
                 return 0;
 
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 61396359863f..ab857ab9f40d 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -355,7 +355,7 @@ try_again:
                 return -EIO;
         }
 
-        if (grave->d_inode) {
+        if (d_is_positive(grave)) {
                 unlock_rename(cache->graveyard, dir);
                 dput(grave);
                 grave = NULL;
@@ -415,7 +415,7 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
         _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry);
 
         ASSERT(object->dentry);
-        ASSERT(object->dentry->d_inode);
+        ASSERT(d_backing_inode(object->dentry));
         ASSERT(object->dentry->d_parent);
 
         dir = dget_parent(object->dentry);
@@ -473,7 +473,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
         path.mnt = cache->mnt;
 
         ASSERT(parent->dentry);
-        ASSERT(parent->dentry->d_inode);
+        ASSERT(d_backing_inode(parent->dentry));
 
         if (!(d_is_dir(parent->dentry))) {
                 // TODO: convert file to dir
@@ -505,21 +505,21 @@ lookup_again:
         if (IS_ERR(next))
                 goto lookup_error;
 
-        _debug("next -> %p %s", next, next->d_inode ? "positive" : "negative");
+        _debug("next -> %p %s", next, d_backing_inode(next) ? "positive" : "negative");
 
         if (!key)
-                object->new = !next->d_inode;
+                object->new = !d_backing_inode(next);
 
         /* if this element of the path doesn't exist, then the lookup phase
          * failed, and we can release any readers in the certain knowledge that
          * there's nothing for them to actually read */
-        if (!next->d_inode)
+        if (d_is_negative(next))
                 fscache_object_lookup_negative(&object->fscache);
 
         /* we need to create the object if it's negative */
         if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
                 /* index objects and intervening tree levels must be subdirs */
-                if (!next->d_inode) {
+                if (d_is_negative(next)) {
                         ret = cachefiles_has_space(cache, 1, 0);
                         if (ret < 0)
                                 goto create_error;
@@ -534,21 +534,21 @@ lookup_again:
                         if (ret < 0)
                                 goto create_error;
 
-                        ASSERT(next->d_inode);
+                        ASSERT(d_backing_inode(next));
 
                         _debug("mkdir -> %p{%p{ino=%lu}}",
-                               next, next->d_inode, next->d_inode->i_ino);
+                               next, d_backing_inode(next), d_backing_inode(next)->i_ino);
 
                 } else if (!d_can_lookup(next)) {
                         pr_err("inode %lu is not a directory\n",
-                               next->d_inode->i_ino);
+                               d_backing_inode(next)->i_ino);
                         ret = -ENOBUFS;
                         goto error;
                 }
 
         } else {
                 /* non-index objects start out life as files */
-                if (!next->d_inode) {
+                if (d_is_negative(next)) {
                         ret = cachefiles_has_space(cache, 1, 0);
                         if (ret < 0)
                                 goto create_error;
@@ -563,16 +563,16 @@ lookup_again:
                         if (ret < 0)
                                 goto create_error;
 
-                        ASSERT(next->d_inode);
+                        ASSERT(d_backing_inode(next));
 
                         _debug("create -> %p{%p{ino=%lu}}",
-                               next, next->d_inode, next->d_inode->i_ino);
+                               next, d_backing_inode(next), d_backing_inode(next)->i_ino);
 
                 } else if (!d_can_lookup(next) &&
                            !d_is_reg(next)
                            ) {
                         pr_err("inode %lu is not a file or directory\n",
-                               next->d_inode->i_ino);
+                               d_backing_inode(next)->i_ino);
                         ret = -ENOBUFS;
                         goto error;
                 }
@@ -646,7 +646,7 @@ lookup_again:
                         const struct address_space_operations *aops;
 
                         ret = -EPERM;
-                        aops = object->dentry->d_inode->i_mapping->a_ops;
+                        aops = d_backing_inode(object->dentry)->i_mapping->a_ops;
                         if (!aops->bmap)
                                 goto check_error;
 
@@ -659,7 +659,7 @@ lookup_again:
         object->new = 0;
         fscache_obtained_object(&object->fscache);
 
-        _leave(" = 0 [%lu]", object->dentry->d_inode->i_ino);
+        _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
         return 0;
 
 create_error:
@@ -731,10 +731,10 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         }
 
         _debug("subdir -> %p %s",
-               subdir, subdir->d_inode ? "positive" : "negative");
+               subdir, d_backing_inode(subdir) ? "positive" : "negative");
 
         /* we need to create the subdir if it doesn't exist yet */
-        if (!subdir->d_inode) {
+        if (d_is_negative(subdir)) {
                 ret = cachefiles_has_space(cache, 1, 0);
                 if (ret < 0)
                         goto mkdir_error;
@@ -750,18 +750,18 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
                 if (ret < 0)
                         goto mkdir_error;
 
-                ASSERT(subdir->d_inode);
+                ASSERT(d_backing_inode(subdir));
 
                 _debug("mkdir -> %p{%p{ino=%lu}}",
                        subdir,
-                       subdir->d_inode,
-                       subdir->d_inode->i_ino);
+                       d_backing_inode(subdir),
+                       d_backing_inode(subdir)->i_ino);
         }
 
         mutex_unlock(&d_inode(dir)->i_mutex);
 
         /* we need to make sure the subdir is a directory */
-        ASSERT(subdir->d_inode);
+        ASSERT(d_backing_inode(subdir));
 
         if (!d_can_lookup(subdir)) {
                 pr_err("%s is not a directory\n", dirname);
@@ -770,18 +770,18 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         }
 
         ret = -EPERM;
-        if (!subdir->d_inode->i_op->setxattr ||
-            !subdir->d_inode->i_op->getxattr ||
-            !subdir->d_inode->i_op->lookup ||
-            !subdir->d_inode->i_op->mkdir ||
-            !subdir->d_inode->i_op->create ||
-            (!subdir->d_inode->i_op->rename &&
-             !subdir->d_inode->i_op->rename2) ||
-            !subdir->d_inode->i_op->rmdir ||
-            !subdir->d_inode->i_op->unlink)
+        if (!d_backing_inode(subdir)->i_op->setxattr ||
+            !d_backing_inode(subdir)->i_op->getxattr ||
+            !d_backing_inode(subdir)->i_op->lookup ||
+            !d_backing_inode(subdir)->i_op->mkdir ||
+            !d_backing_inode(subdir)->i_op->create ||
+            (!d_backing_inode(subdir)->i_op->rename &&
+             !d_backing_inode(subdir)->i_op->rename2) ||
+            !d_backing_inode(subdir)->i_op->rmdir ||
+            !d_backing_inode(subdir)->i_op->unlink)
                 goto check_error;
 
-        _leave(" = [%lu]", subdir->d_inode->i_ino);
+        _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
         return subdir;
 
 check_error:
@@ -836,12 +836,12 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
                 goto lookup_error;
 
         //_debug("victim -> %p %s",
-        //       victim, victim->d_inode ? "positive" : "negative");
+        //       victim, d_backing_inode(victim) ? "positive" : "negative");
 
         /* if the object is no longer there then we probably retired the object
          * at the netfs's request whilst the cull was in progress
          */
-        if (!victim->d_inode) {
+        if (d_is_negative(victim)) {
                 mutex_unlock(&d_inode(dir)->i_mutex);
                 dput(victim);
                 _leave(" = -ENOENT [absent]");
@@ -913,7 +913,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
                 return PTR_ERR(victim);
 
         _debug("victim -> %p %s",
-               victim, victim->d_inode ? "positive" : "negative");
+               victim, d_backing_inode(victim) ? "positive" : "negative");
 
         /* okay... the victim is not being used so we can cull it
          * - start by marking it as stale
diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c
index c6cd8d7a4eef..3cbb0e834694 100644
--- a/fs/cachefiles/rdwr.c
+++ b/fs/cachefiles/rdwr.c
@@ -74,12 +74,12 @@ static int cachefiles_read_waiter(wait_queue_t *wait, unsigned mode,
 static int cachefiles_read_reissue(struct cachefiles_object *object,
                                    struct cachefiles_one_read *monitor)
 {
-        struct address_space *bmapping = object->backer->d_inode->i_mapping;
+        struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping;
         struct page *backpage = monitor->back_page, *backpage2;
         int ret;
 
         _enter("{ino=%lx},{%lx,%lx}",
-               object->backer->d_inode->i_ino,
+               d_backing_inode(object->backer)->i_ino,
                backpage->index, backpage->flags);
 
         /* skip if the page was truncated away completely */
@@ -157,7 +157,7 @@ static void cachefiles_read_copier(struct fscache_operation *_op)
         object = container_of(op->op.object,
                               struct cachefiles_object, fscache);
 
-        _enter("{ino=%lu}", object->backer->d_inode->i_ino);
+        _enter("{ino=%lu}", d_backing_inode(object->backer)->i_ino);
 
         max = 8;
         spin_lock_irq(&object->work_lock);
@@ -247,7 +247,7 @@ static int cachefiles_read_backing_file_one(struct cachefiles_object *object,
         init_waitqueue_func_entry(&monitor->monitor, cachefiles_read_waiter);
 
         /* attempt to get hold of the backing page */
-        bmapping = object->backer->d_inode->i_mapping;
+        bmapping = d_backing_inode(object->backer)->i_mapping;
         newpage = NULL;
 
         for (;;) {
@@ -408,7 +408,7 @@ int cachefiles_read_or_alloc_page(struct fscache_retrieval *op,
         if (!object->backer)
                 goto enobufs;
 
-        inode = object->backer->d_inode;
+        inode = d_backing_inode(object->backer);
         ASSERT(S_ISREG(inode->i_mode));
         ASSERT(inode->i_mapping->a_ops->bmap);
         ASSERT(inode->i_mapping->a_ops->readpages);
@@ -468,7 +468,7 @@ static int cachefiles_read_backing_file(struct cachefiles_object *object,
                                         struct list_head *list)
 {
         struct cachefiles_one_read *monitor = NULL;
-        struct address_space *bmapping = object->backer->d_inode->i_mapping;
+        struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping;
         struct page *newpage = NULL, *netpage, *_n, *backpage = NULL;
         int ret = 0;
 
@@ -705,7 +705,7 @@ int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,
         if (cachefiles_has_space(cache, 0, *nr_pages) < 0)
                 space = 0;
 
-        inode = object->backer->d_inode;
+        inode = d_backing_inode(object->backer);
         ASSERT(S_ISREG(inode->i_mode));
         ASSERT(inode->i_mapping->a_ops->bmap);
         ASSERT(inode->i_mapping->a_ops->readpages);
diff --git a/fs/cachefiles/security.c b/fs/cachefiles/security.c
index 396c18ea2764..31bbc0528b11 100644
--- a/fs/cachefiles/security.c
+++ b/fs/cachefiles/security.c
@@ -55,14 +55,14 @@ static int cachefiles_check_cache_dir(struct cachefiles_cache *cache,
 {
         int ret;
 
-        ret = security_inode_mkdir(root->d_inode, root, 0);
+        ret = security_inode_mkdir(d_backing_inode(root), root, 0);
         if (ret < 0) {
                 pr_err("Security denies permission to make dirs: error %d",
                        ret);
                 return ret;
         }
 
-        ret = security_inode_create(root->d_inode, root, 0);
+        ret = security_inode_create(d_backing_inode(root), root, 0);
         if (ret < 0)
                 pr_err("Security denies permission to create files: error %d",
                        ret);
@@ -95,7 +95,7 @@ int cachefiles_determine_cache_security(struct cachefiles_cache *cache,
 
         /* use the cache root dir's security context as the basis with
          * which create files */
-        ret = set_create_files_as(new, root->d_inode);
+        ret = set_create_files_as(new, d_backing_inode(root));
         if (ret < 0) {
                 abort_creds(new);
                 cachefiles_begin_secure(cache, _saved_cred);
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index a8a68745e11d..d31c1a72d8a5 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -33,7 +33,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
         int ret;
 
         ASSERT(dentry);
-        ASSERT(dentry->d_inode);
+        ASSERT(d_backing_inode(dentry));
 
         if (!object->fscache.cookie)
                 strcpy(type, "C3");
@@ -52,7 +52,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
 
         if (ret != -EEXIST) {
                 pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
-                       dentry, dentry->d_inode->i_ino,
+                       dentry, d_backing_inode(dentry)->i_ino,
                        -ret);
                 goto error;
         }
@@ -64,7 +64,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
                         goto bad_type_length;
 
                 pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
-                       dentry, dentry->d_inode->i_ino,
+                       dentry, d_backing_inode(dentry)->i_ino,
                        -ret);
                 goto error;
         }
@@ -84,14 +84,14 @@ error:
 
 bad_type_length:
         pr_err("Cache object %lu type xattr length incorrect\n",
-               dentry->d_inode->i_ino);
+               d_backing_inode(dentry)->i_ino);
         ret = -EIO;
         goto error;
 
 bad_type:
         xtype[2] = 0;
         pr_err("Cache object %pd [%lu] type %s not %s\n",
-               dentry, dentry->d_inode->i_ino,
+               dentry, d_backing_inode(dentry)->i_ino,
                xtype, type);
         ret = -EIO;
         goto error;
@@ -165,7 +165,7 @@ int cachefiles_check_auxdata(struct cachefiles_object *object)
         int ret;
 
         ASSERT(dentry);
-        ASSERT(dentry->d_inode);
+        ASSERT(d_backing_inode(dentry));
         ASSERT(object->fscache.cookie->def->check_aux);
 
         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
@@ -204,7 +204,7 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
         _enter("%p,#%d", object, auxdata->len);
 
         ASSERT(dentry);
-        ASSERT(dentry->d_inode);
+        ASSERT(d_backing_inode(dentry));
 
         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
         if (!auxbuf) {
@@ -225,7 +225,7 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
 
                 cachefiles_io_error_obj(object,
                                         "Can't read xattr on %lu (err %d)",
-                                        dentry->d_inode->i_ino, -ret);
+                                        d_backing_inode(dentry)->i_ino, -ret);
                 goto error;
         }
 
@@ -276,7 +276,7 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
                         cachefiles_io_error_obj(object,
                                                 "Can't update xattr on %lu"
                                                 " (error %d)",
-                                                dentry->d_inode->i_ino, -ret);
+                                                d_backing_inode(dentry)->i_ino, -ret);
                         goto error;
                 }
         }
@@ -291,7 +291,7 @@ error:
 
 bad_type_length:
         pr_err("Cache object %lu xattr length incorrect\n",
-               dentry->d_inode->i_ino);
+               d_backing_inode(dentry)->i_ino);
         ret = -EIO;
         goto error;
 
@@ -316,7 +316,7 @@ int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
                         cachefiles_io_error(cache,
                                             "Can't remove xattr from %lu"
                                             " (error %d)",
-                                            dentry->d_inode->i_ino, -ret);
+                                            d_backing_inode(dentry)->i_ino, -ret);
         }
 
         _leave(" = %d", ret);