source: trunk/server/source3/smbd/dmapi.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 9.4 KB
RevLine 
[745]1/*
2 Unix SMB/CIFS implementation.
3 DMAPI Support routines
4
5 Copyright (C) James Peach 2006
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#include "smbd/smbd.h"
23#include "smbd/globals.h"
24
25#undef DBGC_CLASS
26#define DBGC_CLASS DBGC_DMAPI
27
28#ifndef USE_DMAPI
29
30uint32 dmapi_file_flags(const char * const path) { return 0; }
31bool dmapi_have_session(void) { return False; }
32const void * dmapi_get_current_session(void) { return NULL; }
33
34#else /* USE_DMAPI */
35
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
47
48#define DMAPI_SESSION_NAME "samba"
49#define DMAPI_TRACE 10
50
51struct smbd_dmapi_context {
52 dm_sessid_t session;
53 unsigned session_num;
54};
55
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.
60*/
61static int dmapi_init_session(struct smbd_dmapi_context *ctx)
62{
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);
70
71 int i, err;
72
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);
78 }
79
80 if (session_name == NULL) {
81 DEBUG(0,("Out of memory in dmapi_init_session\n"));
82 talloc_free(tmp_ctx);
83 return -1;
84 }
85
86
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;
91 }
92
93 ZERO_STRUCT(buf);
94
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_ARRAY(tmp_ctx, sessions,
100 dm_sessid_t, nsessions);
101 if (new_sessions == NULL) {
102 talloc_free(tmp_ctx);
103 return -1;
104 }
105
106 sessions = new_sessions;
107 err = dm_getall_sessions(nsessions, sessions, &nsessions);
108 } while (err == -1 && errno == E2BIG);
109
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;
116 }
117
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;
128 }
129 }
130
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;
143 }
144
145 DEBUG(0, ("created new DMAPI session named '%s' for %s\n",
146 session_name, version));
147 }
148
149 if (ctx->session != DM_NO_SESSION) {
150 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
151 }
152
153 /*
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.
157
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.
160 */
161
162 talloc_free(tmp_ctx);
163 return 0;
164}
165
166/*
167 Return a pointer to our DMAPI session, if available.
168 This assumes that you have called dmapi_have_session() first.
169*/
170const void *dmapi_get_current_session(void)
171{
172 if (!dmapi_ctx) {
173 return NULL;
174 }
175
176 if (dmapi_ctx->session == DM_NO_SESSION) {
177 return NULL;
178 }
179
180 return (void *)&dmapi_ctx->session;
181}
182
183/*
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.
187*/
188
189bool dmapi_have_session(void)
190{
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");
195 }
196 dmapi_ctx->session = DM_NO_SESSION;
197 dmapi_ctx->session_num = 0;
198
199 become_root();
200 dmapi_init_session(dmapi_ctx);
201 unbecome_root();
202
203 }
204
205 return dmapi_ctx->session != DM_NO_SESSION;
206}
207
208/*
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.
212 */
213bool dmapi_new_session(void)
214{
215 if (dmapi_have_session()) {
216 /* try to destroy the old one - this may not succeed */
217 dm_destroy_session(dmapi_ctx->session);
218 }
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;
225}
226
227/*
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.
233*/
234bool dmapi_destroy_session(void)
235{
236 if (!dmapi_ctx) {
237 return true;
238 }
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)));
247 }
248 unbecome_root();
249 }
250 return dmapi_ctx->session == DM_NO_SESSION;
251}
252
253
254/*
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.
261*/
262uint32 dmapi_file_flags(const char * const path)
263{
264 int err;
265 dm_eventset_t events = {0};
266 uint nevents;
267
268 dm_sessid_t dmapi_session;
269 const void *dmapi_session_ptr;
270 void *dm_handle = NULL;
271 size_t dm_handle_len = 0;
272
273 uint32 flags = 0;
274
275 dmapi_session_ptr = dmapi_get_current_session();
276 if (dmapi_session_ptr == NULL) {
277 return 0;
278 }
279
280 dmapi_session = *(dm_sessid_t *)dmapi_session_ptr;
281 if (dmapi_session == DM_NO_SESSION) {
282 return 0;
283 }
284
285 /* AIX has DMAPI but no POSIX capablities support. In this case,
286 * we need to be root to do DMAPI manipulations.
287 */
288#ifndef HAVE_POSIX_CAPABILITIES
289 become_root();
290#endif
291
292 err = dm_path_to_handle(CONST_DISCARD(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)));
297
298 if (errno != EPERM) {
299 goto done;
300 }
301
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.
307 */
308
309 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
310
311 err = dm_path_to_handle(CONST_DISCARD(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;
318 }
319 }
320
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;
328 }
329
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.
333 */
334 DEBUG(DMAPI_TRACE, ("DMAPI event list for %s\n", path));
335 if (DMEV_ISSET(DM_EVENT_READ, events)) {
336 flags = FILE_ATTRIBUTE_OFFLINE;
337 }
338
339 dm_handle_free(dm_handle, dm_handle_len);
340
341 if (flags & FILE_ATTRIBUTE_OFFLINE) {
342 DEBUG(DMAPI_TRACE, ("%s is OFFLINE\n", path));
343 }
344
345done:
346
347#ifndef HAVE_POSIX_CAPABILITIES
348 unbecome_root();
349#endif
350
351 return flags;
352}
353
354
355#endif /* USE_DMAPI */
Note: See TracBrowser for help on using the repository browser.