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

Commit 36f10f55 authored by Amir Goldstein's avatar Amir Goldstein Committed by Jan Kara
Browse files

fsnotify: let connector point to an abstract object 



Make the code to attach/detach a connector to object more generic
by letting the fsnotify connector point to an abstract fsnotify_connp_t.
Code that needs to dereference an inode or mount object now uses the
helpers fsnotify_conn_{inode,mount}.

Signed-off-by: default avatarAmir Goldstein <amir73il@gmail.com>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
parent b812a9f5

fs/notify/fdinfo.c

+4 −4
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ 
#include <linux/exportfs.h>



#include "inotify/inotify.h"

#include "../fs/mount.h"

#include "fsnotify.h"



#if defined(CONFIG_PROC_FS)
@@ -81,7 +81,7 @@ static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark) 
		return;



	inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);

	inode = igrab(mark->connector->inode);

	inode = igrab(fsnotify_conn_inode(mark->connector));

	if (inode) {

		/*

		 * IN_ALL_EVENTS represents all of the mask bits
@@ -117,7 +117,7 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark) 
		mflags |= FAN_MARK_IGNORED_SURV_MODIFY;



	if (mark->connector->type == FSNOTIFY_OBJ_TYPE_INODE) {

		inode = igrab(mark->connector->inode);

		inode = igrab(fsnotify_conn_inode(mark->connector));

		if (!inode)

			return;

		seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
@@ -127,7 +127,7 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark) 
		seq_putc(m, '\n');

		iput(inode);

	} else if (mark->connector->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {

		struct mount *mnt = real_mount(mark->connector->mnt);

		struct mount *mnt = fsnotify_conn_mount(mark->connector);



		seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",

			   mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);

fs/notify/fsnotify.h

+6 −4
Original line number Diff line number Diff line
@@ -9,14 +9,16 @@ 


#include "../mount.h"



static inline struct inode *fsnotify_obj_inode(fsnotify_connp_t *connp)

static inline struct inode *fsnotify_conn_inode(

				struct fsnotify_mark_connector *conn)

{

	return container_of(connp, struct inode, i_fsnotify_marks);

	return container_of(conn->obj, struct inode, i_fsnotify_marks);

}



static inline struct mount *fsnotify_obj_mount(fsnotify_connp_t *connp)

static inline struct mount *fsnotify_conn_mount(

				struct fsnotify_mark_connector *conn)

{

	return container_of(connp, struct mount, mnt_fsnotify_marks);

	return container_of(conn->obj, struct mount, mnt_fsnotify_marks);

}



/* destroy all events sitting in this groups notification queue */

fs/notify/mark.c

+16 −16
Original line number Diff line number Diff line
@@ -120,14 +120,14 @@ static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn) 
			new_mask |= mark->mask;

	}

	if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)

		conn->inode->i_fsnotify_mask = new_mask;

		fsnotify_conn_inode(conn)->i_fsnotify_mask = new_mask;

	else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT)

		real_mount(conn->mnt)->mnt_fsnotify_mask = new_mask;

		fsnotify_conn_mount(conn)->mnt_fsnotify_mask = new_mask;

}



/*

 * Calculate mask of events for a list of marks. The caller must make sure

 * connector and connector->inode cannot disappear under us.  Callers achieve

 * connector and connector->obj cannot disappear under us.  Callers achieve

 * this by holding a mark->lock or mark->group->mark_mutex for a mark on this

 * list.

 */
@@ -140,7 +140,8 @@ void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn) 
	__fsnotify_recalc_mask(conn);

	spin_unlock(&conn->lock);

	if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)

		__fsnotify_update_child_dentry_flags(conn->inode);

		__fsnotify_update_child_dentry_flags(

					fsnotify_conn_inode(conn));

}



