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

Commit 75c3cfa8 authored by David Howells's avatar David Howells Committed by Al Viro
Browse files

VFS: assorted weird filesystems: d_inode() annotations 



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

arch/ia64/kernel/perfmon.c

+1 −1
Original line number Diff line number Diff line
@@ -2159,7 +2159,7 @@ static const struct file_operations pfm_file_ops = { 
static char *pfmfs_dname(struct dentry *dentry, char *buffer, int buflen)

{

	return dynamic_dname(dentry, buffer, buflen, "pfm:[%lu]",

			     dentry->d_inode->i_ino);

			     d_inode(dentry)->i_ino);

}



static const struct dentry_operations pfmfs_dentry_operations = {

arch/powerpc/platforms/cell/spufs/inode.c

+11 −11
Original line number Diff line number Diff line
@@ -111,7 +111,7 @@ spufs_new_inode(struct super_block *sb, umode_t mode) 
static int

spufs_setattr(struct dentry *dentry, struct iattr *attr)

{

	struct inode *inode = dentry->d_inode;

	struct inode *inode = d_inode(dentry);



	if ((attr->ia_valid & ATTR_SIZE) &&

	    (attr->ia_size != inode->i_size))
@@ -163,14 +163,14 @@ static void spufs_prune_dir(struct dentry *dir) 
{

	struct dentry *dentry, *tmp;



	mutex_lock(&dir->d_inode->i_mutex);

	mutex_lock(&d_inode(dir)->i_mutex);

	list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {

		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(dir->d_inode, dentry);

			simple_unlink(d_inode(dir), dentry);

			/* XXX: what was dcache_lock protecting here? Other

			 * filesystems (IB, configfs) release dcache_lock

			 * before unlink */
@@ -180,7 +180,7 @@ static void spufs_prune_dir(struct dentry *dir) 
		}

	}

	shrink_dcache_parent(dir);

	mutex_unlock(&dir->d_inode->i_mutex);

	mutex_unlock(&d_inode(dir)->i_mutex);

}



/* Caller must hold parent->i_mutex */
@@ -192,7 +192,7 @@ static int spufs_rmdir(struct inode *parent, struct dentry *dir) 
	d_drop(dir);

	res = simple_rmdir(parent, dir);

	/* We have to give up the mm_struct */

	spu_forget(SPUFS_I(dir->d_inode)->i_ctx);

	spu_forget(SPUFS_I(d_inode(dir))->i_ctx);

	return res;

}
@@ -222,8 +222,8 @@ static int spufs_dir_close(struct inode *inode, struct file *file) 
	int ret;



	dir = file->f_path.dentry;

	parent = dir->d_parent->d_inode;

	ctx = SPUFS_I(dir->d_inode)->i_ctx;

	parent = d_inode(dir->d_parent);

	ctx = SPUFS_I(d_inode(dir))->i_ctx;



	mutex_lock_nested(&parent->i_mutex, I_MUTEX_PARENT);

	ret = spufs_rmdir(parent, dir);
