source: vendor/3.5.10/source3/modules/onefs_notify.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 21.5 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 *
4 * Support for change notify using OneFS's file event notification system
5 *
6 * Copyright (C) Andrew Tridgell, 2006
7 * Copyright (C) Steven Danneman, 2008
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 3 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 */
22
23/* Implement handling of change notify requests on files and directories using
24 * Isilon OneFS's "ifs event" file notification system.
25 *
26 * The structure of this file is based off the implementation of change notify
27 * using the inotify system calls in smbd/notify_inotify.c */
28
29/* TODO: We could reduce the number of file descriptors used by merging
30 * multiple watch requests on the same directory into the same
31 * onefs_notify_watch_context. To do this we'd need mux/demux routines that
32 * when receiving an event on that watch context would check it against the
33 * CompletionFilter and WatchTree of open SMB requests, and return notify
34 * events back to the proper SMB requests */
35
36#include "includes.h"
37#include "onefs.h"
38
39#include <ifs/ifs_types.h>
40#include <ifs/ifs_syscalls.h>
41#include <isi_util/syscalls.h>
42
43#include <sys/event.h>
44
45#define ONEFS_IFS_EVENT_MAX_NUM 8
46#define ONEFS_IFS_EVENT_MAX_BYTES (ONEFS_IFS_EVENT_MAX_NUM * \
47 sizeof(struct ifs_event))
48
49struct onefs_notify_watch_context {
50 struct sys_notify_context *ctx;
51 int watch_fd;
52 ino_t watch_lin;
53 const char *path;
54 int ifs_event_fd;
55 uint32_t ifs_filter; /* the ifs event mask */
56 uint32_t smb_filter; /* the windows completion filter */
57 void (*callback)(struct sys_notify_context *ctx,
58 void *private_data,
59 struct notify_event *ev);
60 void *private_data;
61};
62
63/**
64 * Conversion map from a SMB completion filter to an IFS event mask.
65 */
66static const struct {
67 uint32_t smb_filter;
68 uint32_t ifs_filter;
69} onefs_notify_conv[] = {
70 {FILE_NOTIFY_CHANGE_FILE_NAME,
71 NOTE_CREATE | NOTE_DELETE | NOTE_RENAME_FROM | NOTE_RENAME_TO},
72 {FILE_NOTIFY_CHANGE_DIR_NAME,
73 NOTE_CREATE | NOTE_DELETE | NOTE_RENAME_FROM | NOTE_RENAME_TO},
74 {FILE_NOTIFY_CHANGE_ATTRIBUTES,
75 NOTE_CREATE | NOTE_DELETE | NOTE_RENAME_FROM | NOTE_RENAME_TO |
76 NOTE_ATTRIB},
77 {FILE_NOTIFY_CHANGE_SIZE,
78 NOTE_SIZE | NOTE_EXTEND},
79 {FILE_NOTIFY_CHANGE_LAST_WRITE,
80 NOTE_WRITE | NOTE_ATTRIB},
81 /* OneFS doesn't set atime by default, but we can somewhat fake it by
82 * notifying for other events that imply ACCESS */
83 {FILE_NOTIFY_CHANGE_LAST_ACCESS,
84 NOTE_WRITE | NOTE_ATTRIB},
85 /* We don't have an ifs_event for the setting of create time, but we
86 * can fake by notifying when a "new" file is created via rename */
87 {FILE_NOTIFY_CHANGE_CREATION,
88 NOTE_RENAME_TO},
89 {FILE_NOTIFY_CHANGE_SECURITY,
90 NOTE_SECURITY},
91 /* Unsupported bits
92 FILE_NOTIFY_CHANGE_EA (no EAs in OneFS)
93 FILE_NOTIFY_CHANGE_STREAM_NAME (no ifs_event equivalent)
94 FILE_NOTIFY_CHANGE_STREAM_SIZE (no ifs_event equivalent)
95 FILE_NOTIFY_CHANGE_STREAM_WRITE (no ifs_event equivalent) */
96};
97
98#define ONEFS_NOTIFY_UNSUPPORTED (FILE_NOTIFY_CHANGE_LAST_ACCESS | \
99 FILE_NOTIFY_CHANGE_CREATION | \
100 FILE_NOTIFY_CHANGE_EA | \
101 FILE_NOTIFY_CHANGE_STREAM_NAME | \
102 FILE_NOTIFY_CHANGE_STREAM_SIZE | \
103 FILE_NOTIFY_CHANGE_STREAM_WRITE)
104
105/**
106 * Convert Windows/SMB filter/flags to IFS event filter.
107 *
108 * @param[in] smb_filter Windows Completion Filter sent in the SMB
109 *
110 * @return ifs event filter mask
111 */
112static uint32_t
113onefs_notify_smb_filter_to_ifs_filter(uint32_t smb_filter)
114{
115 int i;
116 uint32_t ifs_filter = 0x0;
117
118 for (i=0;i<ARRAY_SIZE(onefs_notify_conv);i++) {
119 if (onefs_notify_conv[i].smb_filter & smb_filter) {
120 ifs_filter |= onefs_notify_conv[i].ifs_filter;
121 }
122 }
123
124 return ifs_filter;
125}
126
127/**
128 * Convert IFS filter/flags to a Windows notify action.
129 *
130 * Returns Win notification actions, types (1-5).
131 *
132 * @param[in] smb_filter Windows Completion Filter sent in the SMB
133 * @param[in] ifs_filter Returned from the kernel in the ifs_event
134 *
135 * @return 0 if there are no more relevant flags.
136 */
137static int
138onefs_notify_ifs_filter_to_smb_action(uint32_t smb_filter, uint32_t ifs_filter)
139{
140 /* Handle Windows special cases, before modifying events bitmask */
141
142 /* Special case 1: win32api->MoveFile needs to send a modified
143 * notification on the new file, if smb_filter == ATTRIBUTES.
144 * Here we handle the case where two separate ATTR & NAME notifications
145 * have been registered. We handle the case where both bits are set in
146 * the same registration in onefs_notify_dispatch() */
147 if ((smb_filter & FILE_NOTIFY_CHANGE_ATTRIBUTES) &&
148 !(smb_filter & FILE_NOTIFY_CHANGE_FILE_NAME) &&
149 (ifs_filter & NOTE_FILE) && (ifs_filter & NOTE_RENAME_TO))
150 {
151 return NOTIFY_ACTION_MODIFIED;
152 }
153
154 /* Special case 2: Writes need to send a modified
155 * notification on the file, if smb_filter = ATTRIBUTES. */
156 if ((smb_filter & FILE_NOTIFY_CHANGE_ATTRIBUTES) &&
157 (ifs_filter & NOTE_FILE) && (ifs_filter & NOTE_WRITE))
158 {
159 return NOTIFY_ACTION_MODIFIED;
160 }
161
162 /* Loop because some events may be filtered out. Eventually all
163 * relevant events will be taken care of and returned. */
164 while (1) {
165 if (ifs_filter & NOTE_CREATE) {
166 ifs_filter &= ~NOTE_CREATE;
167 if ((smb_filter & FILE_NOTIFY_CHANGE_FILE_NAME) &&
168 (ifs_filter & NOTE_FILE))
169 return NOTIFY_ACTION_ADDED;
170 if ((smb_filter & FILE_NOTIFY_CHANGE_DIR_NAME) &&
171 (ifs_filter & NOTE_DIRECTORY))
172 return NOTIFY_ACTION_ADDED;
173 }
174 else if (ifs_filter & NOTE_DELETE) {
175 ifs_filter &= ~NOTE_DELETE;
176 if ((smb_filter & FILE_NOTIFY_CHANGE_FILE_NAME) &&
177 (ifs_filter & NOTE_FILE))
178 return NOTIFY_ACTION_REMOVED;
179 if ((smb_filter & FILE_NOTIFY_CHANGE_DIR_NAME) &&
180 (ifs_filter & NOTE_DIRECTORY))
181 return NOTIFY_ACTION_REMOVED;
182 }
183 else if (ifs_filter & NOTE_WRITE) {
184 ifs_filter &= ~NOTE_WRITE;
185 if ((smb_filter & FILE_NOTIFY_CHANGE_LAST_WRITE) ||
186 (smb_filter & FILE_NOTIFY_CHANGE_LAST_ACCESS))
187 return NOTIFY_ACTION_MODIFIED;
188 }
189 else if ((ifs_filter & NOTE_SIZE) || (ifs_filter & NOTE_EXTEND)) {
190 ifs_filter &= ~NOTE_SIZE;
191 ifs_filter &= ~NOTE_EXTEND;
192
193 /* TODO: Do something on NOTE_DIR? */
194 if ((smb_filter & FILE_NOTIFY_CHANGE_SIZE) &&
195 (ifs_filter & NOTE_FILE))
196 return NOTIFY_ACTION_MODIFIED;
197 }
198 else if (ifs_filter & NOTE_ATTRIB) {
199 ifs_filter &= ~NOTE_ATTRIB;
200 /* NOTE_ATTRIB needs to be converted to a
201 * LAST_WRITE as well, because we need to send
202 * LAST_WRITE when the mtime changes. Looking into
203 * better alternatives as this causes extra LAST_WRITE
204 * notifications. We also return LAST_ACCESS as a
205 * modification to attribs implies this. */
206 if ((smb_filter & FILE_NOTIFY_CHANGE_ATTRIBUTES) ||
207 (smb_filter & FILE_NOTIFY_CHANGE_LAST_WRITE) ||
208 (smb_filter & FILE_NOTIFY_CHANGE_LAST_ACCESS))
209 return NOTIFY_ACTION_MODIFIED;
210 }
211 else if (ifs_filter & NOTE_LINK) {
212 ifs_filter &= ~NOTE_LINK;
213 /* NOTE_LINK will send out NO notifications */
214 }
215 else if (ifs_filter & NOTE_REVOKE) {
216 ifs_filter &= ~NOTE_REVOKE;
217 /* NOTE_REVOKE will send out NO notifications */
218 }
219 else if (ifs_filter & NOTE_RENAME_FROM) {
220 ifs_filter &= ~NOTE_RENAME_FROM;
221
222 if (((smb_filter & FILE_NOTIFY_CHANGE_FILE_NAME) &&
223 (ifs_filter & NOTE_FILE)) ||
224 ((smb_filter & FILE_NOTIFY_CHANGE_DIR_NAME) &&
225 (ifs_filter & NOTE_DIRECTORY))) {
226 /* Check if this is a RENAME, not a MOVE */
227 if (ifs_filter & NOTE_RENAME_SAMEDIR) {
228 /* Remove the NOTE_RENAME_SAMEDIR, IFF
229 * RENAME_TO is not in this event */
230 if (!(ifs_filter & NOTE_RENAME_TO))
231 ifs_filter &=
232 ~NOTE_RENAME_SAMEDIR;
233 return NOTIFY_ACTION_OLD_NAME;
234 }
235 return NOTIFY_ACTION_REMOVED;
236 }
237 }
238 else if (ifs_filter & NOTE_RENAME_TO) {
239 ifs_filter &= ~NOTE_RENAME_TO;
240
241 if (((smb_filter & FILE_NOTIFY_CHANGE_FILE_NAME) &&
242 (ifs_filter & NOTE_FILE)) ||
243 ((smb_filter & FILE_NOTIFY_CHANGE_DIR_NAME) &&
244 (ifs_filter & NOTE_DIRECTORY))) {
245 /* Check if this is a RENAME, not a MOVE */
246 if (ifs_filter & NOTE_RENAME_SAMEDIR) {
247 /* Remove the NOTE_RENAME_SAMEDIR, IFF
248 * RENAME_FROM is not in this event */
249 if (!(ifs_filter & NOTE_RENAME_FROM))
250 ifs_filter &=
251 ~NOTE_RENAME_SAMEDIR;
252 return NOTIFY_ACTION_NEW_NAME;
253 }
254 return NOTIFY_ACTION_ADDED;
255 }
256 /* RAW-NOTIFY shows us that a rename triggers a
257 * creation time change */
258 if ((smb_filter & FILE_NOTIFY_CHANGE_CREATION) &&
259 (ifs_filter & NOTE_FILE))
260 return NOTIFY_ACTION_MODIFIED;
261 }
262 else if (ifs_filter & NOTE_SECURITY) {
263 ifs_filter &= ~NOTE_SECURITY;
264
265 if (smb_filter & FILE_NOTIFY_CHANGE_SECURITY)
266 return NOTIFY_ACTION_MODIFIED;
267 } else {
268 /* No relevant flags found */
269 return 0;
270 }
271 }
272}
273
274/**
275 * Retrieve a directory path of a changed file, relative to the watched dir
276 *
277 * @param[in] wc watch context for the returned event
278 * @param[in] e ifs_event notification returned from the kernel
279 * @param[out] path name relative to the watched dir. This is talloced
280 * off of wc and needs to be freed by the caller.
281 *
282 * @return true on success
283 *
284 * TODO: This function currently doesn't handle path names with multiple
285 * encodings. enc_get_lin_path() should be used in the future to convert
286 * each path segment's encoding to UTF-8
287 */
288static bool
289get_ifs_event_path(struct onefs_notify_watch_context *wc, struct ifs_event *e,
290 char **path)
291{
292 char *path_buf = NULL;
293 size_t pathlen = 0;
294 int error = 0;
295
296 SMB_ASSERT(path);
297
298 /* Lookup the path from watch_dir through our parent dir */
299 if (e->namelen > 0) {
300 error = lin_get_path(wc->watch_lin,
301 e->parent_lin,
302 HEAD_SNAPID,
303 e->parent_parent_lin,
304 e->parent_name_hash,
305 &pathlen, &path_buf);
306 if (!error) {
307 /* Only add slash if a path exists in path_buf from
308 * lin_get_path call. Windows does not expect a
309 * leading '/' */
310 if (pathlen > 0)
311 *path = talloc_asprintf(wc, "%s/%s",
312 path_buf, e->name);
313 else
314 *path = talloc_asprintf(wc, "%s", e->name);
315 SAFE_FREE(path_buf);
316 }
317 }
318
319 /* If ifs_event didn't return a name, or we errored out of our intial
320 * path lookup, try again using the lin of the changed file */
321 if (!(*path)) {
322 error = lin_get_path(wc->watch_lin,
323 e->lin,
324 HEAD_SNAPID,
325 e->parent_lin,
326 e->name_hash,
327 &pathlen, &path_buf);
328 if (error) {
329 /* It's possible that both the lin and the parent lin
330 * are invalid (or not given) -- we will skip these
331 * events. */
332 DEBUG(3,("Path lookup failed. LINS are invalid: "
333 "e->lin: 0x%llu, e->parent_lin: 0x%llu, "
334 "e->parent_parent_lin: 0x%llu\n",
335 e->lin, e->parent_lin, e->parent_parent_lin));
336 SAFE_FREE(path_buf);
337 return false;
338 } else {
339 *path = talloc_asprintf(wc, "%s", path_buf);
340 DEBUG(5, ("Using path from event LIN = %s\n",
341 path_buf));
342 SAFE_FREE(path_buf);
343 }
344 }
345
346 /* Replacement of UNIX slashes with WIN slashes is handled at a
347 * higher layer. */
348
349 return true;
350}
351
352/**
353 * Dispatch one OneFS notify event to the general Samba code
354 *
355 * @param[in] wc watch context for the returned event
356 * @param[in] e event returned from the kernel
357 *
358 * @return nothing
359 */
360static void
361onefs_notify_dispatch(struct onefs_notify_watch_context *wc,
362 struct ifs_event *e)
363{
364 char *path = NULL;
365 struct notify_event ne;
366
367 DEBUG(5, ("Retrieved ifs event from kernel: lin=%#llx, ifs_events=%#x, "
368 "parent_lin=%#llx, namelen=%d, name=\"%s\"\n",
369 e->lin, e->events, e->parent_lin, e->namelen, e->name));
370
371 /* Check validity of event returned from kernel */
372 if (e->lin == 0) {
373 /* The lin == 0 specifies 1 of 2 cases:
374 * 1) We are out of events. The kernel has a limited
375 * amount (somewhere near 90000)
376 * 2) Split nodes have merged back and had data written
377 * to them -- thus we've missed some of those events. */
378 DEBUG(3, ("We've missed some kernel ifs events!\n"));
379
380 /* Alert higher level to the problem so it returns catch-all
381 * response to the client */
382 ne.path = NULL;
383 ne.action = 0;
384 wc->callback(wc->ctx, wc->private_data, &ne);
385 }
386
387 if (e->lin == wc->watch_lin) {
388 /* Windows doesn't report notifications on root
389 * watched directory */
390 /* TODO: This should be abstracted out to the general layer
391 * instead of being handled in every notify provider */
392 DEBUG(5, ("Skipping notification on root of the watched "
393 "path.\n"));
394 return;
395 }
396
397 /* Retrieve the full path for the ifs event name */
398 if(!get_ifs_event_path(wc, e, &path)) {
399 DEBUG(3, ("Failed to convert the ifs_event lins to a path. "
400 "Skipping this event\n"));
401 return;
402 }
403
404 if (!strncmp(path, ".ifsvar", 7)) {
405 /* Skip notifications on file if its in ifs configuration
406 * directory */
407 goto clean;
408 }
409
410 ne.path = path;
411
412 /* Convert ifs event mask to an smb action mask */
413 ne.action = onefs_notify_ifs_filter_to_smb_action(wc->smb_filter,
414 e->events);
415
416 DEBUG(5, ("Converted smb_filter=%#x, ifs_events=%#x, to "
417 "ne.action = %d, for ne.path = %s\n",
418 wc->smb_filter, e->events, ne.action, ne.path));
419
420 if (!ne.action)
421 goto clean;
422
423 /* Return notify_event to higher level */
424 wc->callback(wc->ctx, wc->private_data, &ne);
425
426 /* SMB expects a file rename/move to generate three actions, a
427 * rename_from/delete on the from file, a rename_to/create on the to
428 * file, and a modify for the rename_to file. If we have two separate
429 * notifications registered for ATTRIBUTES and FILENAME, this case will
430 * be handled by separate ifs_events in
431 * onefs_notify_ifs_filter_to_smb_action(). If both bits are registered
432 * in the same notification, we must send an extra MODIFIED action
433 * here. */
434 if ((wc->smb_filter & FILE_NOTIFY_CHANGE_ATTRIBUTES) &&
435 (wc->smb_filter & FILE_NOTIFY_CHANGE_FILE_NAME) &&
436 (e->events & NOTE_FILE) && (e->events & NOTE_RENAME_TO))
437 {
438 ne.action = NOTIFY_ACTION_MODIFIED;
439 wc->callback(wc->ctx, wc->private_data, &ne);
440 }
441
442 /* FALLTHROUGH */
443clean:
444 talloc_free(path);
445 return;
446}
447
448/**
449 * Callback when the kernel has some events for us
450 *
451 * Read events off ifs event fd and pass them to our dispatch function
452 *
453 * @param ev context of all tevents registered in the smbd
454 * @param fde tevent struct specific to one ifs event channel
455 * @param flags tevent flags passed when we added our ifs event channel fd to
456 * the main loop
457 * @param private_data onefs_notify_watch_context specific to this ifs event
458 * channel
459 *
460 * @return nothing
461 */
462static void
463onefs_notify_handler(struct event_context *ev,
464 struct fd_event *fde,
465 uint16_t flags,
466 void *private_data)
467{
468 struct onefs_notify_watch_context *wc = NULL;
469 struct ifs_event ifs_events[ONEFS_IFS_EVENT_MAX_NUM];
470 ssize_t nread = 0;
471 int count = 0;
472 int i = 0;
473
474 wc = talloc_get_type(private_data, struct onefs_notify_watch_context);
475
476 /* Read as many ifs events from the notify channel as we can */
477 nread = sys_read(wc->ifs_event_fd, &ifs_events,
478 ONEFS_IFS_EVENT_MAX_BYTES);
479 if (nread == 0) {
480 DEBUG(0,("No data found while reading ifs event fd?!\n"));
481 return;
482 }
483 if (nread < 0) {
484 DEBUG(0,("Failed to read ifs event data: %s\n",
485 strerror(errno)));
486 return;
487 }
488
489 count = nread / sizeof(struct ifs_event);
490
491 DEBUG(5, ("Got %d notification events in %d bytes.\n", count, nread));
492
493 /* Dispatch ifs_events one-at-a-time to higher level */
494 for (i=0; i < count; i++) {
495 onefs_notify_dispatch(wc, &ifs_events[i]);
496 }
497}
498
499/**
500 * Destroy the ifs event channel
501 *
502 * This is called from talloc_free() when the generic Samba notify layer frees
503 * the onefs_notify_watch_context.
504 *
505 * @param[in] wc pointer to watch context which is being destroyed
506 *
507 * return 0 on success
508*/
509static int
510onefs_watch_destructor(struct onefs_notify_watch_context *wc)
511{
512 /* The ifs_event_fd will re de-registered from the event loop by
513 * another destructor triggered from the freeing of this wc */
514 close(wc->ifs_event_fd);
515 return 0;
516}
517
518/**
519 * Register a single change notify watch request.
520 *
521 * Open an event listener on a directory to watch for modifications. This
522 * channel is closed by a destructor when the caller calls talloc_free()
523 * on *handle.
524 *
525 * @param[in] vfs_handle handle given to most VFS operations
526 * @param[in] ctx context (conn and tevent) for this connection
527 * @param[in] e filter and path of client's notify request
528 * @param[in] callback function to call when file notification event is received
529 * from the kernel, passing that event up to Samba's
530 * generalized change notify layer
531 * @param[in] private_data opaque data given to us by the general change notify
532 * layer which must be returned in the callback function
533 * @param[out] handle_p handle returned to generalized change notify layer used
534 * to close the event channel when notification is
535 * cancelled
536 *
537 * @return NT_STATUS_OK unless error
538 */
539NTSTATUS
540onefs_notify_watch(vfs_handle_struct *vfs_handle,
541 struct sys_notify_context *ctx,
542 struct notify_entry *e,
543 void (*callback)(struct sys_notify_context *ctx,
544 void *private_data,
545 struct notify_event *ev),
546 void *private_data,
547 void *handle_p)
548{
549 int ifs_event_fd = -1;
550 uint32_t ifs_filter = 0;
551 uint32_t smb_filter = e->filter;
552 bool watch_tree = !!e->subdir_filter;
553 struct onefs_notify_watch_context *wc = NULL;
554 void **handle = (void **)handle_p;
555 SMB_STRUCT_STAT sbuf;
556 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
557
558 /* Fallback to default Samba implementation if kernel CN is disabled */
559 if (!lp_kernel_change_notify(vfs_handle->conn->params)) {
560 (*handle) = NULL;
561 return NT_STATUS_OK;
562 }
563
564 /* The OneFS open path should always give us a valid fd on a directory*/
565 SMB_ASSERT(e->dir_fd >= 0);
566
567 /* Always set e->filter to 0 so we don't fallback on the default change
568 * notify backend. It's not cluster coherent or cross-protocol so we
569 * can't guarantee correctness using it. */
570 e->filter = 0;
571 e->subdir_filter = 0;
572
573 /* Snapshots do not currently allow event listeners. See Isilon
574 * bug 33476 for an example of .snapshot debug spew that can occur. */
575 if (e->dir_id.extid != HEAD_SNAPID)
576 return NT_STATUS_INVALID_PARAMETER;
577
578 /* Convert Completion Filter mask to IFS Event mask */
579 ifs_filter = onefs_notify_smb_filter_to_ifs_filter(smb_filter);
580
581 if (smb_filter & ONEFS_NOTIFY_UNSUPPORTED) {
582 /* One or more of the filter bits could not be fully handled by
583 * the ifs_event system. To be correct, if we cannot service a
584 * bit in the completion filter we should return
585 * NT_STATUS_NOT_IMPLEMENTED to let the client know that they
586 * won't be receiving all the notify events that they asked for.
587 * Unfortunately, WinXP clients cache this error message, stop
588 * trying to send any notify requests at all, and instead return
589 * NOT_IMPLEMENTED to all requesting apps without ever sending a
590 * message to us. Thus we lie, and say we can service all bits,
591 * but simply don't return actions for the filter bits we can't
592 * detect or fully implement. */
593 DEBUG(3,("One or more of the Windows completion filter bits "
594 "for \"%s\" could not be fully handled by the "
595 "ifs_event system. The failed bits are "
596 "smb_filter=%#x\n",
597 e->path, smb_filter & ONEFS_NOTIFY_UNSUPPORTED));
598 }
599
600 if (ifs_filter == 0) {
601 /* None of the filter bits given are supported by the ifs_event
602 * system. Don't create a kernel notify channel, but mock
603 * up a fake handle for the caller. */
604 DEBUG(3,("No bits in the Windows completion filter could be "
605 "translated to ifs_event mask for \"%s\", "
606 "smb_filter=%#x\n", e->path, smb_filter));
607 (*handle) = NULL;
608 return NT_STATUS_OK;
609 }
610
611 /* Register an ifs event channel for this watch request */
612 ifs_event_fd = ifs_create_listener(watch_tree ?
613 EVENT_RECURSIVE :
614 EVENT_CHILDREN,
615 ifs_filter,
616 e->dir_fd);
617 if (ifs_event_fd < 0) {
618 DEBUG(0,("Failed to create listener for %s with \"%s\". "
619 "smb_filter=0x%x, ifs_filter=0x%x, watch_tree=%u\n",
620 strerror(errno), e->path, smb_filter, ifs_filter,
621 watch_tree));
622 return map_nt_error_from_unix(errno);
623 }
624
625 /* Create a watch context to track this change notify request */
626 wc = talloc(ctx, struct onefs_notify_watch_context);
627 if (wc == NULL) {
628 status = NT_STATUS_NO_MEMORY;
629 goto err;
630 }
631
632 /* Get LIN for directory */
633 if (onefs_sys_fstat(e->dir_fd, &sbuf)) {
634 DEBUG(0, ("stat on directory fd failed: %s\n",
635 strerror(errno)));
636 status = map_nt_error_from_unix(errno);
637 goto err;
638 }
639
640 if (sbuf.st_ex_ino == 0) {
641 DEBUG(0, ("0 LIN found!\n"));
642 goto err;
643 }
644
645 wc->ctx = ctx;
646 wc->watch_fd = e->dir_fd;
647 wc->watch_lin = sbuf.st_ex_ino;
648 wc->ifs_event_fd = ifs_event_fd;
649 wc->ifs_filter = ifs_filter;
650 wc->smb_filter = smb_filter;
651 wc->callback = callback;
652 wc->private_data = private_data;
653 wc->path = talloc_strdup(wc, e->path);
654 if (wc->path == NULL) {
655 status = NT_STATUS_NO_MEMORY;
656 goto err;
657 }
658
659 (*handle) = wc;
660
661 /* The caller frees the handle to stop watching */
662 talloc_set_destructor(wc, onefs_watch_destructor);
663
664 /* Add a tevent waiting for the ifs event fd to be readable */
665 event_add_fd(ctx->ev, wc, wc->ifs_event_fd, EVENT_FD_READ,
666 onefs_notify_handler, wc);
667
668 DEBUG(10, ("Watching for changes on \"%s\" smb_filter=0x%x, "
669 "ifs_filter=0x%x, watch_tree=%d, ifs_event_fd=%d, "
670 "dir_fd=%d, dir_lin=0x%llx\n",
671 e->path, smb_filter, ifs_filter, watch_tree,
672 ifs_event_fd, e->dir_fd, sbuf.st_ex_ino));
673
674 return NT_STATUS_OK;
675
676err:
677 talloc_free(wc);
678 SMB_ASSERT(ifs_event_fd >= 0);
679 close(ifs_event_fd);
680 return status;
681}
Note: See TracBrowser for help on using the repository browser.