Fanotify cleanups
Subsystems (3)
Jan Kara
maintainerv2 cover Fanotify cleanups
Hello,
when fixing use-after-free bug with fanotify introduced by my previous
cleanup patches (the fix is already merged by Linus), I have better understood handling of permission events and found a couple of things that can be further cleaned up. This patch series uses the notify structure itself for processing response to permission event (patch 2/5) thus saving some space and allocation, converts access_mutex to spinlock (patch 3/5) which should be faster, and moves code around copy_event_to_user() to make code more readable (patch 4/5, 5/5).
The patches pass LTP fanotify tests. Andrew, can you please take the patches?
Changes since v1:
- rebased on top of latest fanotify fixes which went to Linus (3.13-rc5)
Honza
Jan Kara
maintainerPATCH v2 1/5 fanotify: Remove useless bypass_perm check
prepare_for_access_response() checks whether group->fanotify_data.bypass_perm is set. However this test can never be true because prepare_for_access_response() is called only from fanotify_read() which means fanotify group is alive with an active fd while bypass_perm is set from fanotify_release() when all file descriptors pointing to the group are closed and the group is going away.
--- fs/notify/fanotify/fanotify_user.c | 8 -------- 1 file changed, 8 deletions(-)
fs/notify/fanotify/fanotify_user.c +0 -8
@@ -211,14 +211,6 @@ static int prepare_for_access_response(struct fsnotify_group *group, re->fd = fd;mutex_lock (&group->fanotify_data.access_mutex); - -if (atomic_read (&group->fanotify_data.bypass_perm)) { -mutex_unlock (&group->fanotify_data.access_mutex); -kmem_cache_free (fanotify_response_event_cache, re); -FANOTIFY_E (event)->response =FAN_ALLOW ; -return 0 ; - } -list_add_tail (&re->list, &group->fanotify_data.access_list);mutex_unlock (&group->fanotify_data.access_mutex);
Signature · 1 line
1.8.1.4
Jan Kara
maintainerPATCH v2 2/5 fanotify: Use fanotify event structure for permission response processing
In reply to Jan KaraCurrently, fanotify creates new structure to track the fact that permission event has been reported to userspace and someone is waiting for a response to it. As event structures are now completely in the hands of each notification framework, we can use the event structure for this tracking instead of allocating a new structure.
Since this makes the event structures for normal events and permission events even more different and the structures have different lifetime rules, we split them into two separate structures (where permission event structure contains the structure for a normal event). This makes normal events 8 bytes smaller and the code a tad bit cleaner.
--- fs/notify/fanotify/fanotify.c | 63 +++++++++++++------ fs/notify/fanotify/fanotify.h | 34 ++++++++--- fs/notify/fanotify/fanotify_user.c | 120 +++++++++++++------------------------ 3 files changed, 113 insertions(+), 104 deletions(-)
fs/notify/fanotify/fanotify.c +45 -18
@@ -60,8 +60,8 @@ static int fanotify_merge(struct list_head *list, struct fsnotify_event *event) }#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS -static int fanotify_get_response_from_access (struct fsnotify_group *group, -struct fanotify_event_info *event) +static int fanotify_get_response (struct fsnotify_group *group, +struct fanotify_perm_event_info *event) {int ret;
@@ -142,6 +142,40 @@ static bool fanotify_should_send_event(struct fsnotify_mark *inode_mark,return false; } +struct fanotify_event_info *fanotify_alloc_event (struct inode *inode,u32 mask, +struct path *path) +{ +struct fanotify_event_info *event; + +#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS +if (mask &FAN_ALL_PERM_EVENTS ) { +struct fanotify_perm_event_info *pevent; + + pevent =kmem_cache_alloc (fanotify_perm_event_cachep, +GFP_KERNEL ); +if (!pevent) +return NULL ; + event = &pevent->fae; + pevent->response =0 ; + goto init; + } +#endif + event =kmem_cache_alloc (fanotify_event_cachep,GFP_KERNEL ); +if (!event) +return NULL ; +init:__maybe_unused +fsnotify_init_event (&event->fse, inode, mask); + event->tgid =get_pid (task_tgid (current)); +if (path) { + event->path = *path; +path_get (&event->path); + }else { + event->path.mnt =NULL ; + event->path.dentry =NULL ; + } +return event; +} + static int fanotify_handle_event(struct fsnotify_group *group, struct inode *inode, struct fsnotify_mark *inode_mark,
@@ -171,25 +205,11 @@ static int fanotify_handle_event(struct fsnotify_group *group,pr_debug ("%s: group=%p inode=%p mask=%x\n" , __func__, group, inode, mask); - event =kmem_cache_alloc (fanotify_event_cachep,GFP_KERNEL ); + event =fanotify_alloc_event (inode, mask, data);if (unlikely (!event))return -ENOMEM ; fsn_event = &event->fse; -fsnotify_init_event (fsn_event, inode, mask); - event->tgid =get_pid (task_tgid (current)); -if (data_type ==FSNOTIFY_EVENT_PATH ) { -struct path *path = data; - event->path = *path; -path_get (&event->path); - }else { - event->path.mnt =NULL ; - event->path.dentry =NULL ; - } -#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS - event->response =0 ; -#endif - ret =fsnotify_add_notify_event (group, fsn_event, fanotify_merge);if (ret) {/* Permission events shouldn't be merged */
@@ -202,7 +222,7 @@ static int fanotify_handle_event(struct fsnotify_group *group,#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS if (mask &FAN_ALL_PERM_EVENTS ) { - ret =fanotify_get_response_from_access (group, event); + ret =fanotify_get_response (group,FANOTIFY_PE (fsn_event));fsnotify_destroy_event (group, fsn_event); }#endif
@@ -225,6 +245,13 @@ static void fanotify_free_event(struct fsnotify_event *fsn_event) event =FANOTIFY_E (fsn_event);path_put (&event->path);put_pid (event->tgid); +#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS +if (fsn_event->mask &FAN_ALL_PERM_EVENTS ) { +kmem_cache_free (fanotify_perm_event_cachep, +FANOTIFY_PE (fsn_event)); +return ; + } +#endif kmem_cache_free (fanotify_event_cachep, event); }
fs/notify/fanotify/fanotify.h +27 -7
@@ -3,13 +3,12 @@#include <linux/slab.h> extern struct kmem_cache *fanotify_event_cachep; +extern struct kmem_cache *fanotify_perm_event_cachep;/* -* Lifetime of the structure differs for normal and permission events. In both -* cases the structure is allocated in fanotify_handle_event(). For normal -* events the structure is freed immediately after reporting it to userspace. -* For permission events we free it only after we receive response from -* userspace. +* Structure for normal fanotify events. It gets allocated in +* fanotify_handle_event() and freed when the information is retrieved by +* userspace */ struct fanotify_event_info {struct fsnotify_event fse;
@@ -19,12 +18,33 @@ struct fanotify_event_info {*/ struct path path;struct pid *tgid; +}; +#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS -u32 response;/* userspace answer to question */ -#endif +/* +* Structure for permission fanotify events. It gets allocated and freed in +* fanotify_handle_event() since we wait there for user response. When the +* information is retrieved by userspace the structure is moved from +* group->notification_list to group->fanotify_data.access_list to wait for +* user response. +*/ +struct fanotify_perm_event_info { +struct fanotify_event_info fae; +int response;/* userspace answer to question */ +int fd;/* fd we passed to userspace for this event */ }; +static inline struct fanotify_perm_event_info * +FANOTIFY_PE (struct fsnotify_event *fse) +{ + return container_of(fse, struct fanotify_perm_event_info, fae.fse); +} +#endif +static inline struct fanotify_event_info *FANOTIFY_E (struct fsnotify_event *fse) { return container_of(fse, struct fanotify_event_info, fse); } + +struct fanotify_event_info *fanotify_alloc_event (struct inode *inode,u32 mask, +struct path *path);
fs/notify/fanotify/fanotify_user.c +41 -79
211 lines not on this page · raw message
Signature · 1 line
1.8.1.4
Jan Kara
maintainerPATCH v2 3/5 fanotify: Convert access_mutex to spinlock
In reply to Jan Karaaccess_mutex is used only to guard operations on access_list. There's no need for sleeping within this lock so just make a spinlock out of it.
--- fs/notify/fanotify/fanotify_user.c | 14 +++++++------- include/linux/fsnotify_backend.h | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-)
fs/notify/fanotify/fanotify_user.c +7 -7
@@ -134,7 +134,7 @@ static struct fanotify_perm_event_info *dequeue_event( {struct fanotify_perm_event_info *event, *return_e =NULL ; -mutex_lock (&group->fanotify_data.access_mutex); +spin_lock (&group->fanotify_data.access_lock);list_for_each_entry (event, &group->fanotify_data.access_list, fae.fse.list) {if (event->fd != fd)
@@ -144,7 +144,7 @@ static struct fanotify_perm_event_info *dequeue_event( return_e = event;break ; } -mutex_unlock (&group->fanotify_data.access_mutex); +spin_unlock (&group->fanotify_data.access_lock);pr_debug ("%s: found return_re=%p\n" , __func__, return_e);
@@ -210,10 +210,10 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS if (event->mask &FAN_ALL_PERM_EVENTS ) {FANOTIFY_PE (event)->fd = fd; -mutex_lock (&group->fanotify_data.access_mutex); +spin_lock (&group->fanotify_data.access_lock);list_add_tail (&event->fae.fse.list, &group->fanotify_data.access_list); -mutex_unlock (&group->fanotify_data.access_mutex); +spin_unlock (&group->fanotify_data.access_lock); }#endif
@@ -343,7 +343,7 @@ static int fanotify_release(struct inode *ignored, struct file *file)#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS struct fanotify_perm_event_info *event, *next; -mutex_lock (&group->fanotify_data.access_mutex); +spin_lock (&group->fanotify_data.access_lock);atomic_inc (&group->fanotify_data.bypass_perm);
@@ -355,7 +355,7 @@ static int fanotify_release(struct inode *ignored, struct file *file)list_del_init (&event->fae.fse.list); event->response = FAN_ALLOW; } -mutex_unlock (&group->fanotify_data.access_mutex); +spin_unlock (&group->fanotify_data.access_lock);wake_up (&group->fanotify_data.access_waitq);#endif
@@ -697,7 +697,7 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags) group->fanotify_data.f_flags = event_f_flags;#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS -mutex_init (&group->fanotify_data.access_mutex); +spin_lock_init (&group->fanotify_data.access_lock);init_waitqueue_head (&group->fanotify_data.access_waitq);INIT_LIST_HEAD (&group->fanotify_data.access_list);atomic_set (&group->fanotify_data.bypass_perm,0 );
include/linux/fsnotify_backend.h +1 -1
@@ -178,7 +178,7 @@ struct fsnotify_group {struct fanotify_group_private_data {#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS /* allows a group to block waiting for a userspace response */ -struct mutex access_mutex; +spinlock_t access_lock;struct list_head access_list;wait_queue_head_t access_waitq;atomic_t bypass_perm;
Signature · 1 line
1.8.1.4
Jan Kara
maintainerPATCH v2 4/5 fanotify: Reorganize loop in fanotify_read()
In reply to Jan KaraSwap the error / "read ok" branches in the main loop of fanotify_read(). We will grow the "read ok" part in the next patch and this makes the indentation easier. Also it is more common to have error conditions inside an 'if' instead of the fast path.
--- fs/notify/fanotify/fanotify_user.c | 46 ++++++++++++++++++++------------------ 1 file changed, 24 insertions(+), 22 deletions(-)
fs/notify/fanotify/fanotify_user.c +24 -22
@@ -272,35 +272,37 @@ static ssize_t fanotify_read(struct file *file, char __user *buf, kevent =get_one_event (group, count);mutex_unlock (&group->notification_mutex); -if (kevent) { +if (IS_ERR (kevent)) { ret =PTR_ERR (kevent); -if (IS_ERR (kevent)) +break ; + } + +if (!kevent) { + ret = -EAGAIN ; +if (file->f_flags &O_NONBLOCK )break ; - ret =copy_event_to_user (group, kevent, buf); -/* -* Permission events get queued to wait for response. -* Other events can be destroyed now. -*/ -if (!(kevent->mask &FAN_ALL_PERM_EVENTS )) -fsnotify_destroy_event (group, kevent); -if (ret <0 ) + + ret = -ERESTARTSYS ; +if (signal_pending (current)) +break ; + +if (start != buf)break ; - buf += ret; - count -= ret; +schedule ();continue ; } - ret = -EAGAIN ; -if (file->f_flags &O_NONBLOCK ) -break ; - ret = -ERESTARTSYS ; -if (signal_pending (current)) -break ; - -if (start != buf) + ret =copy_event_to_user (group, kevent, buf); +/* +* Permission events get queued to wait for response. Other +* events can be destroyed now. +*/ +if (!(kevent->mask &FAN_ALL_PERM_EVENTS )) +fsnotify_destroy_event (group, kevent); +if (ret <0 )break ; - -schedule (); + buf += ret; + count -= ret; }finish_wait (&group->notification_waitq, &wait);
Signature · 1 line
1.8.1.4
Jan Kara
maintainerPATCH v2 5/5 fanotify: Move unrelated handling from copy_event_to_user()
In reply to Jan KaraMove code moving event structure to access_list from copy_event_to_user() to fanotify_read() where it is more logical (so that we can immediately see in the main loop that we either move the event to a different list or free it). Also move special error handling for permission events from copy_event_to_user() to the main loop to have it in one place with error handling for normal events. This makes copy_event_to_user() really only copy the event to user without any side effects.
--- fs/notify/fanotify/fanotify_user.c | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-)
fs/notify/fanotify/fanotify_user.c +18 -17
@@ -199,7 +199,7 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group, ret =fill_event_metadata (group, &fanotify_event_metadata, event, &f);if (ret <0 ) - goto out; +return ret; fd = fanotify_event_metadata.fd; ret = -EFAULT ;
@@ -208,13 +208,8 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group, goto out_close_fd;#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS -if (event->mask &FAN_ALL_PERM_EVENTS ) { +if (event->mask &FAN_ALL_PERM_EVENTS )FANOTIFY_PE (event)->fd = fd; -spin_lock (&group->fanotify_data.access_lock); -list_add_tail (&event->fae.fse.list, - &group->fanotify_data.access_list); -spin_unlock (&group->fanotify_data.access_lock); - }#endif if (fd !=FAN_NOFD )
@@ -226,13 +221,6 @@ out_close_fd:put_unused_fd (fd);fput (f); } -out: -#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS -if (event->mask &FAN_ALL_PERM_EVENTS ) { -FANOTIFY_PE (event)->response =FAN_DENY ; -wake_up (&group->fanotify_data.access_waitq); - } -#endif return ret; }
@@ -297,10 +285,23 @@ static ssize_t fanotify_read(struct file *file, char __user *buf,* Permission events get queued to wait for response. Other * events can be destroyed now. */ -if (!(kevent->mask &FAN_ALL_PERM_EVENTS )) +if (!(kevent->mask &FAN_ALL_PERM_EVENTS )) {fsnotify_destroy_event (group, kevent); -if (ret <0 ) -break ; +if (ret <0 ) +break ; + }else { +#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS +if (ret <0 ) { +FANOTIFY_PE (kevent)->response =FAN_DENY ; +wake_up (&group->fanotify_data.access_waitq); +break ; + } +spin_lock (&group->fanotify_data.access_lock); +list_add_tail (&kevent->list, + &group->fanotify_data.access_list); +spin_unlock (&group->fanotify_data.access_lock); +#endif + } buf += ret; count -= ret; }
Signature · 1 line
1.8.1.4