Context Navigation

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

Visit:

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: