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
25 #include "../librpc/gen_ndr/notify.h"
26 #include "smbd/smbd.h"
27 #include "lib/sys_rw_data.h"
31 #include <sys/inotify.h>
33 /* glibc < 2.5 headers don't have these defines */
35 #define IN_ONLYDIR 0x01000000
38 #define IN_MASK_ADD 0x20000000
41 struct inotify_private
{
42 struct sys_notify_context
*ctx
;
44 struct inotify_watch_context
*watches
;
47 struct inotify_watch_context
{
48 struct inotify_watch_context
*next
, *prev
;
49 struct inotify_private
*in
;
51 void (*callback
)(struct sys_notify_context
*ctx
,
53 struct notify_event
*ev
);
55 uint32_t mask
; /* the inotify mask */
56 uint32_t filter
; /* the windows completion filter */
62 destroy the inotify private context
64 static int inotify_destructor(struct inotify_private
*in
)
72 see if a particular event from inotify really does match a requested
75 static bool filter_match(struct inotify_watch_context
*w
,
76 struct inotify_event
*e
)
80 DEBUG(10, ("filter_match: e->mask=%x, w->mask=%x, w->filter=%x\n",
81 e
->mask
, w
->mask
, w
->filter
));
83 if ((e
->mask
& w
->mask
) == 0) {
84 /* this happens because inotify_add_watch() coalesces watches on the same
85 path, oring their masks together */
89 /* SMB separates the filters for files and directories */
90 if (e
->mask
& IN_ISDIR
) {
91 ok
= ((w
->filter
& FILE_NOTIFY_CHANGE_DIR_NAME
) != 0);
95 if ((e
->mask
& IN_ATTRIB
) &&
96 (w
->filter
& (FILE_NOTIFY_CHANGE_ATTRIBUTES
|
97 FILE_NOTIFY_CHANGE_LAST_WRITE
|
98 FILE_NOTIFY_CHANGE_LAST_ACCESS
|
99 FILE_NOTIFY_CHANGE_EA
|
100 FILE_NOTIFY_CHANGE_SECURITY
))) {
103 if ((e
->mask
& IN_MODIFY
) &&
104 (w
->filter
& FILE_NOTIFY_CHANGE_ATTRIBUTES
)) {
108 ok
= ((w
->filter
& FILE_NOTIFY_CHANGE_FILE_NAME
) != 0);
115 dispatch one inotify event
117 the cookies are used to correctly handle renames
119 static void inotify_dispatch(struct inotify_private
*in
,
120 struct inotify_event
*e
,
122 uint32_t prev_cookie
,
123 struct inotify_event
*e2
)
125 struct inotify_watch_context
*w
, *next
;
126 struct notify_event ne
;
128 DEBUG(10, ("inotify_dispatch called with mask=%x, name=[%s]\n",
129 e
->mask
, e
->len
? e
->name
: ""));
131 /* ignore extraneous events, such as unmount and IN_IGNORED events */
132 if ((e
->mask
& (IN_ATTRIB
|IN_MODIFY
|IN_CREATE
|IN_DELETE
|
133 IN_MOVED_FROM
|IN_MOVED_TO
)) == 0) {
137 /* map the inotify mask to a action. This gets complicated for
139 if (e
->mask
& IN_CREATE
) {
140 ne
.action
= NOTIFY_ACTION_ADDED
;
141 } else if (e
->mask
& IN_DELETE
) {
142 ne
.action
= NOTIFY_ACTION_REMOVED
;
143 } else if (e
->mask
& IN_MOVED_FROM
) {
144 if (e2
!= NULL
&& e2
->cookie
== e
->cookie
&&
146 ne
.action
= NOTIFY_ACTION_OLD_NAME
;
148 ne
.action
= NOTIFY_ACTION_REMOVED
;
150 } else if (e
->mask
& IN_MOVED_TO
) {
151 if ((e
->cookie
== prev_cookie
) && (e
->wd
== prev_wd
)) {
152 ne
.action
= NOTIFY_ACTION_NEW_NAME
;
154 ne
.action
= NOTIFY_ACTION_ADDED
;
157 ne
.action
= NOTIFY_ACTION_MODIFIED
;
161 DEBUG(10, ("inotify_dispatch: ne.action = %d, ne.path = %s\n",
162 ne
.action
, ne
.path
));
164 /* find any watches that have this watch descriptor */
165 for (w
=in
->watches
;w
;w
=next
) {
167 if (w
->wd
== e
->wd
&& filter_match(w
, e
)) {
168 w
->callback(in
->ctx
, w
->private_data
, &ne
);
172 /* SMB expects a file rename to generate three events, two for
173 the rename and the other for a modify of the
174 destination. Strange! */
175 if (ne
.action
!= NOTIFY_ACTION_NEW_NAME
||
176 (e
->mask
& IN_ISDIR
) != 0) {
180 ne
.action
= NOTIFY_ACTION_MODIFIED
;
183 for (w
=in
->watches
;w
;w
=next
) {
185 if (w
->wd
== e
->wd
&& filter_match(w
, e
) &&
186 !(w
->filter
& FILE_NOTIFY_CHANGE_CREATION
)) {
187 w
->callback(in
->ctx
, w
->private_data
, &ne
);
193 called when the kernel has some events for us
195 static void inotify_handler(struct tevent_context
*ev
, struct tevent_fd
*fde
,
196 uint16_t flags
, void *private_data
)
198 struct inotify_private
*in
= talloc_get_type(private_data
,
199 struct inotify_private
);
201 struct inotify_event
*e0
, *e
;
202 uint32_t prev_cookie
=0;
207 we must use FIONREAD as we cannot predict the length of the
208 filenames, and thus can't know how much to allocate
211 if (ioctl(in
->fd
, FIONREAD
, &bufsize
) != 0 ||
213 DEBUG(0,("No data on inotify fd?!\n"));
218 e0
= e
= (struct inotify_event
*)TALLOC_SIZE(in
, bufsize
+ 1);
219 if (e
== NULL
) return;
220 ((uint8_t *)e
)[bufsize
] = '\0';
222 ret
= read_data(in
->fd
, e0
, bufsize
);
223 if (ret
!= bufsize
) {
224 DEBUG(0, ("Failed to read all inotify data - %s\n",
227 /* the inotify fd will now be out of sync,
228 * can't keep reading data off it */
233 /* we can get more than one event in the buffer */
234 while (e
&& (bufsize
>= sizeof(*e
))) {
235 struct inotify_event
*e2
= NULL
;
236 bufsize
-= e
->len
+ sizeof(*e
);
237 if (bufsize
>= sizeof(*e
)) {
238 e2
= (struct inotify_event
*)(e
->len
+ sizeof(*e
) + (char *)e
);
240 inotify_dispatch(in
, e
, prev_wd
, prev_cookie
, e2
);
242 prev_cookie
= e
->cookie
;
250 setup the inotify handle - called the first time a watch is added on
253 static NTSTATUS
inotify_setup(struct sys_notify_context
*ctx
)
255 struct inotify_private
*in
;
256 struct tevent_fd
*fde
;
258 in
= talloc(ctx
, struct inotify_private
);
259 NT_STATUS_HAVE_NO_MEMORY(in
);
260 in
->fd
= inotify_init();
262 DEBUG(0,("Failed to init inotify - %s\n", strerror(errno
)));
264 return map_nt_error_from_unix(errno
);
269 ctx
->private_data
= in
;
270 talloc_set_destructor(in
, inotify_destructor
);
272 /* add a event waiting for the inotify fd to be readable */
273 fde
= tevent_add_fd(ctx
->ev
, in
, in
->fd
, TEVENT_FD_READ
,
274 inotify_handler
, in
);
276 ctx
->private_data
= NULL
;
278 return NT_STATUS_NO_MEMORY
;
286 map from a change notify mask to a inotify mask. Remove any bits
289 static const struct {
290 uint32_t notify_mask
;
291 uint32_t inotify_mask
;
292 } inotify_mapping
[] = {
293 {FILE_NOTIFY_CHANGE_FILE_NAME
, IN_CREATE
|IN_DELETE
|IN_MOVED_FROM
|IN_MOVED_TO
},
294 {FILE_NOTIFY_CHANGE_DIR_NAME
, IN_CREATE
|IN_DELETE
|IN_MOVED_FROM
|IN_MOVED_TO
},
295 {FILE_NOTIFY_CHANGE_ATTRIBUTES
, IN_ATTRIB
|IN_MOVED_TO
|IN_MOVED_FROM
|IN_MODIFY
},
296 {FILE_NOTIFY_CHANGE_LAST_WRITE
, IN_ATTRIB
},
297 {FILE_NOTIFY_CHANGE_LAST_ACCESS
, IN_ATTRIB
},
298 {FILE_NOTIFY_CHANGE_EA
, IN_ATTRIB
},
299 {FILE_NOTIFY_CHANGE_SECURITY
, IN_ATTRIB
}
302 static uint32_t inotify_map(uint32_t *filter
)
306 for (i
=0;i
<ARRAY_SIZE(inotify_mapping
);i
++) {
307 if (inotify_mapping
[i
].notify_mask
& *filter
) {
308 out
|= inotify_mapping
[i
].inotify_mask
;
309 *filter
&= ~inotify_mapping
[i
].notify_mask
;
318 static int watch_destructor(struct inotify_watch_context
*w
)
320 struct inotify_private
*in
= w
->in
;
322 DLIST_REMOVE(w
->in
->watches
, w
);
324 /* only rm the watch if its the last one with this wd */
325 for (w
=in
->watches
;w
;w
=w
->next
) {
326 if (w
->wd
== wd
) break;
329 DEBUG(10, ("Deleting inotify watch %d\n", wd
));
330 if (inotify_rm_watch(in
->fd
, wd
) == -1) {
331 DEBUG(1, ("inotify_rm_watch returned %s\n",
341 add a watch. The watch is removed when the caller calls
342 talloc_free() on *handle
344 NTSTATUS
inotify_watch(struct sys_notify_context
*ctx
,
347 uint32_t *subdir_filter
,
348 void (*callback
)(struct sys_notify_context
*ctx
,
350 struct notify_event
*ev
),
354 struct inotify_private
*in
;
357 struct inotify_watch_context
*w
;
358 uint32_t orig_filter
= *filter
;
359 void **handle
= (void **)handle_p
;
361 /* maybe setup the inotify fd */
362 if (ctx
->private_data
== NULL
) {
364 status
= inotify_setup(ctx
);
365 NT_STATUS_NOT_OK_RETURN(status
);
368 in
= talloc_get_type(ctx
->private_data
, struct inotify_private
);
370 mask
= inotify_map(filter
);
372 /* this filter can't be handled by inotify */
373 return NT_STATUS_INVALID_PARAMETER
;
376 /* using IN_MASK_ADD allows us to cope with inotify() returning the same
377 watch descriptor for multiple watches on the same path */
378 mask
|= (IN_MASK_ADD
| IN_ONLYDIR
);
380 /* get a new watch descriptor for this path */
381 wd
= inotify_add_watch(in
->fd
, path
, mask
);
383 *filter
= orig_filter
;
384 DEBUG(1, ("inotify_add_watch returned %s\n", strerror(errno
)));
385 return map_nt_error_from_unix(errno
);
388 DEBUG(10, ("inotify_add_watch for %s mask %x returned wd %d\n",
391 w
= talloc(in
, struct inotify_watch_context
);
393 inotify_rm_watch(in
->fd
, wd
);
394 *filter
= orig_filter
;
395 return NT_STATUS_NO_MEMORY
;
400 w
->callback
= callback
;
401 w
->private_data
= private_data
;
403 w
->filter
= orig_filter
;
404 w
->path
= talloc_strdup(w
, path
);
405 if (w
->path
== NULL
) {
406 inotify_rm_watch(in
->fd
, wd
);
407 *filter
= orig_filter
;
409 return NT_STATUS_NO_MEMORY
;
414 DLIST_ADD(in
->watches
, w
);
416 /* the caller frees the handle to stop watching */
417 talloc_set_destructor(w
, watch_destructor
);