s3:smbd: s/struct timed_event/struct tevent_timer
[Samba/gebeck_regimport.git] / source3 / smbd / dmapi.c
blob8e80a588c5f619e9f6fe112ca783137b387875d2
1 /*
2 Unix SMB/CIFS implementation.
3 DMAPI Support routines
5 Copyright (C) James Peach 2006
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.
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.
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/>.
21 #include "includes.h"
22 #include "smbd/smbd.h"
23 #include "smbd/globals.h"
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_DMAPI
28 #ifndef USE_DMAPI
30 uint32 dmapi_file_flags(const char * const path) { return 0; }
31 bool dmapi_have_session(void) { return False; }
32 const void * dmapi_get_current_session(void) { return NULL; }
34 #else /* USE_DMAPI */
36 #ifdef HAVE_XFS_DMAPI_H
37 #include <xfs/dmapi.h>
38 #elif defined(HAVE_SYS_DMI_H)
39 #include <sys/dmi.h>
40 #elif defined(HAVE_SYS_JFSDMAPI_H)
41 #include <sys/jfsdmapi.h>
42 #elif defined(HAVE_SYS_DMAPI_H)
43 #include <sys/dmapi.h>
44 #elif defined(HAVE_DMAPI_H)
45 #include <dmapi.h>
46 #endif
48 #define DMAPI_SESSION_NAME "samba"
49 #define DMAPI_TRACE 10
51 struct smbd_dmapi_context {
52 dm_sessid_t session;
53 unsigned session_num;
56 /*
57 Initialise DMAPI session. The session is persistant kernel state,
58 so it might already exist, in which case we merely want to
59 reconnect to it. This function should be called as root.
61 static int dmapi_init_session(struct smbd_dmapi_context *ctx)
63 char buf[DM_SESSION_INFO_LEN];
64 size_t buflen;
65 uint nsessions = 5;
66 dm_sessid_t *sessions = NULL;
67 char *version;
68 char *session_name;
69 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
71 int i, err;
73 if (ctx->session_num == 0) {
74 session_name = talloc_strdup(tmp_ctx, DMAPI_SESSION_NAME);
75 } else {
76 session_name = talloc_asprintf(tmp_ctx, "%s%u", DMAPI_SESSION_NAME,
77 ctx->session_num);
80 if (session_name == NULL) {
81 DEBUG(0,("Out of memory in dmapi_init_session\n"));
82 talloc_free(tmp_ctx);
83 return -1;
87 if (dm_init_service(&version) < 0) {
88 DEBUG(0, ("dm_init_service failed - disabling DMAPI\n"));
89 talloc_free(tmp_ctx);
90 return -1;
93 ZERO_STRUCT(buf);
95 /* Fetch kernel DMAPI sessions until we get any of them */
96 do {
97 dm_sessid_t *new_sessions;
98 nsessions *= 2;
99 new_sessions = talloc_realloc(tmp_ctx, sessions,
100 dm_sessid_t, nsessions);
101 if (new_sessions == NULL) {
102 talloc_free(tmp_ctx);
103 return -1;
106 sessions = new_sessions;
107 err = dm_getall_sessions(nsessions, sessions, &nsessions);
108 } while (err == -1 && errno == E2BIG);
110 if (err == -1) {
111 DEBUGADD(DMAPI_TRACE,
112 ("failed to retrieve DMAPI sessions: %s\n",
113 strerror(errno)));
114 talloc_free(tmp_ctx);
115 return -1;
118 /* Look through existing kernel DMAPI sessions to find out ours */
119 for (i = 0; i < nsessions; ++i) {
120 err = dm_query_session(sessions[i], sizeof(buf), buf, &buflen);
121 buf[sizeof(buf) - 1] = '\0';
122 if (err == 0 && strcmp(session_name, buf) == 0) {
123 ctx->session = sessions[i];
124 DEBUGADD(DMAPI_TRACE,
125 ("attached to existing DMAPI session "
126 "named '%s'\n", buf));
127 break;
131 /* No session already defined. */
132 if (ctx->session == DM_NO_SESSION) {
133 err = dm_create_session(DM_NO_SESSION,
134 session_name,
135 &ctx->session);
136 if (err < 0) {
137 DEBUGADD(DMAPI_TRACE,
138 ("failed to create new DMAPI session: %s\n",
139 strerror(errno)));
140 ctx->session = DM_NO_SESSION;
141 talloc_free(tmp_ctx);
142 return -1;
145 DEBUG(0, ("created new DMAPI session named '%s' for %s\n",
146 session_name, version));
149 if (ctx->session != DM_NO_SESSION) {
150 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
154 Note that we never end the DMAPI session. It gets re-used if possiblie.
155 DMAPI session is a kernel resource that is usually lives until server reboot
156 and doesn't get destroed when an application finishes.
158 However, we free list of references to DMAPI sessions we've got from the kernel
159 as it is not needed anymore once we have found (or created) our session.
162 talloc_free(tmp_ctx);
163 return 0;
167 Return a pointer to our DMAPI session, if available.
168 This assumes that you have called dmapi_have_session() first.
170 const void *dmapi_get_current_session(void)
172 if (!dmapi_ctx) {
173 return NULL;
176 if (dmapi_ctx->session == DM_NO_SESSION) {
177 return NULL;
180 return (void *)&dmapi_ctx->session;
184 dmapi_have_session() must be the first DMAPI call you make in Samba. It will
185 initialize DMAPI, if available, and tell you if you can get a DMAPI session.
186 This should be called in the client-specific child process.
189 bool dmapi_have_session(void)
191 if (!dmapi_ctx) {
192 dmapi_ctx = talloc(NULL, struct smbd_dmapi_context);
193 if (!dmapi_ctx) {
194 exit_server("unable to allocate smbd_dmapi_context");
196 dmapi_ctx->session = DM_NO_SESSION;
197 dmapi_ctx->session_num = 0;
199 become_root();
200 dmapi_init_session(dmapi_ctx);
201 unbecome_root();
205 return dmapi_ctx->session != DM_NO_SESSION;
209 only call this when you get back an EINVAL error indicating that the
210 session you are using is invalid. This destroys the existing session
211 and creates a new one.
213 bool dmapi_new_session(void)
215 if (dmapi_have_session()) {
216 /* try to destroy the old one - this may not succeed */
217 dm_destroy_session(dmapi_ctx->session);
219 dmapi_ctx->session = DM_NO_SESSION;
220 become_root();
221 dmapi_ctx->session_num++;
222 dmapi_init_session(dmapi_ctx);
223 unbecome_root();
224 return dmapi_ctx->session != DM_NO_SESSION;
228 only call this when exiting from master smbd process. DMAPI sessions
229 are long-lived kernel resources we ought to share across smbd processes.
230 However, we must free them when all smbd processes are finished to
231 allow other subsystems clean up properly. Not freeing DMAPI session
232 blocks certain HSM implementations from proper shutdown.
234 bool dmapi_destroy_session(void)
236 if (!dmapi_ctx) {
237 return true;
239 if (dmapi_ctx->session != DM_NO_SESSION) {
240 become_root();
241 if (0 == dm_destroy_session(dmapi_ctx->session)) {
242 dmapi_ctx->session_num--;
243 dmapi_ctx->session = DM_NO_SESSION;
244 } else {
245 DEBUG(0,("Couldn't destroy DMAPI session: %s\n",
246 strerror(errno)));
248 unbecome_root();
250 return dmapi_ctx->session == DM_NO_SESSION;
255 This is default implementation of dmapi_file_flags() that is
256 called from VFS is_offline() call to know whether file is offline.
257 For GPFS-specific version see modules/vfs_tsmsm.c. It might be
258 that approach on quering existence of a specific attribute that
259 is used in vfs_tsmsm.c will work with other DMAPI-based HSM
260 implementations as well.
262 uint32 dmapi_file_flags(const char * const path)
264 int err;
265 dm_eventset_t events = {0};
266 uint nevents;
268 dm_sessid_t dmapi_session;
269 const void *dmapi_session_ptr;
270 void *dm_handle = NULL;
271 size_t dm_handle_len = 0;
273 uint32 flags = 0;
275 dmapi_session_ptr = dmapi_get_current_session();
276 if (dmapi_session_ptr == NULL) {
277 return 0;
280 dmapi_session = *(dm_sessid_t *)dmapi_session_ptr;
281 if (dmapi_session == DM_NO_SESSION) {
282 return 0;
285 /* AIX has DMAPI but no POSIX capablities support. In this case,
286 * we need to be root to do DMAPI manipulations.
288 #ifndef HAVE_POSIX_CAPABILITIES
289 become_root();
290 #endif
292 err = dm_path_to_handle(discard_const_p(char, path),
293 &dm_handle, &dm_handle_len);
294 if (err < 0) {
295 DEBUG(DMAPI_TRACE, ("dm_path_to_handle(%s): %s\n",
296 path, strerror(errno)));
298 if (errno != EPERM) {
299 goto done;
302 /* Linux capabilities are broken in that changing our
303 * user ID will clobber out effective capabilities irrespective
304 * of whether we have set PR_SET_KEEPCAPS. Fortunately, the
305 * capabilities are not removed from our permitted set, so we
306 * can re-acquire them if necessary.
309 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
311 err = dm_path_to_handle(discard_const_p(char, path),
312 &dm_handle, &dm_handle_len);
313 if (err < 0) {
314 DEBUG(DMAPI_TRACE,
315 ("retrying dm_path_to_handle(%s): %s\n",
316 path, strerror(errno)));
317 goto done;
321 err = dm_get_eventlist(dmapi_session, dm_handle, dm_handle_len,
322 DM_NO_TOKEN, DM_EVENT_MAX, &events, &nevents);
323 if (err < 0) {
324 DEBUG(DMAPI_TRACE, ("dm_get_eventlist(%s): %s\n",
325 path, strerror(errno)));
326 dm_handle_free(dm_handle, dm_handle_len);
327 goto done;
330 /* We figure that the only reason a DMAPI application would be
331 * interested in trapping read events is that part of the file is
332 * offline.
334 DEBUG(DMAPI_TRACE, ("DMAPI event list for %s\n", path));
335 if (DMEV_ISSET(DM_EVENT_READ, events)) {
336 flags = FILE_ATTRIBUTE_OFFLINE;
339 dm_handle_free(dm_handle, dm_handle_len);
341 if (flags & FILE_ATTRIBUTE_OFFLINE) {
342 DEBUG(DMAPI_TRACE, ("%s is OFFLINE\n", path));
345 done:
347 #ifndef HAVE_POSIX_CAPABILITIES
348 unbecome_root();
349 #endif
351 return flags;
355 #endif /* USE_DMAPI */