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 12static 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 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! */ 34static 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 88static 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 117static int fanotify_handle_event(struct fsnotify_group *group, 118 struct fsnotify_mark *inode_mark, 119 struct fsnotify_mark *fanotify_mark, 120 struct fsnotify_event *event) 121{ 122 int ret = 0; 123 struct fsnotify_event *notify_event = NULL; 124 125 BUILD_BUG_ON(FAN_ACCESS != FS_ACCESS); 126 BUILD_BUG_ON(FAN_MODIFY != FS_MODIFY); 127 BUILD_BUG_ON(FAN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE); 128 BUILD_BUG_ON(FAN_CLOSE_WRITE != FS_CLOSE_WRITE); 129 BUILD_BUG_ON(FAN_OPEN != FS_OPEN); 130 BUILD_BUG_ON(FAN_EVENT_ON_CHILD != FS_EVENT_ON_CHILD); 131 BUILD_BUG_ON(FAN_Q_OVERFLOW != FS_Q_OVERFLOW); 132 BUILD_BUG_ON(FAN_OPEN_PERM != FS_OPEN_PERM); 133 BUILD_BUG_ON(FAN_ACCESS_PERM != FS_ACCESS_PERM); 134 135 pr_debug("%s: group=%p event=%p\n", __func__, group, event); 136 137 notify_event = fsnotify_add_notify_event(group, event, NULL, fanotify_merge); 138 if (IS_ERR(notify_event)) 139 return PTR_ERR(notify_event); 140 141#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 142 if (event->mask & FAN_ALL_PERM_EVENTS) { 143 /* if we merged we need to wait on the new event */ 144 if (notify_event) 145 event = notify_event; 146 ret = fanotify_get_response_from_access(group, event); 147 } 148#endif 149 150 if (notify_event) 151 fsnotify_put_event(notify_event); 152 153 return ret; 154} 155 156static bool fanotify_should_send_event(struct fsnotify_group *group, 157 struct inode *to_tell, 158 struct fsnotify_mark *inode_mark, 159 struct fsnotify_mark *vfsmnt_mark, 160 __u32 event_mask, void *data, int data_type) 161{ 162 __u32 marks_mask, marks_ignored_mask; 163 164 pr_debug("%s: group=%p to_tell=%p inode_mark=%p vfsmnt_mark=%p " 165 "mask=%x data=%p data_type=%d\n", __func__, group, to_tell, 166 inode_mark, vfsmnt_mark, event_mask, data, data_type); 167 168 /* sorry, fanotify only gives a damn about files and dirs */ 169 if (!S_ISREG(to_tell->i_mode) && 170 !S_ISDIR(to_tell->i_mode)) 171 return false; 172 173 /* if we don't have enough info to send an event to userspace say no */ 174 if (data_type != FSNOTIFY_EVENT_PATH) 175 return false; 176 177 if (inode_mark && vfsmnt_mark) { 178 marks_mask = (vfsmnt_mark->mask | inode_mark->mask); 179 marks_ignored_mask = (vfsmnt_mark->ignored_mask | inode_mark->ignored_mask); 180 } else if (inode_mark) { 181 /* 182 * if the event is for a child and this inode doesn't care about 183 * events on the child, don't send it! 184 */ 185 if ((event_mask & FS_EVENT_ON_CHILD) && 186 !(inode_mark->mask & FS_EVENT_ON_CHILD)) 187 return false; 188 marks_mask = inode_mark->mask; 189 marks_ignored_mask = inode_mark->ignored_mask; 190 } else if (vfsmnt_mark) { 191 marks_mask = vfsmnt_mark->mask; 192 marks_ignored_mask = vfsmnt_mark->ignored_mask; 193 } else { 194 BUG(); 195 } 196 197 if (event_mask & marks_mask & ~marks_ignored_mask) 198 return true; 199 200 return false; 201} 202 203const struct fsnotify_ops fanotify_fsnotify_ops = { 204 .handle_event = fanotify_handle_event, 205 .should_send_event = fanotify_should_send_event, 206 .free_group_priv = NULL, 207 .free_event_priv = NULL, 208 .freeing_mark = NULL, 209}; 210