]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - fs/notify/fanotify/fanotify.c
fanotify: fix missing break
[~shefty/rdma-dev.git] / fs / notify / fanotify / fanotify.c
1 #include <linux/fanotify.h>
2 #include <linux/fdtable.h>
3 #include <linux/fsnotify_backend.h>
4 #include <linux/init.h>
5 #include <linux/jiffies.h>
6 #include <linux/kernel.h> /* UINT_MAX */
7 #include <linux/mount.h>
8 #include <linux/sched.h>
9 #include <linux/types.h>
10 #include <linux/wait.h>
11
12 static bool should_merge(struct fsnotify_event *old, struct fsnotify_event *new)
13 {
14         pr_debug("%s: old=%p new=%p\n", __func__, old, new);
15
16         if (old->to_tell == new->to_tell &&
17             old->data_type == new->data_type &&
18             old->tgid == new->tgid) {
19                 switch (old->data_type) {
20                 case (FSNOTIFY_EVENT_PATH):
21                         if ((old->path.mnt == new->path.mnt) &&
22                             (old->path.dentry == new->path.dentry))
23                                 return true;
24                         break;
25                 case (FSNOTIFY_EVENT_NONE):
26                         return true;
27                 default:
28                         BUG();
29                 };
30         }
31         return false;
32 }
33
34 /* and the list better be locked by something too! */
35 static struct fsnotify_event *fanotify_merge(struct list_head *list,
36                                              struct fsnotify_event *event)
37 {
38         struct fsnotify_event_holder *test_holder;
39         struct fsnotify_event *test_event = NULL;
40         struct fsnotify_event *new_event;
41
42         pr_debug("%s: list=%p event=%p\n", __func__, list, event);
43
44
45         list_for_each_entry_reverse(test_holder, list, event_list) {
46                 if (should_merge(test_holder->event, event)) {
47                         test_event = test_holder->event;
48                         break;
49                 }
50         }
51
52         if (!test_event)
53                 return NULL;
54
55         fsnotify_get_event(test_event);
56
57         /* if they are exactly the same we are done */
58         if (test_event->mask == event->mask)
59                 return test_event;
60
61         /*
62          * if the refcnt == 2 this is the only queue
63          * for this event and so we can update the mask
64          * in place.
65          */
66         if (atomic_read(&test_event->refcnt) == 2) {
67                 test_event->mask |= event->mask;
68                 return test_event;
69         }
70
71         new_event = fsnotify_clone_event(test_event);
72
73         /* done with test_event */
74         fsnotify_put_event(test_event);
75
76         /* couldn't allocate memory, merge was not possible */
77         if (unlikely(!new_event))
78                 return ERR_PTR(-ENOMEM);
79
80         /* build new event and replace it on the list */
81         new_event->mask = (test_event->mask | event->mask);
82         fsnotify_replace_event(test_holder, new_event);
83
84         /* we hold a reference on new_event from clone_event */
85         return new_event;
86 }
87
88 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
89 static int fanotify_get_response_from_access(struct fsnotify_group *group,
90                                              struct fsnotify_event *event)
91 {
92         int ret;
93
94         pr_debug("%s: group=%p event=%p\n", __func__, group, event);
95
96         wait_event(group->fanotify_data.access_waitq, event->response ||
97                                 atomic_read(&group->fanotify_data.bypass_perm));
98
99         if (!event->response) /* bypass_perm set */
100                 return 0;
101
102         /* userspace responded, convert to something usable */
103         spin_lock(&event->lock);
104         switch (event->response) {
105         case FAN_ALLOW:
106                 ret = 0;
107                 break;
108         case FAN_DENY:
109         default:
110                 ret = -EPERM;
111         }
112         event->response = 0;
113         spin_unlock(&event->lock);
114
115         pr_debug("%s: group=%p event=%p about to return ret=%d\n", __func__,
116                  group, event, ret);
117         
118         return ret;
119 }
120 #endif
121
122 static int fanotify_handle_event(struct fsnotify_group *group,
123                                  struct fsnotify_mark *inode_mark,
124                                  struct fsnotify_mark *fanotify_mark,
125                                  struct fsnotify_event *event)
126 {
127         int ret = 0;
128         struct fsnotify_event *notify_event = NULL;
129
130         BUILD_BUG_ON(FAN_ACCESS != FS_ACCESS);
131         BUILD_BUG_ON(FAN_MODIFY != FS_MODIFY);
132         BUILD_BUG_ON(FAN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE);
133         BUILD_BUG_ON(FAN_CLOSE_WRITE != FS_CLOSE_WRITE);
134         BUILD_BUG_ON(FAN_OPEN != FS_OPEN);
135         BUILD_BUG_ON(FAN_EVENT_ON_CHILD != FS_EVENT_ON_CHILD);
136         BUILD_BUG_ON(FAN_Q_OVERFLOW != FS_Q_OVERFLOW);
137         BUILD_BUG_ON(FAN_OPEN_PERM != FS_OPEN_PERM);
138         BUILD_BUG_ON(FAN_ACCESS_PERM != FS_ACCESS_PERM);
139         BUILD_BUG_ON(FAN_ONDIR != FS_ISDIR);
140
141         pr_debug("%s: group=%p event=%p\n", __func__, group, event);
142
143         notify_event = fsnotify_add_notify_event(group, event, NULL, fanotify_merge);
144         if (IS_ERR(notify_event))
145                 return PTR_ERR(notify_event);
146
147 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
148         if (event->mask & FAN_ALL_PERM_EVENTS) {
149                 /* if we merged we need to wait on the new event */
150                 if (notify_event)
151                         event = notify_event;
152                 ret = fanotify_get_response_from_access(group, event);
153         }
154 #endif
155
156         if (notify_event)
157                 fsnotify_put_event(notify_event);
158
159         return ret;
160 }
161
162 static bool fanotify_should_send_event(struct fsnotify_group *group,
163                                        struct inode *to_tell,
164                                        struct fsnotify_mark *inode_mark,
165                                        struct fsnotify_mark *vfsmnt_mark,
166                                        __u32 event_mask, void *data, int data_type)
167 {
168         __u32 marks_mask, marks_ignored_mask;
169         struct path *path = data;
170
171         pr_debug("%s: group=%p to_tell=%p inode_mark=%p vfsmnt_mark=%p "
172                  "mask=%x data=%p data_type=%d\n", __func__, group, to_tell,
173                  inode_mark, vfsmnt_mark, event_mask, data, data_type);
174
175         /* if we don't have enough info to send an event to userspace say no */
176         if (data_type != FSNOTIFY_EVENT_PATH)
177                 return false;
178
179         /* sorry, fanotify only gives a damn about files and dirs */
180         if (!S_ISREG(path->dentry->d_inode->i_mode) &&
181             !S_ISDIR(path->dentry->d_inode->i_mode))
182                 return false;
183
184         if (inode_mark && vfsmnt_mark) {
185                 marks_mask = (vfsmnt_mark->mask | inode_mark->mask);
186                 marks_ignored_mask = (vfsmnt_mark->ignored_mask | inode_mark->ignored_mask);
187         } else if (inode_mark) {
188                 /*
189                  * if the event is for a child and this inode doesn't care about
190                  * events on the child, don't send it!
191                  */
192                 if ((event_mask & FS_EVENT_ON_CHILD) &&
193                     !(inode_mark->mask & FS_EVENT_ON_CHILD))
194                         return false;
195                 marks_mask = inode_mark->mask;
196                 marks_ignored_mask = inode_mark->ignored_mask;
197         } else if (vfsmnt_mark) {
198                 marks_mask = vfsmnt_mark->mask;
199                 marks_ignored_mask = vfsmnt_mark->ignored_mask;
200         } else {
201                 BUG();
202         }
203
204         if (S_ISDIR(path->dentry->d_inode->i_mode) &&
205             (marks_ignored_mask & FS_ISDIR))
206                 return false;
207
208         if (event_mask & marks_mask & ~marks_ignored_mask)
209                 return true;
210
211         return false;
212 }
213
214 static void fanotify_free_group_priv(struct fsnotify_group *group)
215 {
216         struct user_struct *user;
217
218         user = group->fanotify_data.user;
219         atomic_dec(&user->fanotify_listeners);
220         free_uid(user);
221 }
222
223 const struct fsnotify_ops fanotify_fsnotify_ops = {
224         .handle_event = fanotify_handle_event,
225         .should_send_event = fanotify_should_send_event,
226         .free_group_priv = fanotify_free_group_priv,
227         .free_event_priv = NULL,
228         .freeing_mark = NULL,
229 };