2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2006
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 notify implementation using inotify
28 #if HAVE_SYS_INOTIFY_H
29 #include <sys/inotify.h>
32 #ifdef HAVE_ASM_TYPES_H
33 #include <asm/types.h>
36 #ifndef HAVE_INOTIFY_INIT
38 #include <linux/inotify.h>
39 #include <asm/unistd.h>
43 glibc doesn't define these functions yet (as of March 2006)
45 static int inotify_init(void)
47 return syscall(__NR_inotify_init
);
50 static int inotify_add_watch(int fd
, const char *path
, __u32 mask
)
52 return syscall(__NR_inotify_add_watch
, fd
, path
, mask
);
55 static int inotify_rm_watch(int fd
, int wd
)
57 return syscall(__NR_inotify_rm_watch
, fd
, wd
);
61 #include <sys/inotify.h>
66 /* older glibc headers don't have these defines either */
68 #define IN_ONLYDIR 0x01000000
71 #define IN_MASK_ADD 0x20000000
74 struct inotify_private
{
75 struct sys_notify_context
*ctx
;
77 struct inotify_watch_context
*watches
;
80 struct inotify_watch_context
{
81 struct inotify_watch_context
*next
, *prev
;
82 struct inotify_private
*in
;
84 void (*callback
)(struct sys_notify_context
*ctx
,
86 struct notify_event
*ev
);
88 uint32_t mask
; /* the inotify mask */
89 uint32_t filter
; /* the windows completion filter */
95 destroy the inotify private context
97 static int inotify_destructor(struct inotify_private
*in
)
105 see if a particular event from inotify really does match a requested
108 static bool filter_match(struct inotify_watch_context
*w
,
109 struct inotify_event
*e
)
111 DEBUG(10, ("filter_match: e->mask=%x, w->mask=%x, w->filter=%x\n",
112 e
->mask
, w
->mask
, w
->filter
));
114 if ((e
->mask
& w
->mask
) == 0) {
115 /* this happens because inotify_add_watch() coalesces watches on the same
116 path, oring their masks together */
120 /* SMB separates the filters for files and directories */
121 if (e
->mask
& IN_ISDIR
) {
122 if ((w
->filter
& FILE_NOTIFY_CHANGE_DIR_NAME
) == 0) {
126 if ((e
->mask
& IN_ATTRIB
) &&
127 (w
->filter
& (FILE_NOTIFY_CHANGE_ATTRIBUTES
|
128 FILE_NOTIFY_CHANGE_LAST_WRITE
|
129 FILE_NOTIFY_CHANGE_LAST_ACCESS
|
130 FILE_NOTIFY_CHANGE_EA
|
131 FILE_NOTIFY_CHANGE_SECURITY
))) {
134 if ((e
->mask
& IN_MODIFY
) &&
135 (w
->filter
& FILE_NOTIFY_CHANGE_ATTRIBUTES
)) {
138 if ((w
->filter
& FILE_NOTIFY_CHANGE_FILE_NAME
) == 0) {
149 dispatch one inotify event
151 the cookies are used to correctly handle renames
153 static void inotify_dispatch(struct inotify_private
*in
,
154 struct inotify_event
*e
,
155 uint32_t prev_cookie
,
156 struct inotify_event
*e2
)
158 struct inotify_watch_context
*w
, *next
;
159 struct notify_event ne
;
161 DEBUG(10, ("inotify_dispatch called with mask=%x, name=[%s]\n",
162 e
->mask
, e
->len
? e
->name
: ""));
164 /* ignore extraneous events, such as unmount and IN_IGNORED events */
165 if ((e
->mask
& (IN_ATTRIB
|IN_MODIFY
|IN_CREATE
|IN_DELETE
|
166 IN_MOVED_FROM
|IN_MOVED_TO
)) == 0) {
170 /* map the inotify mask to a action. This gets complicated for
172 if (e
->mask
& IN_CREATE
) {
173 ne
.action
= NOTIFY_ACTION_ADDED
;
174 } else if (e
->mask
& IN_DELETE
) {
175 ne
.action
= NOTIFY_ACTION_REMOVED
;
176 } else if (e
->mask
& IN_MOVED_FROM
) {
177 if (e2
!= NULL
&& e2
->cookie
== e
->cookie
) {
178 ne
.action
= NOTIFY_ACTION_OLD_NAME
;
180 ne
.action
= NOTIFY_ACTION_REMOVED
;
182 } else if (e
->mask
& IN_MOVED_TO
) {
183 if (e
->cookie
== prev_cookie
) {
184 ne
.action
= NOTIFY_ACTION_NEW_NAME
;
186 ne
.action
= NOTIFY_ACTION_ADDED
;
189 ne
.action
= NOTIFY_ACTION_MODIFIED
;
193 DEBUG(10, ("inotify_dispatch: ne.action = %d, ne.path = %s\n",
194 ne
.action
, ne
.path
));
196 /* find any watches that have this watch descriptor */
197 for (w
=in
->watches
;w
;w
=next
) {
199 if (w
->wd
== e
->wd
&& filter_match(w
, e
)) {
200 w
->callback(in
->ctx
, w
->private_data
, &ne
);
204 /* SMB expects a file rename to generate three events, two for
205 the rename and the other for a modify of the
206 destination. Strange! */
207 if (ne
.action
!= NOTIFY_ACTION_NEW_NAME
||
208 (e
->mask
& IN_ISDIR
) != 0) {
212 ne
.action
= NOTIFY_ACTION_MODIFIED
;
215 for (w
=in
->watches
;w
;w
=next
) {
217 if (w
->wd
== e
->wd
&& filter_match(w
, e
) &&
218 !(w
->filter
& FILE_NOTIFY_CHANGE_CREATION
)) {
219 w
->callback(in
->ctx
, w
->private_data
, &ne
);
225 called when the kernel has some events for us
227 static void inotify_handler(struct event_context
*ev
, struct fd_event
*fde
,
228 uint16_t flags
, void *private_data
)
230 struct inotify_private
*in
= talloc_get_type(private_data
,
231 struct inotify_private
);
233 struct inotify_event
*e0
, *e
;
234 uint32_t prev_cookie
=0;
237 we must use FIONREAD as we cannot predict the length of the
238 filenames, and thus can't know how much to allocate
241 if (ioctl(in
->fd
, FIONREAD
, &bufsize
) != 0 ||
243 DEBUG(0,("No data on inotify fd?!\n"));
248 e0
= e
= (struct inotify_event
*)TALLOC_SIZE(in
, bufsize
);
249 if (e
== NULL
) return;
251 if (sys_read(in
->fd
, e0
, bufsize
) != bufsize
) {
252 DEBUG(0,("Failed to read all inotify data\n"));
257 /* we can get more than one event in the buffer */
258 while (e
&& (bufsize
>= sizeof(*e
))) {
259 struct inotify_event
*e2
= NULL
;
260 bufsize
-= e
->len
+ sizeof(*e
);
261 if (bufsize
>= sizeof(*e
)) {
262 e2
= (struct inotify_event
*)(e
->len
+ sizeof(*e
) + (char *)e
);
264 inotify_dispatch(in
, e
, prev_cookie
, e2
);
265 prev_cookie
= e
->cookie
;
273 setup the inotify handle - called the first time a watch is added on
276 static NTSTATUS
inotify_setup(struct sys_notify_context
*ctx
)
278 struct inotify_private
*in
;
280 if (!lp_parm_bool(-1, "notify", "inotify", True
)) {
281 return NT_STATUS_INVALID_SYSTEM_SERVICE
;
284 in
= talloc(ctx
, struct inotify_private
);
285 NT_STATUS_HAVE_NO_MEMORY(in
);
286 in
->fd
= inotify_init();
288 DEBUG(0,("Failed to init inotify - %s\n", strerror(errno
)));
290 return map_nt_error_from_unix(errno
);
295 ctx
->private_data
= in
;
296 talloc_set_destructor(in
, inotify_destructor
);
298 /* add a event waiting for the inotify fd to be readable */
299 event_add_fd(ctx
->ev
, in
, in
->fd
, EVENT_FD_READ
, inotify_handler
, in
);
306 map from a change notify mask to a inotify mask. Remove any bits
309 static const struct {
310 uint32_t notify_mask
;
311 uint32_t inotify_mask
;
312 } inotify_mapping
[] = {
313 {FILE_NOTIFY_CHANGE_FILE_NAME
, IN_CREATE
|IN_DELETE
|IN_MOVED_FROM
|IN_MOVED_TO
},
314 {FILE_NOTIFY_CHANGE_DIR_NAME
, IN_CREATE
|IN_DELETE
|IN_MOVED_FROM
|IN_MOVED_TO
},
315 {FILE_NOTIFY_CHANGE_ATTRIBUTES
, IN_ATTRIB
|IN_MOVED_TO
|IN_MOVED_FROM
|IN_MODIFY
},
316 {FILE_NOTIFY_CHANGE_LAST_WRITE
, IN_ATTRIB
},
317 {FILE_NOTIFY_CHANGE_LAST_ACCESS
, IN_ATTRIB
},
318 {FILE_NOTIFY_CHANGE_EA
, IN_ATTRIB
},
319 {FILE_NOTIFY_CHANGE_SECURITY
, IN_ATTRIB
},
320 {FILE_NOTIFY_CHANGE_FILE_CONTENT
, IN_MODIFY
|IN_DELETE
|IN_CREATE
|IN_DELETE_SELF
321 |IN_MOVE_SELF
|IN_MOVED_FROM
|IN_MOVED_TO
},
324 static uint32_t inotify_map(struct notify_entry
*e
)
328 for (i
=0;i
<ARRAY_SIZE(inotify_mapping
);i
++) {
329 if (inotify_mapping
[i
].notify_mask
& e
->filter
) {
330 out
|= inotify_mapping
[i
].inotify_mask
;
331 e
->filter
&= ~inotify_mapping
[i
].notify_mask
;
340 static int watch_destructor(struct inotify_watch_context
*w
)
342 struct inotify_private
*in
= w
->in
;
344 DLIST_REMOVE(w
->in
->watches
, w
);
346 /* only rm the watch if its the last one with this wd */
347 for (w
=in
->watches
;w
;w
=w
->next
) {
348 if (w
->wd
== wd
) break;
351 DEBUG(10, ("Deleting inotify watch %d\n", wd
));
352 if (inotify_rm_watch(in
->fd
, wd
) == -1) {
353 DEBUG(1, ("inotify_rm_watch returned %s\n",
363 add a watch. The watch is removed when the caller calls
364 talloc_free() on *handle
366 NTSTATUS
inotify_watch(struct sys_notify_context
*ctx
,
367 struct notify_entry
*e
,
368 void (*callback
)(struct sys_notify_context
*ctx
,
370 struct notify_event
*ev
),
374 struct inotify_private
*in
;
377 struct inotify_watch_context
*w
;
378 uint32_t filter
= e
->filter
;
379 void **handle
= (void **)handle_p
;
381 /* maybe setup the inotify fd */
382 if (ctx
->private_data
== NULL
) {
384 status
= inotify_setup(ctx
);
385 NT_STATUS_NOT_OK_RETURN(status
);
388 in
= talloc_get_type(ctx
->private_data
, struct inotify_private
);
390 mask
= inotify_map(e
);
392 /* this filter can't be handled by inotify */
393 return NT_STATUS_INVALID_PARAMETER
;
396 /* using IN_MASK_ADD allows us to cope with inotify() returning the same
397 watch descriptor for muliple watches on the same path */
398 mask
|= (IN_MASK_ADD
| IN_ONLYDIR
);
400 /* get a new watch descriptor for this path */
401 wd
= inotify_add_watch(in
->fd
, e
->path
, mask
);
404 DEBUG(1, ("inotify_add_watch returned %s\n", strerror(errno
)));
405 return map_nt_error_from_unix(errno
);
408 DEBUG(10, ("inotify_add_watch for %s mask %x returned wd %d\n",
411 w
= talloc(in
, struct inotify_watch_context
);
413 inotify_rm_watch(in
->fd
, wd
);
415 return NT_STATUS_NO_MEMORY
;
420 w
->callback
= callback
;
421 w
->private_data
= private_data
;
424 w
->path
= talloc_strdup(w
, e
->path
);
425 if (w
->path
== NULL
) {
426 inotify_rm_watch(in
->fd
, wd
);
428 return NT_STATUS_NO_MEMORY
;
433 DLIST_ADD(in
->watches
, w
);
435 /* the caller frees the handle to stop watching */
436 talloc_set_destructor(w
, watch_destructor
);