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