source: branches/samba-3.2.x/source/modules/vfs_notify_fam.c

Last change on this file was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 7.5 KB
Line 
1/*
2 * FAM file notification support.
3 *
4 * Copyright (c) James Peach 2005
5 * Copyright (c) Volker Lendecke 2007
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include "includes.h"
22
23#include <fam.h>
24
25#if !defined(HAVE_FAM_H_FAMCODES_TYPEDEF)
26/* Gamin provides this typedef which means we can't use 'enum FAMCodes' as per
27 * every other FAM implementation. Phooey.
28 */
29typedef enum FAMCodes FAMCodes;
30#endif
31
32/* NOTE: There are multiple versions of FAM floating around the net, each with
33 * slight differences from the original SGI FAM implementation. In this file,
34 * we rely only on the SGI features and do not assume any extensions. For
35 * example, we do not look at FAMErrno, because it is not set by the original
36 * implementation.
37 *
38 * Random FAM links:
39 * http://oss.sgi.com/projects/fam/
40 * http://savannah.nongnu.org/projects/fam/
41 * http://sourceforge.net/projects/bsdfam/
42 */
43
44/* ------------------------------------------------------------------------- */
45
46struct fam_watch_context {
47 struct fam_watch_context *prev, *next;
48 FAMConnection *fam_connection;
49 struct FAMRequest fr;
50 struct sys_notify_context *sys_ctx;
51 void (*callback)(struct sys_notify_context *ctx,
52 void *private_data,
53 struct notify_event *ev);
54 void *private_data;
55 uint32_t mask; /* the inotify mask */
56 uint32_t filter; /* the windows completion filter */
57 const char *path;
58};
59
60
61/*
62 * We want one FAM connection per smbd, not one per tcon.
63 */
64static FAMConnection fam_connection;
65static bool fam_connection_initialized = False;
66
67static struct fam_watch_context *fam_notify_list;
68static void fam_handler(struct event_context *event_ctx,
69 struct fd_event *fd_event,
70 uint16 flags,
71 void *private_data);
72
73static NTSTATUS fam_open_connection(FAMConnection *fam_conn,
74 struct event_context *event_ctx)
75{
76 int res;
77 char *name;
78
79 ZERO_STRUCTP(fam_conn);
80 FAMCONNECTION_GETFD(fam_conn) = -1;
81
82 if (asprintf(&name, "smbd (%lu)", (unsigned long)sys_getpid()) == -1) {
83 DEBUG(0, ("No memory\n"));
84 return NT_STATUS_NO_MEMORY;
85 }
86
87 res = FAMOpen2(fam_conn, name);
88 SAFE_FREE(name);
89
90 if (res < 0) {
91 DEBUG(10, ("FAM file change notifications not available\n"));
92 /*
93 * No idea how to get NT_STATUS from a FAM result
94 */
95 FAMCONNECTION_GETFD(fam_conn) = -1;
96 return NT_STATUS_UNEXPECTED_IO_ERROR;
97 }
98
99 if (event_add_fd(event_ctx, event_ctx,
100 FAMCONNECTION_GETFD(fam_conn),
101 EVENT_FD_READ, fam_handler,
102 (void *)fam_conn) == NULL) {
103 DEBUG(0, ("event_add_fd failed\n"));
104 FAMClose(fam_conn);
105 FAMCONNECTION_GETFD(fam_conn) = -1;
106 return NT_STATUS_NO_MEMORY;
107 }
108
109 return NT_STATUS_OK;
110}
111
112static void fam_reopen(FAMConnection *fam_conn,
113 struct event_context *event_ctx,
114 struct fam_watch_context *notify_list)
115{
116 struct fam_watch_context *ctx;
117
118 DEBUG(5, ("Re-opening FAM connection\n"));
119
120 FAMClose(fam_conn);
121
122 if (!NT_STATUS_IS_OK(fam_open_connection(fam_conn, event_ctx))) {
123 DEBUG(5, ("Re-opening fam connection failed\n"));
124 return;
125 }
126
127 for (ctx = notify_list; ctx; ctx = ctx->next) {
128 FAMMonitorDirectory(fam_conn, ctx->path, &ctx->fr, NULL);
129 }
130}
131
132static void fam_handler(struct event_context *event_ctx,
133 struct fd_event *fd_event,
134 uint16 flags,
135 void *private_data)
136{
137 FAMConnection *fam_conn = (FAMConnection *)private_data;
138 FAMEvent fam_event;
139 struct fam_watch_context *ctx;
140 struct notify_event ne;
141
142 if (FAMPending(fam_conn) == 0) {
143 DEBUG(10, ("fam_handler called but nothing pending\n"));
144 return;
145 }
146
147 if (FAMNextEvent(fam_conn, &fam_event) != 1) {
148 DEBUG(5, ("FAMNextEvent returned an error\n"));
149 TALLOC_FREE(fd_event);
150 fam_reopen(fam_conn, event_ctx, fam_notify_list);
151 return;
152 }
153
154 DEBUG(10, ("Got FAMCode %d for %s\n", fam_event.code,
155 fam_event.filename));
156
157 switch (fam_event.code) {
158 case FAMChanged:
159 ne.action = NOTIFY_ACTION_MODIFIED;
160 break;
161 case FAMCreated:
162 ne.action = NOTIFY_ACTION_ADDED;
163 break;
164 case FAMDeleted:
165 ne.action = NOTIFY_ACTION_REMOVED;
166 break;
167 default:
168 DEBUG(10, ("Ignoring code FAMCode %d for file %s\n",
169 (int)fam_event.code, fam_event.filename));
170 return;
171 }
172
173 for (ctx = fam_notify_list; ctx; ctx = ctx->next) {
174 if (memcmp(&fam_event.fr, &ctx->fr, sizeof(FAMRequest)) == 0) {
175 break;
176 }
177 }
178
179 if (ctx == NULL) {
180 DEBUG(5, ("Discarding event for file %s\n",
181 fam_event.filename));
182 return;
183 }
184
185 if ((ne.path = strrchr_m(fam_event.filename, '\\')) == NULL) {
186 ne.path = fam_event.filename;
187 }
188
189 ctx->callback(ctx->sys_ctx, ctx->private_data, &ne);
190}
191
192static int fam_watch_context_destructor(struct fam_watch_context *ctx)
193{
194 if (FAMCONNECTION_GETFD(ctx->fam_connection) != -1) {
195 FAMCancelMonitor(&fam_connection, &ctx->fr);
196 }
197 DLIST_REMOVE(fam_notify_list, ctx);
198 return 0;
199}
200
201/*
202 add a watch. The watch is removed when the caller calls
203 talloc_free() on *handle
204*/
205static NTSTATUS fam_watch(vfs_handle_struct *vfs_handle,
206 struct sys_notify_context *ctx,
207 struct notify_entry *e,
208 void (*callback)(struct sys_notify_context *ctx,
209 void *private_data,
210 struct notify_event *ev),
211 void *private_data,
212 void *handle_p)
213{
214 const uint32 fam_mask = (FILE_NOTIFY_CHANGE_FILE_NAME|
215 FILE_NOTIFY_CHANGE_DIR_NAME);
216 struct fam_watch_context *watch;
217 void **handle = (void **)handle_p;
218
219 if ((e->filter & fam_mask) == 0) {
220 DEBUG(10, ("filter = %u, ignoring in FAM\n", e->filter));
221 return NT_STATUS_OK;
222 }
223
224 if (!fam_connection_initialized) {
225 if (!NT_STATUS_IS_OK(fam_open_connection(&fam_connection,
226 ctx->ev))) {
227 /*
228 * Just let smbd do all the work itself
229 */
230 return NT_STATUS_OK;
231 }
232 fam_connection_initialized = True;
233 }
234
235 if (!(watch = TALLOC_P(ctx, struct fam_watch_context))) {
236 return NT_STATUS_NO_MEMORY;
237 }
238
239 watch->fam_connection = &fam_connection;
240
241 watch->callback = callback;
242 watch->private_data = private_data;
243 watch->sys_ctx = ctx;
244
245 if (!(watch->path = talloc_strdup(watch, e->path))) {
246 DEBUG(0, ("talloc_asprintf failed\n"));
247 TALLOC_FREE(watch);
248 return NT_STATUS_NO_MEMORY;
249 }
250
251 /*
252 * The FAM module in this early state will only take care of
253 * FAMCreated and FAMDeleted events, Leave the rest to
254 * notify_internal.c
255 */
256
257 watch->filter = fam_mask;
258 e->filter &= ~fam_mask;
259
260 DLIST_ADD(fam_notify_list, watch);
261 talloc_set_destructor(watch, fam_watch_context_destructor);
262
263 /*
264 * Only directories monitored so far
265 */
266
267 if (FAMCONNECTION_GETFD(watch->fam_connection) != -1) {
268 FAMMonitorDirectory(watch->fam_connection, watch->path,
269 &watch->fr, NULL);
270 }
271 else {
272 /*
273 * If the re-open is successful, this will establish the
274 * FAMMonitor from the list
275 */
276 fam_reopen(watch->fam_connection, ctx->ev, fam_notify_list);
277 }
278
279 *handle = (void *)watch;
280
281 return NT_STATUS_OK;
282}
283
284/* VFS operations structure */
285
286static vfs_op_tuple notify_fam_op_tuples[] = {
287
288 {SMB_VFS_OP(fam_watch),
289 SMB_VFS_OP_NOTIFY_WATCH,
290 SMB_VFS_LAYER_OPAQUE},
291
292 {SMB_VFS_OP(NULL),
293 SMB_VFS_OP_NOOP,
294 SMB_VFS_LAYER_NOOP}
295
296};
297
298
299NTSTATUS vfs_notify_fam_init(void);
300NTSTATUS vfs_notify_fam_init(void)
301{
302 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "notify_fam",
303 notify_fam_op_tuples);
304}
Note: See TracBrowser for help on using the repository browser.