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 /*
  33  * Recalculate the mask of events relevant to a given inode locked.
  34  */
  35 static void fsnotify_recalc_inode_mask_locked(struct inode *inode)
  36 {
  37         struct fsnotify_mark *mark;
  38         struct hlist_node *pos;
  39         __u32 new_mask = 0;
  40
  41         assert_spin_locked(&inode->i_lock);
  42
  43         hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list)
  44                 new_mask |= mark->mask;
  45         inode->i_fsnotify_mask = new_mask;
  46 }
  47
  48 /*
  49  * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
  50  * any notifier is interested in hearing for this inode.
  51  */
  52 void fsnotify_recalc_inode_mask(struct inode *inode)
  53 {
  54         spin_lock(&inode->i_lock);
  55         fsnotify_recalc_inode_mask_locked(inode);
  56         spin_unlock(&inode->i_lock);
  57
  58         __fsnotify_update_child_dentry_flags(inode);
  59 }
  60
  61 void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
  62 {
  63         struct inode *inode = mark->i.inode;
  64
  65         assert_spin_locked(&mark->lock);
  66         assert_spin_locked(&mark->group->mark_lock);
  67
  68         spin_lock(&inode->i_lock);
  69
  70         hlist_del_init(&mark->i.i_list);
  71         mark->i.inode = NULL;
  72
  73         /*
  74          * this mark is now off the inode->i_fsnotify_marks list and we
  75          * hold the inode->i_lock, so this is the perfect time to update the
  76          * inode->i_fsnotify_mask
  77          */
  78         fsnotify_recalc_inode_mask_locked(inode);
  79
  80         spin_unlock(&inode->i_lock);
  81 }
  82
  83 /*
  84  * Given an inode, destroy all of the marks associated with that inode.
  85  */
  86 void fsnotify_clear_marks_by_inode(struct inode *inode)
  87 {
  88         struct fsnotify_mark *mark, *lmark;
  89         struct hlist_node *pos, *n;
  90         LIST_HEAD(free_list);
  91
  92         spin_lock(&inode->i_lock);
  93         hlist_for_each_entry_safe(mark, pos, n, &inode->i_fsnotify_marks, i.i_list) {
  94                 list_add(&mark->i.free_i_list, &free_list);
  95                 hlist_del_init(&mark->i.i_list);
  96                 fsnotify_get_mark(mark);
  97         }
  98         spin_unlock(&inode->i_lock);
  99
 100         list_for_each_entry_safe(mark, lmark, &free_list, i.free_i_list) {
 101                 fsnotify_destroy_mark(mark);
 102                 fsnotify_put_mark(mark);
 103         }
 104 }
 105
 106 /*
 107  * given a group and inode, find the mark associated with that combination.
 108  * if found take a reference to that mark and return it, else return NULL
 109  */
 110 struct fsnotify_mark *fsnotify_find_inode_mark_locked(struct fsnotify_group *group,
 111                                                       struct inode *inode)
 112 {
 113         struct fsnotify_mark *mark;
 114         struct hlist_node *pos;
 115
 116         assert_spin_locked(&inode->i_lock);
 117
 118         hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list) {
 119                 if (mark->group == group) {
 120                         fsnotify_get_mark(mark);
 121                         return mark;
 122                 }
 123         }
 124         return NULL;
 125 }
 126
 127 /*
 128  * given a group and inode, find the mark associated with that combination.
 129  * if found take a reference to that mark and return it, else return NULL
 130  */
 131 struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
 132                                                struct inode *inode)
 133 {
 134         struct fsnotify_mark *mark;
 135
 136         spin_lock(&inode->i_lock);
 137         mark = fsnotify_find_inode_mark_locked(group, inode);
 138         spin_unlock(&inode->i_lock);
 139
 140         return mark;
 141 }
 142
 143 /*
 144  * Attach an initialized mark mark to a given group and inode.
 145  * These marks may be used for the fsnotify backend to determine which
 146  * event types should be delivered to which group and for which inodes.
 147  */
 148 int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
 149                             struct fsnotify_group *group, struct inode *inode,
 150                             int allow_dups)
 151 {
 152         struct fsnotify_mark *lmark = NULL;
 153         int ret = 0;
 154
 155         inode = igrab(inode);
 156         if (unlikely(!inode))
 157                 return -EINVAL;
 158
 159         mark->flags = FSNOTIFY_MARK_FLAG_INODE;
 160
 161         assert_spin_locked(&mark->lock);
 162         assert_spin_locked(&group->mark_lock);
 163
 164         spin_lock(&inode->i_lock);
 165
 166         if (!allow_dups)
 167                 lmark = fsnotify_find_inode_mark_locked(group, inode);
 168         if (!lmark) {
 169                 mark->i.inode = inode;
 170
 171                 hlist_add_head(&mark->i.i_list, &inode->i_fsnotify_marks);
 172
 173                 fsnotify_recalc_inode_mask_locked(inode);
 174         }
 175
 176         spin_unlock(&inode->i_lock);
 177
 178         if (lmark) {
 179                 ret = -EEXIST;
 180                 iput(inode);
 181         }
 182
 183         return ret;
 184 }
 185
 186 /**
 187  * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
 188  * @list: list of inodes being unmounted (sb->s_inodes)
 189  *
 190  * Called with inode_lock held, protecting the unmounting super block's list
 191  * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay.
 192  * We temporarily drop inode_lock, however, and CAN block.
 193  */
 194 void fsnotify_unmount_inodes(struct list_head *list)
 195 {
 196         struct inode *inode, *next_i, *need_iput = NULL;
 197
 198         list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
 199                 struct inode *need_iput_tmp;
 200
 201                 /*
 202                  * We cannot __iget() an inode in state I_CLEAR, I_FREEING,
 203                  * I_WILL_FREE, or I_NEW which is fine because by that point
 204                  * the inode cannot have any associated watches.
 205                  */
 206                 if (inode->i_state & (I_CLEAR|I_FREEING|I_WILL_FREE|I_NEW))
 207                         continue;
 208
 209                 /*
 210                  * If i_count is zero, the inode cannot have any watches and
 211                  * doing an __iget/iput with MS_ACTIVE clear would actually
 212                  * evict all inodes with zero i_count from icache which is
 213                  * unnecessarily violent and may in fact be illegal to do.
 214                  */
 215                 if (!atomic_read(&inode->i_count))
 216                         continue;
 217
 218                 need_iput_tmp = need_iput;
 219                 need_iput = NULL;
 220
 221                 /* In case fsnotify_inode_delete() drops a reference. */
 222                 if (inode != need_iput_tmp)
 223                         __iget(inode);
 224                 else
 225                         need_iput_tmp = NULL;
 226
 227                 /* In case the dropping of a reference would nuke next_i. */
 228                 if ((&next_i->i_sb_list != list) &&
 229                     atomic_read(&next_i->i_count) &&
 230                     !(next_i->i_state & (I_CLEAR | I_FREEING | I_WILL_FREE))) {
 231                         __iget(next_i);
 232                         need_iput = next_i;
 233                 }
 234
 235                 /*
 236                  * We can safely drop inode_lock here because we hold
 237                  * references on both inode and next_i.  Also no new inodes
 238                  * will be added since the umount has begun.  Finally,
 239                  * iprune_mutex keeps shrink_icache_memory() away.
 240                  */
 241                 spin_unlock(&inode_lock);
 242
 243                 if (need_iput_tmp)
 244                         iput(need_iput_tmp);
 245
 246                 /* for each watch, send FS_UNMOUNT and then remove it */
 247                 fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 248
 249                 fsnotify_inode_delete(inode);
 250
 251                 iput(inode);
 252
 253                 spin_lock(&inode_lock);
 254         }
 255 }