2 * fs/inotify_user.c - inotify support for userspace
5 * John McCutchan <ttb@tentacle.dhs.org>
6 * Robert Love <rml@novell.com>
8 * Copyright (C) 2005 John McCutchan
9 * Copyright 2006 Hewlett-Packard Development Company, L.P.
11 * Copyright (C) 2009 Eric Paris <Red Hat Inc>
12 * inotify was largely rewriten to make use of the fsnotify infrastructure
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2, or (at your option) any
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
25 #include <linux/dcache.h> /* d_unlinked */
26 #include <linux/fs.h> /* struct inode */
27 #include <linux/fsnotify_backend.h>
28 #include <linux/inotify.h>
29 #include <linux/path.h> /* struct path */
30 #include <linux/slab.h> /* kmem_* */
31 #include <linux/types.h>
32 #include <linux/sched.h>
37 * Check if 2 events contain the same information. We do not compare private data
38 * but at this moment that isn't a problem for any know fsnotify listeners.
40 static bool event_compare(struct fsnotify_event
*old
, struct fsnotify_event
*new)
42 if ((old
->mask
== new->mask
) &&
43 (old
->to_tell
== new->to_tell
) &&
44 (old
->data_type
== new->data_type
) &&
45 (old
->name_len
== new->name_len
)) {
46 switch (old
->data_type
) {
47 case (FSNOTIFY_EVENT_INODE
):
48 /* remember, after old was put on the wait_q we aren't
49 * allowed to look at the inode any more, only thing
50 * left to check was if the file_name is the same */
52 !strcmp(old
->file_name
, new->file_name
))
55 case (FSNOTIFY_EVENT_FILE
):
56 if ((old
->file
->f_path
.mnt
== new->file
->f_path
.mnt
) &&
57 (old
->file
->f_path
.dentry
== new->file
->f_path
.dentry
))
60 case (FSNOTIFY_EVENT_NONE
):
61 if (old
->mask
& FS_Q_OVERFLOW
)
63 else if (old
->mask
& FS_IN_IGNORED
)
71 static struct fsnotify_event
*inotify_merge(struct list_head
*list
,
72 struct fsnotify_event
*event
)
74 struct fsnotify_event_holder
*last_holder
;
75 struct fsnotify_event
*last_event
;
77 /* and the list better be locked by something too */
78 spin_lock(&event
->lock
);
80 last_holder
= list_entry(list
->prev
, struct fsnotify_event_holder
, event_list
);
81 last_event
= last_holder
->event
;
82 if (event_compare(last_event
, event
))
83 fsnotify_get_event(last_event
);
87 spin_unlock(&event
->lock
);
92 static int inotify_handle_event(struct fsnotify_group
*group
, struct fsnotify_event
*event
)
94 struct fsnotify_mark
*fsn_mark
;
95 struct inotify_inode_mark
*i_mark
;
96 struct inode
*to_tell
;
97 struct inotify_event_private_data
*event_priv
;
98 struct fsnotify_event_private_data
*fsn_event_priv
;
99 struct fsnotify_event
*added_event
;
102 pr_debug("%s: group=%p event=%p to_tell=%p mask=%x\n", __func__
, group
,
103 event
, event
->to_tell
, event
->mask
);
105 to_tell
= event
->to_tell
;
107 fsn_mark
= fsnotify_find_inode_mark(group
, to_tell
);
108 /* race with watch removal? We already passes should_send */
109 if (unlikely(!fsn_mark
))
111 i_mark
= container_of(fsn_mark
, struct inotify_inode_mark
,
115 event_priv
= kmem_cache_alloc(event_priv_cachep
, GFP_KERNEL
);
116 if (unlikely(!event_priv
))
119 fsn_event_priv
= &event_priv
->fsnotify_event_priv_data
;
121 fsn_event_priv
->group
= group
;
124 added_event
= fsnotify_add_notify_event(group
, event
, fsn_event_priv
, inotify_merge
);
126 inotify_free_event_priv(fsn_event_priv
);
127 if (!IS_ERR(added_event
))
128 fsnotify_put_event(added_event
);
130 ret
= PTR_ERR(added_event
);
133 if (fsn_mark
->mask
& IN_ONESHOT
)
134 fsnotify_destroy_mark(fsn_mark
);
137 * If we hold the fsn_mark until after the event is on the queue
138 * IN_IGNORED won't be able to pass this event in the queue
140 fsnotify_put_mark(fsn_mark
);
145 static void inotify_freeing_mark(struct fsnotify_mark
*fsn_mark
, struct fsnotify_group
*group
)
147 inotify_ignored_and_remove_idr(fsn_mark
, group
);
150 static bool inotify_should_send_event(struct fsnotify_group
*group
, struct inode
*inode
,
151 struct vfsmount
*mnt
, __u32 mask
, void *data
,
154 struct fsnotify_mark
*fsn_mark
;
157 pr_debug("%s: group=%p inode=%p mask=%x data=%p data_type=%d\n",
158 __func__
, group
, inode
, mask
, data
, data_type
);
160 fsn_mark
= fsnotify_find_inode_mark(group
, inode
);
164 mask
= (mask
& ~FS_EVENT_ON_CHILD
);
165 send
= (fsn_mark
->mask
& mask
);
167 if (send
&& (fsn_mark
->mask
& FS_EXCL_UNLINK
) &&
168 (data_type
== FSNOTIFY_EVENT_FILE
)) {
169 struct file
*file
= data
;
171 if (d_unlinked(file
->f_path
.dentry
))
175 /* find took a reference */
176 fsnotify_put_mark(fsn_mark
);
182 * This is NEVER supposed to be called. Inotify marks should either have been
183 * removed from the idr when the watch was removed or in the
184 * fsnotify_destroy_mark_by_group() call when the inotify instance was being
185 * torn down. This is only called if the idr is about to be freed but there
186 * are still marks in it.
188 static int idr_callback(int id
, void *p
, void *data
)
190 struct fsnotify_mark
*fsn_mark
;
191 struct inotify_inode_mark
*i_mark
;
192 static bool warned
= false;
199 i_mark
= container_of(fsn_mark
, struct inotify_inode_mark
, fsn_mark
);
201 WARN(1, "inotify closing but id=%d for fsn_mark=%p in group=%p still in "
202 "idr. Probably leaking memory\n", id
, p
, data
);
205 * I'm taking the liberty of assuming that the mark in question is a
206 * valid address and I'm dereferencing it. This might help to figure
207 * out why we got here and the panic is no worse than the original
208 * BUG() that was here.
211 printk(KERN_WARNING
"fsn_mark->group=%p inode=%p wd=%d\n",
212 fsn_mark
->group
, fsn_mark
->i
.inode
, i_mark
->wd
);
216 static void inotify_free_group_priv(struct fsnotify_group
*group
)
218 /* ideally the idr is empty and we won't hit the BUG in teh callback */
219 idr_for_each(&group
->inotify_data
.idr
, idr_callback
, group
);
220 idr_remove_all(&group
->inotify_data
.idr
);
221 idr_destroy(&group
->inotify_data
.idr
);
222 free_uid(group
->inotify_data
.user
);
225 void inotify_free_event_priv(struct fsnotify_event_private_data
*fsn_event_priv
)
227 struct inotify_event_private_data
*event_priv
;
230 event_priv
= container_of(fsn_event_priv
, struct inotify_event_private_data
,
231 fsnotify_event_priv_data
);
233 kmem_cache_free(event_priv_cachep
, event_priv
);
236 const struct fsnotify_ops inotify_fsnotify_ops
= {
237 .handle_event
= inotify_handle_event
,
238 .should_send_event
= inotify_should_send_event
,
239 .free_group_priv
= inotify_free_group_priv
,
240 .free_event_priv
= inotify_free_event_priv
,
241 .freeing_mark
= inotify_freeing_mark
,