Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 466b77bc authored by David Howells's avatar David Howells Committed by Al Viro
Browse files

VFS: fs/cachefiles: d_backing_inode() annotations 



Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent dea655c2

fs/cachefiles/bind.c

+5 −5
Original line number Diff line number Diff line
@@ -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;

fs/cachefiles/interface.c

+1 −1
Original line number Diff line number Diff line
@@ -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;

fs/cachefiles/namei.c

+35 −35
Original line number Diff line number Diff line
@@ -355,7 +355,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache, 
		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 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, 
	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 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, 
			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 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, 
			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 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, 
			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 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, 
	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

fs/cachefiles/rdwr.c

+7 −7
Original line number Diff line number Diff line
@@ -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);

fs/cachefiles/security.c

+3 −3
Original line number Diff line number Diff line
@@ -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);