/* Free all connectors queued for freeing once SRCU period ends */
@@ -166,20 +167,20 @@ static struct inode *fsnotify_detach_connector_from_object( 
{

	struct inode *inode = NULL;



	if (conn->type == FSNOTIFY_OBJ_TYPE_DETACHED)

		return NULL;



	if (conn->type == FSNOTIFY_OBJ_TYPE_INODE) {

		inode = conn->inode;

		rcu_assign_pointer(inode->i_fsnotify_marks, NULL);

		inode = fsnotify_conn_inode(conn);

		inode->i_fsnotify_mask = 0;

		conn->inode = NULL;

		conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;

	} else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {

		rcu_assign_pointer(real_mount(conn->mnt)->mnt_fsnotify_marks,

				   NULL);

		real_mount(conn->mnt)->mnt_fsnotify_mask = 0;

		conn->mnt = NULL;

		conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;

		fsnotify_conn_mount(conn)->mnt_fsnotify_mask = 0;

	}



	rcu_assign_pointer(*(conn->obj), NULL);

	conn->obj = NULL;

	conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;



	return inode;

}
@@ -448,10 +449,9 @@ static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp, 
	spin_lock_init(&conn->lock);

	INIT_HLIST_HEAD(&conn->list);

	conn->type = type;

	conn->obj = connp;

	if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)

		inode = conn->inode = igrab(fsnotify_obj_inode(connp));

	else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT)

		conn->mnt = &fsnotify_obj_mount(connp)->mnt;

		inode = igrab(fsnotify_conn_inode(conn));

	/*

	 * cmpxchg() provides the barrier so that readers of *connp can see

	 * only initialized structure

include/linux/fsnotify_backend.h

+10 −5
Original line number Diff line number Diff line
@@ -255,6 +255,13 @@ FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT) 
#define fsnotify_foreach_obj_type(type) \

	for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)



/*

 * fsnotify_connp_t is what we embed in objects which connector can be attached

 * to. fsnotify_connp_t * is how we refer from connector back to object.

 */

struct fsnotify_mark_connector;

typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;



/*

 * Inode / vfsmount point to this structure which tracks all marks attached to

 * the inode / vfsmount. The reference to inode / vfsmount is held by this
@@ -264,17 +271,15 @@ FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT) 
struct fsnotify_mark_connector {

	spinlock_t lock;

	unsigned int type;	/* Type of object [lock] */

	union {	/* Object pointer [lock] */

		struct inode *inode;

		struct vfsmount *mnt;

	union {

		/* Object pointer [lock] */

		fsnotify_connp_t *obj;

		/* Used listing heads to free after srcu period expires */

		struct fsnotify_mark_connector *destroy_next;

	};

	struct hlist_head list;

};



typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;



/*

 * A mark is simply an object attached to an in core inode which allows an

 * fsnotify listener to indicate they are either no longer interested in events

kernel/audit_tree.c

+9 −8
Original line number Diff line number Diff line
@@ -168,7 +168,8 @@ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock); 
/* Function to return search key in our hash from inode. */

static unsigned long inode_to_key(const struct inode *inode)

{

	return (unsigned long)inode;

	/* Use address pointed to by connector->obj as the key */

	return (unsigned long)&inode->i_fsnotify_marks;

}



/*
@@ -183,7 +184,7 @@ static unsigned long chunk_to_key(struct audit_chunk *chunk) 
	 */

	if (WARN_ON_ONCE(!chunk->mark.connector))

		return 0;

	return (unsigned long)chunk->mark.connector->inode;

	return (unsigned long)chunk->mark.connector->obj;

}



static inline struct list_head *chunk_hash(unsigned long key)
@@ -258,7 +259,7 @@ static void untag_chunk(struct node *p) 
	spin_lock(&entry->lock);

	/*

	 * mark_mutex protects mark from getting detached and thus also from

	 * mark->connector->inode getting NULL.

	 * mark->connector->obj getting NULL.

	 */

	if (chunk->dead || !(entry->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {

		spin_unlock(&entry->lock);
@@ -288,8 +289,8 @@ static void untag_chunk(struct node *p) 
	if (!new)

		goto Fallback;



	if (fsnotify_add_inode_mark_locked(&new->mark, entry->connector->inode,

					   1)) {

	if (fsnotify_add_mark_locked(&new->mark, entry->connector->obj,

				     FSNOTIFY_OBJ_TYPE_INODE, 1)) {

		fsnotify_put_mark(&new->mark);

		goto Fallback;

	}
@@ -423,7 +424,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree) 
	spin_lock(&old_entry->lock);

	/*

	 * mark_mutex protects mark from getting detached and thus also from

	 * mark->connector->inode getting NULL.

	 * mark->connector->obj getting NULL.

	 */

	if (!(old_entry->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {

		/* old_entry is being shot, lets just lie */
@@ -434,8 +435,8 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree) 
		return -ENOENT;

	}



	if (fsnotify_add_inode_mark_locked(chunk_entry,

			     old_entry->connector->inode, 1)) {

	if (fsnotify_add_mark_locked(chunk_entry, old_entry->connector->obj,

				     FSNOTIFY_OBJ_TYPE_INODE, 1)) {

		spin_unlock(&old_entry->lock);

		mutex_unlock(&old_entry->group->mark_mutex);

		fsnotify_put_mark(chunk_entry);