source: vendor/current/source3/smbd/dmapi.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 9.1 KB
Line 
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_t 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(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_t 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 dm_sessid_t *dmapi_session_ptr;
270 const void *_dmapi_session_ptr;
271 void *dm_handle = NULL;
272 size_t dm_handle_len = 0;
273
274 uint32_t flags = 0;
275
276 _dmapi_session_ptr = dmapi_get_current_session();
277 if (_dmapi_session_ptr == NULL) {
278 return 0;
279 }
280
281 dmapi_session_ptr = discard_const_p(dm_sessid_t, _dmapi_session_ptr);
282 dmapi_session = *dmapi_session_ptr;
283 if (dmapi_session == DM_NO_SESSION) {
284 return 0;
285 }
286
287 /* AIX has DMAPI but no POSIX capablities support. In this case,
288 * we need to be root to do DMAPI manipulations.
289 */
290#ifndef HAVE_POSIX_CAPABILITIES
291 become_root();
292#endif
293
294 err = dm_path_to_handle(discard_const_p(char, path),
295 &dm_handle, &dm_handle_len);
296 if (err < 0) {
297 DEBUG(DMAPI_TRACE, ("dm_path_to_handle(%s): %s\n",
298 path, strerror(errno)));
299
300 if (errno != EPERM) {
301 goto done;
302 }
303
304 /* Linux capabilities are broken in that changing our
305 * user ID will clobber out effective capabilities irrespective
306 * of whether we have set PR_SET_KEEPCAPS. Fortunately, the
307 * capabilities are not removed from our permitted set, so we
308 * can re-acquire them if necessary.
309 */
310
311 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
312
313 err = dm_path_to_handle(discard_const_p(char, path),
314 &dm_handle, &dm_handle_len);
315 if (err < 0) {
316 DEBUG(DMAPI_TRACE,
317 ("retrying dm_path_to_handle(%s): %s\n",
318 path, strerror(errno)));
319 goto done;
320 }
321 }
322
323 err = dm_get_eventlist(dmapi_session, dm_handle, dm_handle_len,
324 DM_NO_TOKEN, DM_EVENT_MAX, &events, &nevents);
325 if (err < 0) {
326 DEBUG(DMAPI_TRACE, ("dm_get_eventlist(%s): %s\n",
327 path, strerror(errno)));
328 dm_handle_free(dm_handle, dm_handle_len);
329 goto done;
330 }
331
332 /* We figure that the only reason a DMAPI application would be
333 * interested in trapping read events is that part of the file is
334 * offline.
335 */
336 DEBUG(DMAPI_TRACE, ("DMAPI event list for %s\n", path));
337 if (DMEV_ISSET(DM_EVENT_READ, events)) {
338 flags = FILE_ATTRIBUTE_OFFLINE;
339 }
340
341 dm_handle_free(dm_handle, dm_handle_len);
342
343 if (flags & FILE_ATTRIBUTE_OFFLINE) {
344 DEBUG(DMAPI_TRACE, ("%s is OFFLINE\n", path));
345 }
346
347done:
348
349#ifndef HAVE_POSIX_CAPABILITIES
350 unbecome_root();
351#endif
352
353 return flags;
354}
355
356
357#endif /* USE_DMAPI */
Note: See TracBrowser for help on using the repository browser.