fs/notify/inode_mark.c

   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 #include <linux/fs.h>
  20 #include <linux/init.h>
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/mutex.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/writeback.h> /* for inode_lock */
  26
  27 #include <asm/atomic.h>
  28
  29 #include <linux/fsnotify_backend.h>
  30 #include "fsnotify.h"
  31
  32 #include "../internal.h"
  33
  34 /*
  35  * Recalculate the mask of events relevant to a given inode locked.
  36  */
  37 static void fsnotify_recalc_inode_mask_locked(struct inode *inode)
  38 {
  39         struct fsnotify_mark *mark;
  40         struct hlist_node *pos;
  41         __u32 new_mask = 0;
  42
  43         assert_spin_locked(&inode->i_lock);
  44
  45         hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list)
  46                 new_mask |= mark->mask;
  47         inode->i_fsnotify_mask = new_mask;
  48 }
  49
  50 /*
  51  * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
  52  * any notifier is interested in hearing for this inode.
  53  */
  54 void fsnotify_recalc_inode_mask(struct inode *inode)
  55 {
  56         spin_lock(&inode->i_lock);
  57         fsnotify_recalc_inode_mask_locked(inode);
  58         spin_unlock(&inode->i_lock);
  59
  60         __fsnotify_update_child_dentry_flags(inode);
  61 }
  62
  63 void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
  64 {
  65         struct inode *inode = mark->i.inode;
  66
  67         assert_spin_locked(&mark->lock);
  68         assert_spin_locked(&mark->group->mark_lock);
  69
  70         spin_lock(&inode->i_lock);
  71
  72         hlist_del_init_rcu(&mark->i.i_list);
  73         mark->i.inode = NULL;
  74
  75         /*
  76          * this mark is now off the inode->i_fsnotify_marks list and we
  77          * hold the inode->i_lock, so this is the perfect time to update the
  78          * inode->i_fsnotify_mask
  79          */
  80         fsnotify_recalc_inode_mask_locked(inode);
  81
  82         spin_unlock(&inode->i_lock);
  83 }
  84
  85 /*
  86  * Given an inode, destroy all of the marks associated with that inode.
  87  */
  88 void fsnotify_clear_marks_by_inode(struct inode *inode)
  89 {
  90         struct fsnotify_mark *mark, *lmark;
  91         struct hlist_node *pos, *n;
  92         LIST_HEAD(free_list);
  93
  94         spin_lock(&inode->i_lock);
  95         hlist_for_each_entry_safe(mark, pos, n, &inode->i_fsnotify_marks, i.i_list) {
  96                 list_add(&mark->i.free_i_list, &free_list);
  97                 hlist_del_init_rcu(&mark->i.i_list);
  98                 fsnotify_get_mark(mark);
  99         }
 100         spin_unlock(&inode->i_lock);
 101
 102         list_for_each_entry_safe(mark, lmark, &free_list, i.free_i_list) {
 103                 fsnotify_destroy_mark(mark);
 104                 fsnotify_put_mark(mark);
 105         }
 106 }
 107
 108 /*
 109  * Given a group clear all of the inode marks associated with that group.
 110  */
 111 void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
 112 {
 113         fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_INODE);
 114 }
 115
 116 /*
 117  * given a group and inode, find the mark associated with that combination.
 118  * if found take a reference to that mark and return it, else return NULL
 119  */
 120 struct fsnotify_mark *fsnotify_find_inode_mark_locked(struct fsnotify_group *group,
 121                                                       struct inode *inode)
 122 {
 123         struct fsnotify_mark *mark;
 124         struct hlist_node *pos;
 125
 126         assert_spin_locked(&inode->i_lock);
 127
 128         hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list) {
 129                 if (mark->group == group) {
 130                         fsnotify_get_mark(mark);
 131                         return mark;
 132                 }
 133         }
 134         return NULL;
 135 }
 136
 137 /*
 138  * given a group and inode, find the mark associated with that combination.
 139  * if found take a reference to that mark and return it, else return NULL
 140  */
 141 struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
 142                                                struct inode *inode)
 143 {
 144         struct fsnotify_mark *mark;
 145
 146         spin_lock(&inode->i_lock);
 147         mark = fsnotify_find_inode_mark_locked(group, inode);
 148         spin_unlock(&inode->i_lock);
 149
 150         return mark;
 151 }
 152
 153 /*
 154  * If we are setting a mark mask on an inode mark we should pin the inode
 155  * in memory.
 156  */
 157 void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *mark,
 158                                          __u32 mask)
 159 {
 160         struct inode *inode;
 161
 162         assert_spin_locked(&mark->lock);
 163
 164         if (mask &&
 165             mark->i.inode &&
 166             !(mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) {
 167                 mark->flags |= FSNOTIFY_MARK_FLAG_OBJECT_PINNED;
 168                 inode = igrab(mark->i.inode);
 169                 /*
 170                  * we shouldn't be able to get here if the inode wasn't
 171                  * already safely held in memory.  But bug in case it
 172                  * ever is wrong.
 173                  */
 174                 BUG_ON(!inode);
 175         }
 176 }
 177
 178 /*
 179  * Attach an initialized mark to a given inode.
 180  * These marks may be used for the fsnotify backend to determine which
 181  * event types should be delivered to which group and for which inodes.  These
 182  * marks are ordered according to priority, highest number first, and then by
 183  * the group's location in memory.
 184  */
 185 int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
 186                             struct fsnotify_group *group, struct inode *inode,
 187                             int allow_dups)
 188 {
 189         struct fsnotify_mark *lmark;
 190         struct hlist_node *node, *last = NULL;
 191         int ret = 0;
 192
 193         mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
 194
 195         assert_spin_locked(&mark->lock);
 196         assert_spin_locked(&group->mark_lock);
 197
 198         spin_lock(&inode->i_lock);
 199
 200         mark->i.inode = inode;
 201
 202         /* is mark the first mark? */
 203         if (hlist_empty(&inode->i_fsnotify_marks)) {
 204                 hlist_add_head_rcu(&mark->i.i_list, &inode->i_fsnotify_marks);
 205                 goto out;
 206         }
 207
 208         /* should mark be in the middle of the current list? */
 209         hlist_for_each_entry(lmark, node, &inode->i_fsnotify_marks, i.i_list) {
 210                 last = node;
 211
 212                 if ((lmark->group == group) && !allow_dups) {
 213                         ret = -EEXIST;
 214                         goto out;
 215                 }
 216
 217                 if (mark->group->priority < lmark->group->priority)
 218                         continue;
 219
 220                 if ((mark->group->priority == lmark->group->priority) &&
 221                     (mark->group < lmark->group))
 222                         continue;
 223
 224                 hlist_add_before_rcu(&mark->i.i_list, &lmark->i.i_list);
 225                 goto out;
 226         }
 227
 228         BUG_ON(last == NULL);
 229         /* mark should be the last entry.  last is the current last entry */
 230         hlist_add_after_rcu(last, &mark->i.i_list);
 231 out:
 232         fsnotify_recalc_inode_mask_locked(inode);
 233         spin_unlock(&inode->i_lock);
 234
 235         return ret;
 236 }
 237
 238 /**
 239  * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
 240  * @list: list of inodes being unmounted (sb->s_inodes)
 241  *
 242  * Called during unmount with no locks held, so needs to be safe against
 243  * concurrent modifiers. We temporarily drop inode_sb_list_lock and CAN block.
 244  */
 245 void fsnotify_unmount_inodes(struct list_head *list)
 246 {
 247         struct inode *inode, *next_i, *need_iput = NULL;
 248
 249         spin_lock(&inode_sb_list_lock);
 250         list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
 251                 struct inode *need_iput_tmp;
 252
 253                 /*
 254                  * We cannot __iget() an inode in state I_FREEING,
 255                  * I_WILL_FREE, or I_NEW which is fine because by that point
 256                  * the inode cannot have any associated watches.
 257                  */
 258                 spin_lock(&inode->i_lock);
 259                 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
 260                         spin_unlock(&inode->i_lock);
 261                         continue;
 262                 }
 263
 264                 /*
 265                  * If i_count is zero, the inode cannot have any watches and
 266                  * doing an __iget/iput with MS_ACTIVE clear would actually
 267                  * evict all inodes with zero i_count from icache which is
 268                  * unnecessarily violent and may in fact be illegal to do.
 269                  */
 270                 if (!atomic_read(&inode->i_count)) {
 271                         spin_unlock(&inode->i_lock);
 272                         continue;
 273                 }
 274
 275                 need_iput_tmp = need_iput;
 276                 need_iput = NULL;
 277
 278                 /* In case fsnotify_inode_delete() drops a reference. */
 279                 if (inode != need_iput_tmp)
 280                         __iget(inode);
 281                 else
 282                         need_iput_tmp = NULL;
 283                 spin_unlock(&inode->i_lock);
 284
 285                 /* In case the dropping of a reference would nuke next_i. */
 286                 if ((&next_i->i_sb_list != list) &&
 287                     atomic_read(&next_i->i_count)) {
 288                         spin_lock(&next_i->i_lock);
 289                         if (!(next_i->i_state & (I_FREEING | I_WILL_FREE))) {
 290                                 __iget(next_i);
 291                                 need_iput = next_i;
 292                         }
 293                         spin_unlock(&next_i->i_lock);
 294                 }
 295
 296                 /*
 297                  * We can safely drop inode_sb_list_lock here because we hold
 298                  * references on both inode and next_i.  Also no new inodes
 299                  * will be added since the umount has begun.
 300                  */
 301                 spin_unlock(&inode_sb_list_lock);
 302
 303                 if (need_iput_tmp)
 304                         iput(need_iput_tmp);
 305
 306                 /* for each watch, send FS_UNMOUNT and then remove it */
 307                 fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 308
 309                 fsnotify_inode_delete(inode);
 310
 311                 iput(inode);
 312
 313                 spin_lock(&inode_sb_list_lock);
 314         }
 315         spin_unlock(&inode_sb_list_lock);
 316 }