@@ -460,7 +460,7 @@ spufs_create_context(struct inode *inode, struct dentry *dentry, 
		goto out_aff_unlock;



	if (affinity) {

		spufs_set_affinity(flags, SPUFS_I(dentry->d_inode)->i_ctx,

		spufs_set_affinity(flags, SPUFS_I(d_inode(dentry))->i_ctx,

								neighbor);

		if (neighbor)

			put_spu_context(neighbor);
@@ -504,7 +504,7 @@ spufs_mkgang(struct inode *dir, struct dentry *dentry, umode_t mode) 


	d_instantiate(dentry, inode);

	inc_nlink(dir);

	inc_nlink(dentry->d_inode);

	inc_nlink(d_inode(dentry));

	return ret;



out_iput:
@@ -561,7 +561,7 @@ static struct file_system_type spufs_type; 
long spufs_create(struct path *path, struct dentry *dentry,

		unsigned int flags, umode_t mode, struct file *filp)

{

	struct inode *dir = path->dentry->d_inode;

	struct inode *dir = d_inode(path->dentry);

	int ret;



	/* check if we are on spufs */

arch/s390/hypfs/inode.c

+9 −9
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ static struct dentry *hypfs_last_dentry; 
static void hypfs_update_update(struct super_block *sb)

{

	struct hypfs_sb_info *sb_info = sb->s_fs_info;

	struct inode *inode = sb_info->update_file->d_inode;

	struct inode *inode = d_inode(sb_info->update_file);



	sb_info->last_update = get_seconds();

	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
@@ -64,7 +64,7 @@ static void hypfs_add_dentry(struct dentry *dentry) 


static inline int hypfs_positive(struct dentry *dentry)

{

	return dentry->d_inode && !d_unhashed(dentry);

	return d_really_is_positive(dentry) && !d_unhashed(dentry);

}



static void hypfs_remove(struct dentry *dentry)
@@ -72,16 +72,16 @@ static void hypfs_remove(struct dentry *dentry) 
	struct dentry *parent;



	parent = dentry->d_parent;

	mutex_lock(&parent->d_inode->i_mutex);

	mutex_lock(&d_inode(parent)->i_mutex);

	if (hypfs_positive(dentry)) {

		if (d_is_dir(dentry))

			simple_rmdir(parent->d_inode, dentry);

			simple_rmdir(d_inode(parent), dentry);

		else

			simple_unlink(parent->d_inode, dentry);

			simple_unlink(d_inode(parent), dentry);

	}

	d_delete(dentry);

	dput(dentry);

	mutex_unlock(&parent->d_inode->i_mutex);

	mutex_unlock(&d_inode(parent)->i_mutex);

}



static void hypfs_delete_tree(struct dentry *root)
@@ -336,7 +336,7 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name, 
	struct dentry *dentry;

	struct inode *inode;



	mutex_lock(&parent->d_inode->i_mutex);

	mutex_lock(&d_inode(parent)->i_mutex);

	dentry = lookup_one_len(name, parent, strlen(name));

	if (IS_ERR(dentry)) {

		dentry = ERR_PTR(-ENOMEM);
@@ -357,14 +357,14 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name, 
	} else if (S_ISDIR(mode)) {

		inode->i_op = &simple_dir_inode_operations;

		inode->i_fop = &simple_dir_operations;

		inc_nlink(parent->d_inode);

		inc_nlink(d_inode(parent));

	} else

		BUG();

	inode->i_private = data;

	d_instantiate(dentry, inode);

	dget(dentry);

fail:

	mutex_unlock(&parent->d_inode->i_mutex);

	mutex_unlock(&d_inode(parent)->i_mutex);

	return dentry;

}

drivers/base/devtmpfs.c

+16 −16
Original line number Diff line number Diff line
@@ -157,10 +157,10 @@ static int dev_mkdir(const char *name, umode_t mode) 
	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	err = vfs_mkdir(path.dentry->d_inode, dentry, mode);

	err = vfs_mkdir(d_inode(path.dentry), dentry, mode);

	if (!err)

		/* mark as kernel-created inode */

		dentry->d_inode->i_private = &thread;

		d_inode(dentry)->i_private = &thread;

	done_path_create(&path, dentry);

	return err;

}
@@ -207,7 +207,7 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid, 
	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	err = vfs_mknod(path.dentry->d_inode, dentry, mode, dev->devt);

	err = vfs_mknod(d_inode(path.dentry), dentry, mode, dev->devt);

	if (!err) {

		struct iattr newattrs;
@@ -215,12 +215,12 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid, 
		newattrs.ia_uid = uid;

		newattrs.ia_gid = gid;

		newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID;

		mutex_lock(&dentry->d_inode->i_mutex);

		mutex_lock(&d_inode(dentry)->i_mutex);

		notify_change(dentry, &newattrs, NULL);

		mutex_unlock(&dentry->d_inode->i_mutex);

		mutex_unlock(&d_inode(dentry)->i_mutex);



		/* mark as kernel-created inode */

		dentry->d_inode->i_private = &thread;

		d_inode(dentry)->i_private = &thread;

	}

	done_path_create(&path, dentry);

	return err;
@@ -235,16 +235,16 @@ static int dev_rmdir(const char *name) 
	dentry = kern_path_locked(name, &parent);

	if (IS_ERR(dentry))

		return PTR_ERR(dentry);

	if (dentry->d_inode) {

		if (dentry->d_inode->i_private == &thread)

			err = vfs_rmdir(parent.dentry->d_inode, dentry);

	if (d_really_is_positive(dentry)) {

		if (d_inode(dentry)->i_private == &thread)

			err = vfs_rmdir(d_inode(parent.dentry), dentry);

		else

			err = -EPERM;

	} else {

		err = -ENOENT;

	}

	dput(dentry);

	mutex_unlock(&parent.dentry->d_inode->i_mutex);

	mutex_unlock(&d_inode(parent.dentry)->i_mutex);

	path_put(&parent);

	return err;

}
@@ -306,11 +306,11 @@ static int handle_remove(const char *nodename, struct device *dev) 
	if (IS_ERR(dentry))

		return PTR_ERR(dentry);



	if (dentry->d_inode) {

	if (d_really_is_positive(dentry)) {

		struct kstat stat;

		struct path p = {.mnt = parent.mnt, .dentry = dentry};

		err = vfs_getattr(&p, &stat);

		if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {

		if (!err && dev_mynode(dev, d_inode(dentry), &stat)) {

			struct iattr newattrs;

			/*

			 * before unlinking this node, reset permissions
@@ -321,10 +321,10 @@ static int handle_remove(const char *nodename, struct device *dev) 
			newattrs.ia_mode = stat.mode & ~0777;

			newattrs.ia_valid =

				ATTR_UID|ATTR_GID|ATTR_MODE;

			mutex_lock(&dentry->d_inode->i_mutex);

			mutex_lock(&d_inode(dentry)->i_mutex);

			notify_change(dentry, &newattrs, NULL);

			mutex_unlock(&dentry->d_inode->i_mutex);

			err = vfs_unlink(parent.dentry->d_inode, dentry, NULL);

			mutex_unlock(&d_inode(dentry)->i_mutex);

			err = vfs_unlink(d_inode(parent.dentry), dentry, NULL);

			if (!err || err == -ENOENT)

				deleted = 1;

		}
@@ -332,7 +332,7 @@ static int handle_remove(const char *nodename, struct device *dev) 
		err = -ENOENT;

	}

	dput(dentry);

	mutex_unlock(&parent.dentry->d_inode->i_mutex);

	mutex_unlock(&d_inode(parent.dentry)->i_mutex);



	path_put(&parent);

	if (deleted && strchr(nodename, '/'))

drivers/block/drbd/drbd_debugfs.c

+4 −4
Original line number Diff line number Diff line
@@ -424,7 +424,7 @@ static int in_flight_summary_show(struct seq_file *m, void *pos) 
 * So we have our own inline version of it above.  :-( */

static inline int debugfs_positive(struct dentry *dentry)

{

        return dentry->d_inode && !d_unhashed(dentry);

        return d_really_is_positive(dentry) && !d_unhashed(dentry);

}



/* make sure at *open* time that the respective object won't go away. */
@@ -439,15 +439,15 @@ static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, vo 
	 * or has debugfs_remove() already been called? */

	parent = file->f_path.dentry->d_parent;

	/* not sure if this can happen: */

	if (!parent || !parent->d_inode)

	if (!parent || d_really_is_negative(parent))

		goto out;

	/* serialize with d_delete() */

	mutex_lock(&parent->d_inode->i_mutex);

	mutex_lock(&d_inode(parent)->i_mutex);

	/* Make sure the object is still alive */

	if (debugfs_positive(file->f_path.dentry)

	&& kref_get_unless_zero(kref))

		ret = 0;

	mutex_unlock(&parent->d_inode->i_mutex);

	mutex_unlock(&d_inode(parent)->i_mutex);

	if (!ret) {

		ret = single_open(file, show, data);

		if (ret)