fsnotify: store struct file not struct path
[sfrench/cifs-2.6.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_FILE):
21                         if ((old->file->f_path.mnt == new->file->f_path.mnt) &&
22                             (old->file->f_path.dentry == new->file->f_path.dentry))
23                                 return true;
24                 case (FSNOTIFY_EVENT_NONE):
25                         return true;
26                 default:
27                         BUG();
28                 };
29         }
30         return false;
31 }
32
33 /* and the list better be locked by something too! */
34 static struct fsnotify_event *fanotify_merge(struct list_head *list,
35                                              struct fsnotify_event *event)
36 {
37         struct fsnotify_event_holder *test_holder;
38         struct fsnotify_event *test_event = NULL;
39         struct fsnotify_event *new_event;
40
41         pr_debug("%s: list=%p event=%p\n", __func__, list, event);
42
43
44         list_for_each_entry_reverse(test_holder, list, event_list) {
45                 if (should_merge(test_holder->event, event)) {
46                         test_event = test_holder->event;
47                         break;
48                 }
49         }
50
51         if (!test_event)
52                 return NULL;
53
54         fsnotify_get_event(test_event);
55
56         /* if they are exactly the same we are done */
57         if (test_event->mask == event->mask)
58                 return test_event;
59
60         /*
61          * if the refcnt == 2 this is the only queue
62          * for this event and so we can update the mask
63          * in place.
64          */
65         if (atomic_read(&test_event->refcnt) == 2) {
66                 test_event->mask |= event->mask;
67                 return test_event;
68         }
69
70         new_event = fsnotify_clone_event(test_event);
71
72         /* done with test_event */
73         fsnotify_put_event(test_event);
74
75         /* couldn't allocate memory, merge was not possible */
76         if (unlikely(!new_event))
77                 return ERR_PTR(-ENOMEM);
78
79         /* build new event and replace it on the list */
80         new_event->mask = (test_event->mask | event->mask);
81         fsnotify_replace_event(test_holder, new_event);
82
83         /* we hold a reference on new_event from clone_event */
84         return new_event;
85 }
86
87 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
88 static int fanotify_get_response_from_access(struct fsnotify_group *group,
89                                              struct fsnotify_event *event)
90 {
91         int ret;
92
93         pr_debug("%s: group=%p event=%p\n", __func__, group, event);
94
95         wait_event(group->fanotify_data.access_waitq, event->response);
96
97         /* userspace responded, convert to something usable */
98         spin_lock(&event->lock);
99         switch (event->response) {
100         case FAN_ALLOW:
101                 ret = 0;
102                 break;
103         case FAN_DENY:
104         default:
105                 ret = -EPERM;
106         }
107         event->response = 0;
108         spin_unlock(&event->lock);
109
110         pr_debug("%s: group=%p event=%p about to return ret=%d\n", __func__,
111                  group, event, ret);
112         
113         return ret;
114 }
115 #endif
116
117 static int fanotify_handle_event(struct fsnotify_group *group, struct fsnotify_event *event)
118 {
119         int ret = 0;
120         struct fsnotify_event *notify_event = NULL;
121
122         BUILD_BUG_ON(FAN_ACCESS != FS_ACCESS);
123         BUILD_BUG_ON(FAN_MODIFY != FS_MODIFY);
124         BUILD_BUG_ON(FAN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE);
125         BUILD_BUG_ON(FAN_CLOSE_WRITE != FS_CLOSE_WRITE);
126         BUILD_BUG_ON(FAN_OPEN != FS_OPEN);
127         BUILD_BUG_ON(FAN_EVENT_ON_CHILD != FS_EVENT_ON_CHILD);
128         BUILD_BUG_ON(FAN_Q_OVERFLOW != FS_Q_OVERFLOW);
129         BUILD_BUG_ON(FAN_OPEN_PERM != FS_OPEN_PERM);
130         BUILD_BUG_ON(FAN_ACCESS_PERM != FS_ACCESS_PERM);
131
132         pr_debug("%s: group=%p event=%p\n", __func__, group, event);
133
134         notify_event = fsnotify_add_notify_event(group, event, NULL, fanotify_merge);
135         if (IS_ERR(notify_event))
136                 return PTR_ERR(notify_event);
137
138 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
139         if (event->mask & FAN_ALL_PERM_EVENTS) {
140                 /* if we merged we need to wait on the new event */
141                 if (notify_event)
142                         event = notify_event;
143                 ret = fanotify_get_response_from_access(group, event);
144         }
145 #endif
146
147         if (notify_event)
148                 fsnotify_put_event(notify_event);
149
150         return ret;
151 }
152
153 static bool should_send_vfsmount_event(struct fsnotify_group *group, struct vfsmount *mnt,
154                                        struct inode *inode, __u32 mask)
155 {
156         struct fsnotify_mark *mnt_mark;
157         struct fsnotify_mark *inode_mark;
158
159         pr_debug("%s: group=%p vfsmount=%p mask=%x\n",
160                  __func__, group, mnt, mask);
161
162         mnt_mark = fsnotify_find_vfsmount_mark(group, mnt);
163         if (!mnt_mark)
164                 return false;
165
166         mask &= mnt_mark->mask;
167         mask &= ~mnt_mark->ignored_mask;
168
169         if (mask) {
170                 inode_mark = fsnotify_find_inode_mark(group, inode);
171                 if (inode_mark) {
172                         mask &= ~inode_mark->ignored_mask;
173                         fsnotify_put_mark(inode_mark);
174                 }
175         }
176
177         /* find took a reference */
178         fsnotify_put_mark(mnt_mark);
179
180         return mask;
181 }
182
183 static bool should_send_inode_event(struct fsnotify_group *group, struct inode *inode,
184                                     __u32 mask)
185 {
186         struct fsnotify_mark *fsn_mark;
187
188         pr_debug("%s: group=%p inode=%p mask=%x\n",
189                  __func__, group, inode, mask);
190
191         fsn_mark = fsnotify_find_inode_mark(group, inode);
192         if (!fsn_mark)
193                 return false;
194
195         /* if the event is for a child and this inode doesn't care about
196          * events on the child, don't send it! */
197         if ((mask & FS_EVENT_ON_CHILD) &&
198             !(fsn_mark->mask & FS_EVENT_ON_CHILD)) {
199                 mask = 0;
200         } else {
201                 /*
202                  * We care about children, but do we care about this particular
203                  * type of event?
204                  */
205                 mask &= ~FS_EVENT_ON_CHILD;
206                 mask &= fsn_mark->mask;
207                 mask &= ~fsn_mark->ignored_mask;
208         }
209
210         /* find took a reference */
211         fsnotify_put_mark(fsn_mark);
212
213         return mask;
214 }
215
216 static bool fanotify_should_send_event(struct fsnotify_group *group, struct inode *to_tell,
217                                        struct vfsmount *mnt, __u32 mask, void *data,
218                                        int data_type)
219 {
220         pr_debug("%s: group=%p to_tell=%p mnt=%p mask=%x data=%p data_type=%d\n",
221                  __func__, group, to_tell, mnt, mask, data, data_type);
222
223         /* sorry, fanotify only gives a damn about files and dirs */
224         if (!S_ISREG(to_tell->i_mode) &&
225             !S_ISDIR(to_tell->i_mode))
226                 return false;
227
228         /* if we don't have enough info to send an event to userspace say no */
229         if (data_type != FSNOTIFY_EVENT_FILE)
230                 return false;
231
232         if (mnt)
233                 return should_send_vfsmount_event(group, mnt, to_tell, mask);
234         else
235                 return should_send_inode_event(group, to_tell, mask);
236 }
237
238 const struct fsnotify_ops fanotify_fsnotify_ops = {
239         .handle_event = fanotify_handle_event,
240         .should_send_event = fanotify_should_send_event,
241         .free_group_priv = NULL,
242         .free_event_priv = NULL,
243         .freeing_mark = NULL,
244 };