Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com> |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License as published by |
| 6 | * the Free Software Foundation; either version 2, or (at your option) |
| 7 | * any later version. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | * GNU General Public License for more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU General Public License |
| 15 | * along with this program; see the file COPYING. If not, write to |
| 16 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
| 17 | */ |
| 18 | |
| 19 | /* |
| 20 | * fsnotify inode mark locking/lifetime/and refcnting |
| 21 | * |
| 22 | * REFCNT: |
Lino Sanfilippo | 9756b91 | 2013-07-08 15:59:46 -0700 | [diff] [blame] | 23 | * The group->recnt and mark->refcnt tell how many "things" in the kernel |
| 24 | * currently are referencing the objects. Both kind of objects typically will |
| 25 | * live inside the kernel with a refcnt of 2, one for its creation and one for |
| 26 | * the reference a group and a mark hold to each other. |
| 27 | * If you are holding the appropriate locks, you can take a reference and the |
| 28 | * object itself is guaranteed to survive until the reference is dropped. |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 29 | * |
| 30 | * LOCKING: |
Lino Sanfilippo | 9756b91 | 2013-07-08 15:59:46 -0700 | [diff] [blame] | 31 | * There are 3 locks involved with fsnotify inode marks and they MUST be taken |
| 32 | * in order as follows: |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 33 | * |
Lino Sanfilippo | 9756b91 | 2013-07-08 15:59:46 -0700 | [diff] [blame] | 34 | * group->mark_mutex |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 35 | * mark->lock |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 36 | * inode->i_lock |
| 37 | * |
Lino Sanfilippo | 9756b91 | 2013-07-08 15:59:46 -0700 | [diff] [blame] | 38 | * group->mark_mutex protects the marks_list anchored inside a given group and |
| 39 | * each mark is hooked via the g_list. It also protects the groups private |
| 40 | * data (i.e group limits). |
| 41 | |
| 42 | * mark->lock protects the marks attributes like its masks and flags. |
| 43 | * Furthermore it protects the access to a reference of the group that the mark |
| 44 | * is assigned to as well as the access to a reference of the inode/vfsmount |
| 45 | * that is being watched by the mark. |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 46 | * |
| 47 | * inode->i_lock protects the i_fsnotify_marks list anchored inside a |
| 48 | * given inode and each mark is hooked via the i_list. (and sorta the |
| 49 | * free_i_list) |
| 50 | * |
| 51 | * |
| 52 | * LIFETIME: |
| 53 | * Inode marks survive between when they are added to an inode and when their |
| 54 | * refcnt==0. |
| 55 | * |
| 56 | * The inode mark can be cleared for a number of different reasons including: |
| 57 | * - The inode is unlinked for the last time. (fsnotify_inode_remove) |
| 58 | * - The inode is being evicted from cache. (fsnotify_inode_delete) |
| 59 | * - The fs the inode is on is unmounted. (fsnotify_inode_delete/fsnotify_unmount_inodes) |
| 60 | * - Something explicitly requests that it be removed. (fsnotify_destroy_mark) |
| 61 | * - The fsnotify_group associated with the mark is going away and all such marks |
| 62 | * need to be cleaned up. (fsnotify_clear_marks_by_group) |
| 63 | * |
| 64 | * Worst case we are given an inode and need to clean up all the marks on that |
| 65 | * inode. We take i_lock and walk the i_fsnotify_marks safely. For each |
| 66 | * mark on the list we take a reference (so the mark can't disappear under us). |
| 67 | * We remove that mark form the inode's list of marks and we add this mark to a |
Lino Sanfilippo | 9756b91 | 2013-07-08 15:59:46 -0700 | [diff] [blame] | 68 | * private list anchored on the stack using i_free_list; we walk i_free_list |
| 69 | * and before we destroy the mark we make sure that we dont race with a |
| 70 | * concurrent destroy_group by getting a ref to the marks group and taking the |
| 71 | * groups mutex. |
| 72 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 73 | * Very similarly for freeing by group, except we use free_g_list. |
| 74 | * |
| 75 | * This has the very interesting property of being able to run concurrently with |
| 76 | * any (or all) other directions. |
| 77 | */ |
| 78 | |
| 79 | #include <linux/fs.h> |
| 80 | #include <linux/init.h> |
| 81 | #include <linux/kernel.h> |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 82 | #include <linux/kthread.h> |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 83 | #include <linux/module.h> |
| 84 | #include <linux/mutex.h> |
| 85 | #include <linux/slab.h> |
| 86 | #include <linux/spinlock.h> |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 87 | #include <linux/srcu.h> |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 88 | |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 89 | #include <linux/atomic.h> |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 90 | |
| 91 | #include <linux/fsnotify_backend.h> |
| 92 | #include "fsnotify.h" |
| 93 | |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 94 | struct srcu_struct fsnotify_mark_srcu; |
| 95 | static DEFINE_SPINLOCK(destroy_lock); |
| 96 | static LIST_HEAD(destroy_list); |
| 97 | static DECLARE_WAIT_QUEUE_HEAD(destroy_waitq); |
| 98 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 99 | void fsnotify_get_mark(struct fsnotify_mark *mark) |
| 100 | { |
| 101 | atomic_inc(&mark->refcnt); |
| 102 | } |
| 103 | |
| 104 | void fsnotify_put_mark(struct fsnotify_mark *mark) |
| 105 | { |
Lino Sanfilippo | 23e964c | 2011-06-14 17:29:47 +0200 | [diff] [blame] | 106 | if (atomic_dec_and_test(&mark->refcnt)) { |
| 107 | if (mark->group) |
| 108 | fsnotify_put_group(mark->group); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 109 | mark->free_mark(mark); |
Lino Sanfilippo | 23e964c | 2011-06-14 17:29:47 +0200 | [diff] [blame] | 110 | } |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 111 | } |
| 112 | |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 113 | /* Calculate mask of events for a list of marks */ |
| 114 | u32 fsnotify_recalc_mask(struct hlist_head *head) |
| 115 | { |
| 116 | u32 new_mask = 0; |
| 117 | struct fsnotify_mark *mark; |
| 118 | |
| 119 | hlist_for_each_entry(mark, head, obj_list) |
| 120 | new_mask |= mark->mask; |
| 121 | return new_mask; |
| 122 | } |
| 123 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 124 | /* |
| 125 | * Any time a mark is getting freed we end up here. |
| 126 | * The caller had better be holding a reference to this mark so we don't actually |
| 127 | * do the final put under the mark->lock |
| 128 | */ |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 129 | void fsnotify_destroy_mark_locked(struct fsnotify_mark *mark, |
| 130 | struct fsnotify_group *group) |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 131 | { |
Eric Paris | 0d48b7f | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 132 | struct inode *inode = NULL; |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 133 | |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 134 | BUG_ON(!mutex_is_locked(&group->mark_mutex)); |
| 135 | |
Lino Sanfilippo | 104d06f | 2011-06-14 17:29:48 +0200 | [diff] [blame] | 136 | spin_lock(&mark->lock); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 137 | |
Eric Paris | 700307a | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 138 | /* something else already called this function on this mark */ |
| 139 | if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) { |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 140 | spin_unlock(&mark->lock); |
Lino Sanfilippo | e2a2994 | 2011-06-14 17:29:51 +0200 | [diff] [blame] | 141 | return; |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 142 | } |
| 143 | |
Eric Paris | 700307a | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 144 | mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE; |
| 145 | |
Eric Paris | 0d48b7f | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 146 | if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) { |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 147 | inode = mark->inode; |
Eric Paris | b31d397 | 2010-04-21 16:49:38 -0400 | [diff] [blame] | 148 | fsnotify_destroy_inode_mark(mark); |
Eric Paris | 0d48b7f | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 149 | } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) |
| 150 | fsnotify_destroy_vfsmount_mark(mark); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 151 | else |
| 152 | BUG(); |
| 153 | |
| 154 | list_del_init(&mark->g_list); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 155 | spin_unlock(&mark->lock); |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 156 | |
Lino Sanfilippo | 6960b0d | 2011-08-12 01:13:31 +0200 | [diff] [blame] | 157 | if (inode && (mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) |
| 158 | iput(inode); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 159 | |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 160 | spin_lock(&destroy_lock); |
Jan Kara | 37d469e | 2014-12-12 16:58:39 -0800 | [diff] [blame] | 161 | list_add(&mark->g_list, &destroy_list); |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 162 | spin_unlock(&destroy_lock); |
| 163 | wake_up(&destroy_waitq); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 164 | |
| 165 | /* |
| 166 | * __fsnotify_update_child_dentry_flags(inode); |
| 167 | * |
| 168 | * I really want to call that, but we can't, we have no idea if the inode |
| 169 | * still exists the second we drop the mark->lock. |
| 170 | * |
| 171 | * The next time an event arrive to this inode from one of it's children |
| 172 | * __fsnotify_parent will see that the inode doesn't care about it's |
| 173 | * children and will update all of these flags then. So really this |
| 174 | * is just a lazy update (and could be a perf win...) |
| 175 | */ |
| 176 | |
Lino Sanfilippo | 23e964c | 2011-06-14 17:29:47 +0200 | [diff] [blame] | 177 | atomic_dec(&group->num_marks); |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | void fsnotify_destroy_mark(struct fsnotify_mark *mark, |
| 181 | struct fsnotify_group *group) |
| 182 | { |
Lino Sanfilippo | 6960b0d | 2011-08-12 01:13:31 +0200 | [diff] [blame] | 183 | mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING); |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 184 | fsnotify_destroy_mark_locked(mark, group); |
| 185 | mutex_unlock(&group->mark_mutex); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 186 | } |
| 187 | |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 188 | /* |
| 189 | * Destroy all marks in the given list. The marks must be already detached from |
Jan Kara | a2673b6 | 2015-07-17 16:24:12 -0700 | [diff] [blame^] | 190 | * the original inode / vfsmount. Note that we can race with |
| 191 | * fsnotify_clear_marks_by_group_flags(). However we hold a reference to each |
| 192 | * mark so they won't get freed from under us and nobody else touches our |
| 193 | * free_list list_head. |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 194 | */ |
| 195 | void fsnotify_destroy_marks(struct list_head *to_free) |
| 196 | { |
| 197 | struct fsnotify_mark *mark, *lmark; |
| 198 | struct fsnotify_group *group; |
| 199 | |
| 200 | list_for_each_entry_safe(mark, lmark, to_free, free_list) { |
| 201 | spin_lock(&mark->lock); |
| 202 | fsnotify_get_group(mark->group); |
| 203 | group = mark->group; |
| 204 | spin_unlock(&mark->lock); |
| 205 | |
| 206 | fsnotify_destroy_mark(mark, group); |
| 207 | fsnotify_put_mark(mark); |
| 208 | fsnotify_put_group(group); |
| 209 | } |
| 210 | } |
| 211 | |
Eric Paris | 90b1e7a | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 212 | void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask) |
| 213 | { |
| 214 | assert_spin_locked(&mark->lock); |
| 215 | |
| 216 | mark->mask = mask; |
| 217 | |
| 218 | if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) |
| 219 | fsnotify_set_inode_mark_mask_locked(mark, mask); |
| 220 | } |
| 221 | |
Eric Paris | 33af5e3 | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 222 | void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask) |
| 223 | { |
| 224 | assert_spin_locked(&mark->lock); |
| 225 | |
| 226 | mark->ignored_mask = mask; |
| 227 | } |
Eric Paris | 90b1e7a | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 228 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 229 | /* |
Jan Kara | 8edc6e1 | 2014-11-13 15:19:33 -0800 | [diff] [blame] | 230 | * Sorting function for lists of fsnotify marks. |
| 231 | * |
| 232 | * Fanotify supports different notification classes (reflected as priority of |
| 233 | * notification group). Events shall be passed to notification groups in |
| 234 | * decreasing priority order. To achieve this marks in notification lists for |
| 235 | * inodes and vfsmounts are sorted so that priorities of corresponding groups |
| 236 | * are descending. |
| 237 | * |
| 238 | * Furthermore correct handling of the ignore mask requires processing inode |
| 239 | * and vfsmount marks of each group together. Using the group address as |
| 240 | * further sort criterion provides a unique sorting order and thus we can |
| 241 | * merge inode and vfsmount lists of marks in linear time and find groups |
| 242 | * present in both lists. |
| 243 | * |
| 244 | * A return value of 1 signifies that b has priority over a. |
| 245 | * A return value of 0 signifies that the two marks have to be handled together. |
| 246 | * A return value of -1 signifies that a has priority over b. |
| 247 | */ |
| 248 | int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b) |
| 249 | { |
| 250 | if (a == b) |
| 251 | return 0; |
| 252 | if (!a) |
| 253 | return 1; |
| 254 | if (!b) |
| 255 | return -1; |
| 256 | if (a->priority < b->priority) |
| 257 | return 1; |
| 258 | if (a->priority > b->priority) |
| 259 | return -1; |
| 260 | if (a < b) |
| 261 | return 1; |
| 262 | return -1; |
| 263 | } |
| 264 | |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 265 | /* Add mark into proper place in given list of marks */ |
| 266 | int fsnotify_add_mark_list(struct hlist_head *head, struct fsnotify_mark *mark, |
| 267 | int allow_dups) |
| 268 | { |
| 269 | struct fsnotify_mark *lmark, *last = NULL; |
| 270 | int cmp; |
| 271 | |
| 272 | /* is mark the first mark? */ |
| 273 | if (hlist_empty(head)) { |
| 274 | hlist_add_head_rcu(&mark->obj_list, head); |
| 275 | return 0; |
| 276 | } |
| 277 | |
| 278 | /* should mark be in the middle of the current list? */ |
| 279 | hlist_for_each_entry(lmark, head, obj_list) { |
| 280 | last = lmark; |
| 281 | |
| 282 | if ((lmark->group == mark->group) && !allow_dups) |
| 283 | return -EEXIST; |
| 284 | |
| 285 | cmp = fsnotify_compare_groups(lmark->group, mark->group); |
| 286 | if (cmp >= 0) { |
| 287 | hlist_add_before_rcu(&mark->obj_list, &lmark->obj_list); |
| 288 | return 0; |
| 289 | } |
| 290 | } |
| 291 | |
| 292 | BUG_ON(last == NULL); |
| 293 | /* mark should be the last entry. last is the current last entry */ |
| 294 | hlist_add_behind_rcu(&mark->obj_list, &last->obj_list); |
| 295 | return 0; |
| 296 | } |
| 297 | |
Jan Kara | 8edc6e1 | 2014-11-13 15:19:33 -0800 | [diff] [blame] | 298 | /* |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 299 | * Attach an initialized mark to a given group and fs object. |
| 300 | * These marks may be used for the fsnotify backend to determine which |
| 301 | * event types should be delivered to which group. |
| 302 | */ |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 303 | int fsnotify_add_mark_locked(struct fsnotify_mark *mark, |
| 304 | struct fsnotify_group *group, struct inode *inode, |
| 305 | struct vfsmount *mnt, int allow_dups) |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 306 | { |
| 307 | int ret = 0; |
| 308 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 309 | BUG_ON(inode && mnt); |
| 310 | BUG_ON(!inode && !mnt); |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 311 | BUG_ON(!mutex_is_locked(&group->mark_mutex)); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 312 | |
| 313 | /* |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 314 | * LOCKING ORDER!!!! |
Lino Sanfilippo | 986ab09 | 2011-06-14 17:29:50 +0200 | [diff] [blame] | 315 | * group->mark_mutex |
Lino Sanfilippo | 104d06f | 2011-06-14 17:29:48 +0200 | [diff] [blame] | 316 | * mark->lock |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 317 | * inode->i_lock |
| 318 | */ |
Lino Sanfilippo | 104d06f | 2011-06-14 17:29:48 +0200 | [diff] [blame] | 319 | spin_lock(&mark->lock); |
Eric Paris | 700307a | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 320 | mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE; |
| 321 | |
Lino Sanfilippo | 23e964c | 2011-06-14 17:29:47 +0200 | [diff] [blame] | 322 | fsnotify_get_group(group); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 323 | mark->group = group; |
| 324 | list_add(&mark->g_list, &group->marks_list); |
| 325 | atomic_inc(&group->num_marks); |
| 326 | fsnotify_get_mark(mark); /* for i_list and g_list */ |
| 327 | |
| 328 | if (inode) { |
| 329 | ret = fsnotify_add_inode_mark(mark, group, inode, allow_dups); |
| 330 | if (ret) |
| 331 | goto err; |
Eric Paris | 0d48b7f | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 332 | } else if (mnt) { |
| 333 | ret = fsnotify_add_vfsmount_mark(mark, group, mnt, allow_dups); |
| 334 | if (ret) |
| 335 | goto err; |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 336 | } else { |
| 337 | BUG(); |
| 338 | } |
| 339 | |
Eric Paris | 90b1e7a | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 340 | /* this will pin the object if appropriate */ |
| 341 | fsnotify_set_mark_mask_locked(mark, mark->mask); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 342 | spin_unlock(&mark->lock); |
| 343 | |
| 344 | if (inode) |
| 345 | __fsnotify_update_child_dentry_flags(inode); |
| 346 | |
| 347 | return ret; |
| 348 | err: |
Eric Paris | 700307a | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 349 | mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE; |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 350 | list_del_init(&mark->g_list); |
Lino Sanfilippo | 23e964c | 2011-06-14 17:29:47 +0200 | [diff] [blame] | 351 | fsnotify_put_group(group); |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 352 | mark->group = NULL; |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 353 | atomic_dec(&group->num_marks); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 354 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 355 | spin_unlock(&mark->lock); |
| 356 | |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 357 | spin_lock(&destroy_lock); |
Jan Kara | 37d469e | 2014-12-12 16:58:39 -0800 | [diff] [blame] | 358 | list_add(&mark->g_list, &destroy_list); |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 359 | spin_unlock(&destroy_lock); |
| 360 | wake_up(&destroy_waitq); |
| 361 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 362 | return ret; |
| 363 | } |
| 364 | |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 365 | int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group, |
| 366 | struct inode *inode, struct vfsmount *mnt, int allow_dups) |
| 367 | { |
| 368 | int ret; |
| 369 | mutex_lock(&group->mark_mutex); |
| 370 | ret = fsnotify_add_mark_locked(mark, group, inode, mnt, allow_dups); |
| 371 | mutex_unlock(&group->mark_mutex); |
| 372 | return ret; |
| 373 | } |
| 374 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 375 | /* |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 376 | * Given a list of marks, find the mark associated with given group. If found |
| 377 | * take a reference to that mark and return it, else return NULL. |
| 378 | */ |
| 379 | struct fsnotify_mark *fsnotify_find_mark(struct hlist_head *head, |
| 380 | struct fsnotify_group *group) |
| 381 | { |
| 382 | struct fsnotify_mark *mark; |
| 383 | |
| 384 | hlist_for_each_entry(mark, head, obj_list) { |
| 385 | if (mark->group == group) { |
| 386 | fsnotify_get_mark(mark); |
| 387 | return mark; |
| 388 | } |
| 389 | } |
| 390 | return NULL; |
| 391 | } |
| 392 | |
| 393 | /* |
Jan Kara | a2673b6 | 2015-07-17 16:24:12 -0700 | [diff] [blame^] | 394 | * Clear any marks in a group in which mark->flags & flags is true. |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 395 | */ |
Eric Paris | 4d92604 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 396 | void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, |
| 397 | unsigned int flags) |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 398 | { |
| 399 | struct fsnotify_mark *lmark, *mark; |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 400 | |
Lino Sanfilippo | 6960b0d | 2011-08-12 01:13:31 +0200 | [diff] [blame] | 401 | mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 402 | list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) { |
Eric Paris | 4d92604 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 403 | if (mark->flags & flags) { |
Eric Paris | 4d92604 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 404 | fsnotify_get_mark(mark); |
Lino Sanfilippo | 64c20d2 | 2011-06-14 17:29:53 +0200 | [diff] [blame] | 405 | fsnotify_destroy_mark_locked(mark, group); |
| 406 | fsnotify_put_mark(mark); |
Eric Paris | 4d92604 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 407 | } |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 408 | } |
Lino Sanfilippo | 986ab09 | 2011-06-14 17:29:50 +0200 | [diff] [blame] | 409 | mutex_unlock(&group->mark_mutex); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 410 | } |
| 411 | |
Eric Paris | 4d92604 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 412 | /* |
| 413 | * Given a group, destroy all of the marks associated with that group. |
| 414 | */ |
| 415 | void fsnotify_clear_marks_by_group(struct fsnotify_group *group) |
| 416 | { |
| 417 | fsnotify_clear_marks_by_group_flags(group, (unsigned int)-1); |
| 418 | } |
| 419 | |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 420 | void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old) |
| 421 | { |
| 422 | assert_spin_locked(&old->lock); |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 423 | new->inode = old->inode; |
| 424 | new->mnt = old->mnt; |
Lino Sanfilippo | 23e964c | 2011-06-14 17:29:47 +0200 | [diff] [blame] | 425 | if (old->group) |
| 426 | fsnotify_get_group(old->group); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 427 | new->group = old->group; |
| 428 | new->mask = old->mask; |
| 429 | new->free_mark = old->free_mark; |
| 430 | } |
| 431 | |
| 432 | /* |
| 433 | * Nothing fancy, just initialize lists and locks and counters. |
| 434 | */ |
| 435 | void fsnotify_init_mark(struct fsnotify_mark *mark, |
| 436 | void (*free_mark)(struct fsnotify_mark *mark)) |
| 437 | { |
Eric Paris | ba643f0 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 438 | memset(mark, 0, sizeof(*mark)); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 439 | spin_lock_init(&mark->lock); |
| 440 | atomic_set(&mark->refcnt, 1); |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 441 | mark->free_mark = free_mark; |
| 442 | } |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 443 | |
| 444 | static int fsnotify_mark_destroy(void *ignored) |
| 445 | { |
| 446 | struct fsnotify_mark *mark, *next; |
David Cohen | efa8f7e | 2014-06-04 16:05:42 -0700 | [diff] [blame] | 447 | struct list_head private_destroy_list; |
Jan Kara | a2673b6 | 2015-07-17 16:24:12 -0700 | [diff] [blame^] | 448 | struct fsnotify_group *group; |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 449 | |
| 450 | for (;;) { |
| 451 | spin_lock(&destroy_lock); |
Andreas Gruenbacher | 8778abb | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 452 | /* exchange the list head */ |
| 453 | list_replace_init(&destroy_list, &private_destroy_list); |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 454 | spin_unlock(&destroy_lock); |
| 455 | |
| 456 | synchronize_srcu(&fsnotify_mark_srcu); |
| 457 | |
Jan Kara | 37d469e | 2014-12-12 16:58:39 -0800 | [diff] [blame] | 458 | list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) { |
| 459 | list_del_init(&mark->g_list); |
Jan Kara | a2673b6 | 2015-07-17 16:24:12 -0700 | [diff] [blame^] | 460 | group = mark->group; |
| 461 | /* |
| 462 | * Some groups like to know that marks are being freed. |
| 463 | * This is a callback to the group function to let it |
| 464 | * know that this mark is being freed. |
| 465 | */ |
| 466 | if (group && group->ops->freeing_mark) |
| 467 | group->ops->freeing_mark(mark, group); |
Eric Paris | 75c1be4 | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 468 | fsnotify_put_mark(mark); |
| 469 | } |
| 470 | |
| 471 | wait_event_interruptible(destroy_waitq, !list_empty(&destroy_list)); |
| 472 | } |
| 473 | |
| 474 | return 0; |
| 475 | } |
| 476 | |
| 477 | static int __init fsnotify_mark_init(void) |
| 478 | { |
| 479 | struct task_struct *thread; |
| 480 | |
| 481 | thread = kthread_run(fsnotify_mark_destroy, NULL, |
| 482 | "fsnotify_mark"); |
| 483 | if (IS_ERR(thread)) |
| 484 | panic("unable to start fsnotify mark destruction thread."); |
| 485 | |
| 486 | return 0; |
| 487 | } |
| 488 | device_initcall(fsnotify_mark_init); |