1#ifndef _LINUX_FS_NOTIFY_H
2#define _LINUX_FS_NOTIFY_H
3
4/*
5 * include/linux/fsnotify.h - generic hooks for filesystem notification, to
6 * reduce in-source duplication from both dnotify and inotify.
7 *
8 * We don't compile any of this away in some complicated menagerie of ifdefs.
9 * Instead, we rely on the code inside to optimize away as needed.
10 *
11 * (C) Copyright 2005 Robert Love
12 */
13
14#include <linux/fsnotify_backend.h>
15#include <linux/audit.h>
16#include <linux/slab.h>
17#include <linux/bug.h>
18
19/*
20 * fsnotify_d_instantiate - instantiate a dentry for inode
21 */
22static inline void fsnotify_d_instantiate(struct dentry *dentry,
23					  struct inode *inode)
24{
25	__fsnotify_d_instantiate(dentry, inode);
26}
27
28/* Notify this dentry's parent about a child's events. */
29static inline int fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask)
30{
31	if (!dentry)
32		dentry = path->dentry;
33
34	return __fsnotify_parent(path, dentry, mask);
35}
36
37/* simple call site for access decisions */
38static inline int fsnotify_perm(struct file *file, int mask)
39{
40	struct path *path = &file->f_path;
41	struct inode *inode = file_inode(file);
42	__u32 fsnotify_mask = 0;
43	int ret;
44
45	if (file->f_mode & FMODE_NONOTIFY)
46		return 0;
47	if (!(mask & (MAY_READ | MAY_OPEN)))
48		return 0;
49	if (mask & MAY_OPEN)
50		fsnotify_mask = FS_OPEN_PERM;
51	else if (mask & MAY_READ)
52		fsnotify_mask = FS_ACCESS_PERM;
53	else
54		BUG();
55
56	ret = fsnotify_parent(path, NULL, fsnotify_mask);
57	if (ret)
58		return ret;
59
60	return fsnotify(inode, fsnotify_mask, path, FSNOTIFY_EVENT_PATH, NULL, 0);
61}
62
63/*
64 * fsnotify_d_move - dentry has been moved
65 */
66static inline void fsnotify_d_move(struct dentry *dentry)
67{
68	/*
69	 * On move we need to update dentry->d_flags to indicate if the new parent
70	 * cares about events from this dentry.
71	 */
72	__fsnotify_update_dcache_flags(dentry);
73}
74
75/*
76 * fsnotify_link_count - inode's link count changed
77 */
78static inline void fsnotify_link_count(struct inode *inode)
79{
80	fsnotify(inode, FS_ATTRIB, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
81}
82
83/*
84 * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir
85 */
86static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
87				 const unsigned char *old_name,
88				 int isdir, struct inode *target, struct dentry *moved)
89{
90	struct inode *source = moved->d_inode;
91	u32 fs_cookie = fsnotify_get_cookie();
92	__u32 old_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_FROM);
93	__u32 new_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_TO);
94	const unsigned char *new_name = moved->d_name.name;
95
96	if (old_dir == new_dir)
97		old_dir_mask |= FS_DN_RENAME;
98
99	if (isdir) {
100		old_dir_mask |= FS_ISDIR;
101		new_dir_mask |= FS_ISDIR;
102	}
103
104	fsnotify(old_dir, old_dir_mask, source, FSNOTIFY_EVENT_INODE, old_name,
105		 fs_cookie);
106	fsnotify(new_dir, new_dir_mask, source, FSNOTIFY_EVENT_INODE, new_name,
107		 fs_cookie);
108
109	if (target)
110		fsnotify_link_count(target);
111
112	if (source)
113		fsnotify(source, FS_MOVE_SELF, moved->d_inode, FSNOTIFY_EVENT_INODE, NULL, 0);
114	audit_inode_child(new_dir, moved, AUDIT_TYPE_CHILD_CREATE);
115}
116
117/*
118 * fsnotify_inode_delete - and inode is being evicted from cache, clean up is needed
119 */
120static inline void fsnotify_inode_delete(struct inode *inode)
121{
122	__fsnotify_inode_delete(inode);
123}
124
125/*
126 * fsnotify_vfsmount_delete - a vfsmount is being destroyed, clean up is needed
127 */
128static inline void fsnotify_vfsmount_delete(struct vfsmount *mnt)
129{
130	__fsnotify_vfsmount_delete(mnt);
131}
132
133/*
134 * fsnotify_nameremove - a filename was removed from a directory
135 */
136static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
137{
138	__u32 mask = FS_DELETE;
139
140	if (isdir)
141		mask |= FS_ISDIR;
142
143	fsnotify_parent(NULL, dentry, mask);
144}
145
146/*
147 * fsnotify_inoderemove - an inode is going away
148 */
149static inline void fsnotify_inoderemove(struct inode *inode)
150{
151	fsnotify(inode, FS_DELETE_SELF, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
152	__fsnotify_inode_delete(inode);
153}
154
155/*
156 * fsnotify_create - 'name' was linked in
157 */
158static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
159{
160	audit_inode_child(inode, dentry, AUDIT_TYPE_CHILD_CREATE);
161
162	fsnotify(inode, FS_CREATE, dentry->d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0);
163}
164
165/*
166 * fsnotify_link - new hardlink in 'inode' directory
167 * Note: We have to pass also the linked inode ptr as some filesystems leave
168 *   new_dentry->d_inode NULL and instantiate inode pointer later
169 */
170static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry)
171{
172	fsnotify_link_count(inode);
173	audit_inode_child(dir, new_dentry, AUDIT_TYPE_CHILD_CREATE);
174
175	fsnotify(dir, FS_CREATE, inode, FSNOTIFY_EVENT_INODE, new_dentry->d_name.name, 0);
176}
177
178/*
179 * fsnotify_mkdir - directory 'name' was created
180 */
181static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
182{
183	__u32 mask = (FS_CREATE | FS_ISDIR);
184	struct inode *d_inode = dentry->d_inode;
185
186	audit_inode_child(inode, dentry, AUDIT_TYPE_CHILD_CREATE);
187
188	fsnotify(inode, mask, d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0);
189}
190
191/*
192 * fsnotify_access - file was read
193 */
194static inline void fsnotify_access(struct file *file)
195{
196	struct path *path = &file->f_path;
197	struct inode *inode = file_inode(file);
198	__u32 mask = FS_ACCESS;
199
200	if (S_ISDIR(inode->i_mode))
201		mask |= FS_ISDIR;
202
203	if (!(file->f_mode & FMODE_NONOTIFY)) {
204		fsnotify_parent(path, NULL, mask);
205		fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0);
206	}
207}
208
209/*
210 * fsnotify_modify - file was modified
211 */
212static inline void fsnotify_modify(struct file *file)
213{
214	struct path *path = &file->f_path;
215	struct inode *inode = file_inode(file);
216	__u32 mask = FS_MODIFY;
217
218	if (S_ISDIR(inode->i_mode))
219		mask |= FS_ISDIR;
220
221	if (!(file->f_mode & FMODE_NONOTIFY)) {
222		fsnotify_parent(path, NULL, mask);
223		fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0);
224	}
225}
226
227/*
228 * fsnotify_open - file was opened
229 */
230static inline void fsnotify_open(struct file *file)
231{
232	struct path *path = &file->f_path;
233	struct inode *inode = file_inode(file);
234	__u32 mask = FS_OPEN;
235
236	if (S_ISDIR(inode->i_mode))
237		mask |= FS_ISDIR;
238
239	fsnotify_parent(path, NULL, mask);
240	fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0);
241}
242
243/*
244 * fsnotify_close - file was closed
245 */
246static inline void fsnotify_close(struct file *file)
247{
248	struct path *path = &file->f_path;
249	struct inode *inode = file_inode(file);
250	fmode_t mode = file->f_mode;
251	__u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE;
252
253	if (S_ISDIR(inode->i_mode))
254		mask |= FS_ISDIR;
255
256	if (!(file->f_mode & FMODE_NONOTIFY)) {
257		fsnotify_parent(path, NULL, mask);
258		fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0);
259	}
260}
261
262/*
263 * fsnotify_xattr - extended attributes were changed
264 */
265static inline void fsnotify_xattr(struct dentry *dentry)
266{
267	struct inode *inode = dentry->d_inode;
268	__u32 mask = FS_ATTRIB;
269
270	if (S_ISDIR(inode->i_mode))
271		mask |= FS_ISDIR;
272
273	fsnotify_parent(NULL, dentry, mask);
274	fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
275}
276
277/*
278 * fsnotify_change - notify_change event.  file was modified and/or metadata
279 * was changed.
280 */
281static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
282{
283	struct inode *inode = dentry->d_inode;
284	__u32 mask = 0;
285
286	if (ia_valid & ATTR_UID)
287		mask |= FS_ATTRIB;
288	if (ia_valid & ATTR_GID)
289		mask |= FS_ATTRIB;
290	if (ia_valid & ATTR_SIZE)
291		mask |= FS_MODIFY;
292
293	/* both times implies a utime(s) call */
294	if ((ia_valid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME))
295		mask |= FS_ATTRIB;
296	else if (ia_valid & ATTR_ATIME)
297		mask |= FS_ACCESS;
298	else if (ia_valid & ATTR_MTIME)
299		mask |= FS_MODIFY;
300
301	if (ia_valid & ATTR_MODE)
302		mask |= FS_ATTRIB;
303
304	if (mask) {
305		if (S_ISDIR(inode->i_mode))
306			mask |= FS_ISDIR;
307
308		fsnotify_parent(NULL, dentry, mask);
309		fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
310	}
311}
312
313#if defined(CONFIG_FSNOTIFY)	/* notify helpers */
314
315/*
316 * fsnotify_oldname_init - save off the old filename before we change it
317 */
318static inline const unsigned char *fsnotify_oldname_init(const unsigned char *name)
319{
320	return kstrdup(name, GFP_KERNEL);
321}
322
323/*
324 * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init
325 */
326static inline void fsnotify_oldname_free(const unsigned char *old_name)
327{
328	kfree(old_name);
329}
330
331#else	/* CONFIG_FSNOTIFY */
332
333static inline const char *fsnotify_oldname_init(const unsigned char *name)
334{
335	return NULL;
336}
337
338static inline void fsnotify_oldname_free(const unsigned char *old_name)
339{
340}
341
342#endif	/*  CONFIG_FSNOTIFY */
343
344#endif	/* _LINUX_FS_NOTIFY_H */
345