~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/notify/inode_mark.c

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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         __u32 new_mask = 0;
 40 
 41         assert_spin_locked(&inode->i_lock);
 42 
 43         hlist_for_each_entry(mark, &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         BUG_ON(!mutex_is_locked(&mark->group->mark_mutex));
 66         assert_spin_locked(&mark->lock);
 67 
 68         spin_lock(&inode->i_lock);
 69 
 70         hlist_del_init_rcu(&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 *n;
 90         LIST_HEAD(free_list);
 91 
 92         spin_lock(&inode->i_lock);
 93         hlist_for_each_entry_safe(mark, n, &inode->i_fsnotify_marks, i.i_list) {
 94                 list_add(&mark->i.free_i_list, &free_list);
 95                 hlist_del_init_rcu(&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                 struct fsnotify_group *group;
102 
103                 spin_lock(&mark->lock);
104                 fsnotify_get_group(mark->group);
105                 group = mark->group;
106                 spin_unlock(&mark->lock);
107 
108                 fsnotify_destroy_mark(mark, group);
109                 fsnotify_put_mark(mark);
110                 fsnotify_put_group(group);
111         }
112 }
113 
114 /*
115  * Given a group clear all of the inode marks associated with that group.
116  */
117 void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
118 {
119         fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_INODE);
120 }
121 
122 /*
123  * given a group and inode, find the mark associated with that combination.
124  * if found take a reference to that mark and return it, else return NULL
125  */
126 static struct fsnotify_mark *fsnotify_find_inode_mark_locked(
127                 struct fsnotify_group *group,
128                 struct inode *inode)
129 {
130         struct fsnotify_mark *mark;
131 
132         assert_spin_locked(&inode->i_lock);
133 
134         hlist_for_each_entry(mark, &inode->i_fsnotify_marks, i.i_list) {
135                 if (mark->group == group) {
136                         fsnotify_get_mark(mark);
137                         return mark;
138                 }
139         }
140         return NULL;
141 }
142 
143 /*
144  * given a group and inode, find the mark associated with that combination.
145  * if found take a reference to that mark and return it, else return NULL
146  */
147 struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
148                                                struct inode *inode)
149 {
150         struct fsnotify_mark *mark;
151 
152         spin_lock(&inode->i_lock);
153         mark = fsnotify_find_inode_mark_locked(group, inode);
154         spin_unlock(&inode->i_lock);
155 
156         return mark;
157 }
158 
159 /*
160  * If we are setting a mark mask on an inode mark we should pin the inode
161  * in memory.
162  */
163 void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *mark,
164                                          __u32 mask)
165 {
166         struct inode *inode;
167 
168         assert_spin_locked(&mark->lock);
169 
170         if (mask &&
171             mark->i.inode &&
172             !(mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) {
173                 mark->flags |= FSNOTIFY_MARK_FLAG_OBJECT_PINNED;
174                 inode = igrab(mark->i.inode);
175                 /*
176                  * we shouldn't be able to get here if the inode wasn't
177                  * already safely held in memory.  But bug in case it
178                  * ever is wrong.
179                  */
180                 BUG_ON(!inode);
181         }
182 }
183 
184 /*
185  * Attach an initialized mark to a given inode.
186  * These marks may be used for the fsnotify backend to determine which
187  * event types should be delivered to which group and for which inodes.  These
188  * marks are ordered according to priority, highest number first, and then by
189  * the group's location in memory.
190  */
191 int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
192                             struct fsnotify_group *group, struct inode *inode,
193                             int allow_dups)
194 {
195         struct fsnotify_mark *lmark, *last = NULL;
196         int ret = 0;
197         int cmp;
198 
199         mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
200 
201         BUG_ON(!mutex_is_locked(&group->mark_mutex));
202         assert_spin_locked(&mark->lock);
203 
204         spin_lock(&inode->i_lock);
205 
206         mark->i.inode = inode;
207 
208         /* is mark the first mark? */
209         if (hlist_empty(&inode->i_fsnotify_marks)) {
210                 hlist_add_head_rcu(&mark->i.i_list, &inode->i_fsnotify_marks);
211                 goto out;
212         }
213 
214         /* should mark be in the middle of the current list? */
215         hlist_for_each_entry(lmark, &inode->i_fsnotify_marks, i.i_list) {
216                 last = lmark;
217 
218                 if ((lmark->group == group) && !allow_dups) {
219                         ret = -EEXIST;
220                         goto out;
221                 }
222 
223                 cmp = fsnotify_compare_groups(lmark->group, mark->group);
224                 if (cmp < 0)
225                         continue;
226 
227                 hlist_add_before_rcu(&mark->i.i_list, &lmark->i.i_list);
228                 goto out;
229         }
230 
231         BUG_ON(last == NULL);
232         /* mark should be the last entry.  last is the current last entry */
233         hlist_add_behind_rcu(&mark->i.i_list, &last->i.i_list);
234 out:
235         fsnotify_recalc_inode_mask_locked(inode);
236         spin_unlock(&inode->i_lock);
237 
238         return ret;
239 }
240 
241 /**
242  * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
243  * @list: list of inodes being unmounted (sb->s_inodes)
244  *
245  * Called during unmount with no locks held, so needs to be safe against
246  * concurrent modifiers. We temporarily drop inode_sb_list_lock and CAN block.
247  */
248 void fsnotify_unmount_inodes(struct list_head *list)
249 {
250         struct inode *inode, *next_i, *need_iput = NULL;
251 
252         spin_lock(&inode_sb_list_lock);
253         list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
254                 struct inode *need_iput_tmp;
255 
256                 /*
257                  * We cannot __iget() an inode in state I_FREEING,
258                  * I_WILL_FREE, or I_NEW which is fine because by that point
259                  * the inode cannot have any associated watches.
260                  */
261                 spin_lock(&inode->i_lock);
262                 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
263                         spin_unlock(&inode->i_lock);
264                         continue;
265                 }
266 
267                 /*
268                  * If i_count is zero, the inode cannot have any watches and
269                  * doing an __iget/iput with MS_ACTIVE clear would actually
270                  * evict all inodes with zero i_count from icache which is
271                  * unnecessarily violent and may in fact be illegal to do.
272                  */
273                 if (!atomic_read(&inode->i_count)) {
274                         spin_unlock(&inode->i_lock);
275                         continue;
276                 }
277 
278                 need_iput_tmp = need_iput;
279                 need_iput = NULL;
280 
281                 /* In case fsnotify_inode_delete() drops a reference. */
282                 if (inode != need_iput_tmp)
283                         __iget(inode);
284                 else
285                         need_iput_tmp = NULL;
286                 spin_unlock(&inode->i_lock);
287 
288                 /* In case the dropping of a reference would nuke next_i. */
289                 while (&next_i->i_sb_list != list) {
290                         spin_lock(&next_i->i_lock);
291                         if (!(next_i->i_state & (I_FREEING | I_WILL_FREE)) &&
292                                                 atomic_read(&next_i->i_count)) {
293                                 __iget(next_i);
294                                 need_iput = next_i;
295                                 spin_unlock(&next_i->i_lock);
296                                 break;
297                         }
298                         spin_unlock(&next_i->i_lock);
299                         next_i = list_entry(next_i->i_sb_list.next,
300                                                 struct inode, i_sb_list);
301                 }
302 
303                 /*
304                  * We can safely drop inode_sb_list_lock here because either
305                  * we actually hold references on both inode and next_i or
306                  * end of list.  Also no new inodes will be added since the
307                  * 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 }
325 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp