CRED: Constify the kernel_cap_t arguments to the capset LSM hooks
[linux-2.6.git] / include / linux / fsnotify.h
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/dnotify.h>
15 #include <linux/inotify.h>
16 #include <linux/audit.h>
17
18 /*
19  * fsnotify_d_instantiate - instantiate a dentry for inode
20  * Called with dcache_lock held.
21  */
22 static inline void fsnotify_d_instantiate(struct dentry *entry,
23                                                 struct inode *inode)
24 {
25         inotify_d_instantiate(entry, inode);
26 }
27
28 /*
29  * fsnotify_d_move - entry has been moved
30  * Called with dcache_lock and entry->d_lock held.
31  */
32 static inline void fsnotify_d_move(struct dentry *entry)
33 {
34         inotify_d_move(entry);
35 }
36
37 /*
38  * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir
39  */
40 static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
41                                  const char *old_name, const char *new_name,
42                                  int isdir, struct inode *target, struct dentry *moved)
43 {
44         struct inode *source = moved->d_inode;
45         u32 cookie = inotify_get_cookie();
46
47         if (old_dir == new_dir)
48                 inode_dir_notify(old_dir, DN_RENAME);
49         else {
50                 inode_dir_notify(old_dir, DN_DELETE);
51                 inode_dir_notify(new_dir, DN_CREATE);
52         }
53
54         if (isdir)
55                 isdir = IN_ISDIR;
56         inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir,cookie,old_name,
57                                   source);
58         inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, cookie, new_name,
59                                   source);
60
61         if (target) {
62                 inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL, NULL);
63                 inotify_inode_is_dead(target);
64         }
65
66         if (source) {
67                 inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL, NULL);
68         }
69         audit_inode_child(new_name, moved, new_dir);
70 }
71
72 /*
73  * fsnotify_nameremove - a filename was removed from a directory
74  */
75 static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
76 {
77         if (isdir)
78                 isdir = IN_ISDIR;
79         dnotify_parent(dentry, DN_DELETE);
80         inotify_dentry_parent_queue_event(dentry, IN_DELETE|isdir, 0, dentry->d_name.name);
81 }
82
83 /*
84  * fsnotify_inoderemove - an inode is going away
85  */
86 static inline void fsnotify_inoderemove(struct inode *inode)
87 {
88         inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL, NULL);
89         inotify_inode_is_dead(inode);
90 }
91
92 /*
93  * fsnotify_link_count - inode's link count changed
94  */
95 static inline void fsnotify_link_count(struct inode *inode)
96 {
97         inotify_inode_queue_event(inode, IN_ATTRIB, 0, NULL, NULL);
98 }
99
100 /*
101  * fsnotify_create - 'name' was linked in
102  */
103 static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
104 {
105         inode_dir_notify(inode, DN_CREATE);
106         inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name,
107                                   dentry->d_inode);
108         audit_inode_child(dentry->d_name.name, dentry, inode);
109 }
110
111 /*
112  * fsnotify_link - new hardlink in 'inode' directory
113  * Note: We have to pass also the linked inode ptr as some filesystems leave
114  *   new_dentry->d_inode NULL and instantiate inode pointer later
115  */
116 static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry)
117 {
118         inode_dir_notify(dir, DN_CREATE);
119         inotify_inode_queue_event(dir, IN_CREATE, 0, new_dentry->d_name.name,
120                                   inode);
121         fsnotify_link_count(inode);
122         audit_inode_child(new_dentry->d_name.name, new_dentry, dir);
123 }
124
125 /*
126  * fsnotify_mkdir - directory 'name' was created
127  */
128 static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
129 {
130         inode_dir_notify(inode, DN_CREATE);
131         inotify_inode_queue_event(inode, IN_CREATE | IN_ISDIR, 0, 
132                                   dentry->d_name.name, dentry->d_inode);
133         audit_inode_child(dentry->d_name.name, dentry, inode);
134 }
135
136 /*
137  * fsnotify_access - file was read
138  */
139 static inline void fsnotify_access(struct dentry *dentry)
140 {
141         struct inode *inode = dentry->d_inode;
142         u32 mask = IN_ACCESS;
143
144         if (S_ISDIR(inode->i_mode))
145                 mask |= IN_ISDIR;
146
147         dnotify_parent(dentry, DN_ACCESS);
148         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
149         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
150 }
151
152 /*
153  * fsnotify_modify - file was modified
154  */
155 static inline void fsnotify_modify(struct dentry *dentry)
156 {
157         struct inode *inode = dentry->d_inode;
158         u32 mask = IN_MODIFY;
159
160         if (S_ISDIR(inode->i_mode))
161                 mask |= IN_ISDIR;
162
163         dnotify_parent(dentry, DN_MODIFY);
164         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
165         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
166 }
167
168 /*
169  * fsnotify_open - file was opened
170  */
171 static inline void fsnotify_open(struct dentry *dentry)
172 {
173         struct inode *inode = dentry->d_inode;
174         u32 mask = IN_OPEN;
175
176         if (S_ISDIR(inode->i_mode))
177                 mask |= IN_ISDIR;
178
179         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
180         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
181 }
182
183 /*
184  * fsnotify_close - file was closed
185  */
186 static inline void fsnotify_close(struct file *file)
187 {
188         struct dentry *dentry = file->f_path.dentry;
189         struct inode *inode = dentry->d_inode;
190         const char *name = dentry->d_name.name;
191         fmode_t mode = file->f_mode;
192         u32 mask = (mode & FMODE_WRITE) ? IN_CLOSE_WRITE : IN_CLOSE_NOWRITE;
193
194         if (S_ISDIR(inode->i_mode))
195                 mask |= IN_ISDIR;
196
197         inotify_dentry_parent_queue_event(dentry, mask, 0, name);
198         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
199 }
200
201 /*
202  * fsnotify_xattr - extended attributes were changed
203  */
204 static inline void fsnotify_xattr(struct dentry *dentry)
205 {
206         struct inode *inode = dentry->d_inode;
207         u32 mask = IN_ATTRIB;
208
209         if (S_ISDIR(inode->i_mode))
210                 mask |= IN_ISDIR;
211
212         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
213         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
214 }
215
216 /*
217  * fsnotify_change - notify_change event.  file was modified and/or metadata
218  * was changed.
219  */
220 static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
221 {
222         struct inode *inode = dentry->d_inode;
223         int dn_mask = 0;
224         u32 in_mask = 0;
225
226         if (ia_valid & ATTR_UID) {
227                 in_mask |= IN_ATTRIB;
228                 dn_mask |= DN_ATTRIB;
229         }
230         if (ia_valid & ATTR_GID) {
231                 in_mask |= IN_ATTRIB;
232                 dn_mask |= DN_ATTRIB;
233         }
234         if (ia_valid & ATTR_SIZE) {
235                 in_mask |= IN_MODIFY;
236                 dn_mask |= DN_MODIFY;
237         }
238         /* both times implies a utime(s) call */
239         if ((ia_valid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME))
240         {
241                 in_mask |= IN_ATTRIB;
242                 dn_mask |= DN_ATTRIB;
243         } else if (ia_valid & ATTR_ATIME) {
244                 in_mask |= IN_ACCESS;
245                 dn_mask |= DN_ACCESS;
246         } else if (ia_valid & ATTR_MTIME) {
247                 in_mask |= IN_MODIFY;
248                 dn_mask |= DN_MODIFY;
249         }
250         if (ia_valid & ATTR_MODE) {
251                 in_mask |= IN_ATTRIB;
252                 dn_mask |= DN_ATTRIB;
253         }
254
255         if (dn_mask)
256                 dnotify_parent(dentry, dn_mask);
257         if (in_mask) {
258                 if (S_ISDIR(inode->i_mode))
259                         in_mask |= IN_ISDIR;
260                 inotify_inode_queue_event(inode, in_mask, 0, NULL, NULL);
261                 inotify_dentry_parent_queue_event(dentry, in_mask, 0,
262                                                   dentry->d_name.name);
263         }
264 }
265
266 #ifdef CONFIG_INOTIFY   /* inotify helpers */
267
268 /*
269  * fsnotify_oldname_init - save off the old filename before we change it
270  */
271 static inline const char *fsnotify_oldname_init(const char *name)
272 {
273         return kstrdup(name, GFP_KERNEL);
274 }
275
276 /*
277  * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init
278  */
279 static inline void fsnotify_oldname_free(const char *old_name)
280 {
281         kfree(old_name);
282 }
283
284 #else   /* CONFIG_INOTIFY */
285
286 static inline const char *fsnotify_oldname_init(const char *name)
287 {
288         return NULL;
289 }
290
291 static inline void fsnotify_oldname_free(const char *old_name)
292 {
293 }
294
295 #endif  /* ! CONFIG_INOTIFY */
296
297 #endif  /* _LINUX_FS_NOTIFY_H */