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>

diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c
index fbb08e97438d36eb0bc783386bf68d1521fb9a81..6af790fc3df8a163249b7863d443fc7ab2ae4e9d 100644 (file)
--- 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 f1fb0a21bb5a75f26cffb0efc00f243533d13d38..afa023dded5be937ddd713847b37f2d165f586be 100644 (file)
--- 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 61396359863f2eeef4bb4e6eb3031e63d7030da4..ab857ab9f40d91a375a31030e1872f9ebd704837 100644 (file)
--- 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 c6cd8d7a4eef91b379efc75888a94eba6345ac33..3cbb0e834694131d461c927fddb2340b72755415 100644 (file)
--- 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 396c18ea2764116cd9aade503f11348b16c59b11..31bbc0528b1173fcc56cd4e74863d8eb106d1f8a 100644 (file)
--- 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 a8a68745e11d45b0c093501e359d1190546f788b..d31c1a72d8a5ba90255ff7537a824b9c8036b749 100644 (file)
--- 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);