source: branches/samba-3.3.x/source/modules/vfs_tsmsm.c

Last change on this file was 206, checked in by Herwig Bauernfeind, 16 years ago

Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 12.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba VFS module for handling offline files
4 with Tivoli Storage Manager Space Management
5
6 (c) Alexander Bokovoy, 2007, 2008
7 (c) Andrew Tridgell, 2007, 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 This VFS module accepts following options:
24 tsmsm: hsm script = <path to hsm script> (default does nothing)
25 hsm script should point to a shell script which accepts two arguments:
26 <operation> <filepath>
27 where <operation> is currently 'offline' to set offline status of the <filepath>
28
29 tsmsm: online ratio = ratio to check reported size against actual file size (0.5 by default)
30 tsmsm: attribute name = name of DMAPI attribute that is present when a file is offline.
31 Default is "IBMobj" (which is what GPFS uses)
32
33 The TSMSM VFS module tries to avoid calling expensive DMAPI calls with some heuristics
34 based on the fact that number of blocks reported of a file multiplied by 512 will be
35 bigger than 'online ratio' of actual size for online (non-migrated) files.
36
37 If checks fail, we call DMAPI and ask for specific attribute which present for
38 offline (migrated) files. If this attribute presents, we consider file offline.
39 */
40
41#include "includes.h"
42
43#ifndef USE_DMAPI
44#error "This module requires DMAPI support!"
45#endif
46
47#ifdef HAVE_XFS_DMAPI_H
48#include <xfs/dmapi.h>
49#elif defined(HAVE_SYS_DMI_H)
50#include <sys/dmi.h>
51#elif defined(HAVE_SYS_JFSDMAPI_H)
52#include <sys/jfsdmapi.h>
53#elif defined(HAVE_SYS_DMAPI_H)
54#include <sys/dmapi.h>
55#elif defined(HAVE_DMAPI_H)
56#include <dmapi.h>
57#endif
58
59#ifndef _ISOC99_SOURCE
60#define _ISOC99_SOURCE
61#endif
62
63#include <math.h>
64
65/* optimisation tunables - used to avoid the DMAPI slow path */
66#define FILE_IS_ONLINE_RATIO 0.5
67
68/* default attribute name to look for */
69#define DM_ATTRIB_OBJECT "IBMObj"
70
71struct tsmsm_struct {
72 float online_ratio;
73 char *hsmscript;
74 const char *attrib_name;
75 const char *attrib_value;
76};
77
78static void tsmsm_free_data(void **pptr) {
79 struct tsmsm_struct **tsmd = (struct tsmsm_struct **)pptr;
80 if(!tsmd) return;
81 TALLOC_FREE(*tsmd);
82}
83
84/*
85 called when a client connects to a share
86*/
87static int tsmsm_connect(struct vfs_handle_struct *handle,
88 const char *service,
89 const char *user) {
90 struct tsmsm_struct *tsmd = TALLOC_ZERO_P(handle, struct tsmsm_struct);
91 const char *fres;
92 const char *tsmname;
93
94 if (!tsmd) {
95 DEBUG(0,("tsmsm_connect: out of memory!\n"));
96 return -1;
97 }
98
99 if (!dmapi_have_session()) {
100 DEBUG(0,("tsmsm_connect: no DMAPI session for Samba is available!\n"));
101 TALLOC_FREE(tsmd);
102 return -1;
103 }
104
105 tsmname = (handle->param ? handle->param : "tsmsm");
106
107 /* Get 'hsm script' and 'dmapi attribute' parameters to tsmd context */
108 tsmd->hsmscript = lp_parm_talloc_string(SNUM(handle->conn), tsmname,
109 "hsm script", NULL);
110 talloc_steal(tsmd, tsmd->hsmscript);
111
112 tsmd->attrib_name = lp_parm_talloc_string(SNUM(handle->conn), tsmname,
113 "dmapi attribute", DM_ATTRIB_OBJECT);
114 talloc_steal(tsmd, tsmd->attrib_name);
115
116 tsmd->attrib_value = lp_parm_talloc_string(SNUM(handle->conn), "tsmsm",
117 "dmapi value", NULL);
118 talloc_steal(tsmd, tsmd->attrib_value);
119
120 /* retrieve 'online ratio'. In case of error default to FILE_IS_ONLINE_RATIO */
121 fres = lp_parm_const_string(SNUM(handle->conn), tsmname,
122 "online ratio", NULL);
123 if (fres == NULL) {
124 tsmd->online_ratio = FILE_IS_ONLINE_RATIO;
125 } else {
126 tsmd->online_ratio = strtof(fres, NULL);
127 if (tsmd->online_ratio > 1.0 ||
128 tsmd->online_ratio <= 0.0) {
129 DEBUG(1, ("tsmsm_connect: invalid online ration %f - using %f.\n",
130 tsmd->online_ratio, (float)FILE_IS_ONLINE_RATIO));
131 }
132 }
133
134 /* Store the private data. */
135 SMB_VFS_HANDLE_SET_DATA(handle, tsmd, tsmsm_free_data,
136 struct tsmsm_struct, return -1);
137 return SMB_VFS_NEXT_CONNECT(handle, service, user);
138}
139
140static bool tsmsm_is_offline(struct vfs_handle_struct *handle,
141 const char *path,
142 SMB_STRUCT_STAT *stbuf) {
143 struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
144 const dm_sessid_t *dmsession_id;
145 void *dmhandle = NULL;
146 size_t dmhandle_len = 0;
147 size_t rlen;
148 dm_attrname_t dmname;
149 int ret, lerrno;
150 bool offline;
151 char *buf = NULL;
152 size_t buflen;
153
154 /* if the file has more than FILE_IS_ONLINE_RATIO of blocks available,
155 then assume it is not offline (it may not be 100%, as it could be sparse) */
156 if (512 * (off_t)stbuf->st_blocks >= stbuf->st_size * tsmd->online_ratio) {
157 DEBUG(10,("%s not offline: st_blocks=%ld st_size=%ld "
158 "online_ratio=%.2f\n", path, (long)stbuf->st_blocks,
159 (long)stbuf->st_size, tsmd->online_ratio));
160 return false;
161 }
162
163 dmsession_id = dmapi_get_current_session();
164 if (dmsession_id == NULL) {
165 DEBUG(2, ("tsmsm_is_offline: no DMAPI session available? "
166 "Assume file is online.\n"));
167 return false;
168 }
169
170 /* using POSIX capabilities does not work here. It's a slow path, so
171 * become_root() is just as good anyway (tridge)
172 */
173
174 /* Also, AIX has DMAPI but no POSIX capablities support. In this case,
175 * we need to be root to do DMAPI manipulations.
176 */
177 become_root();
178
179 /* go the slow DMAPI route */
180 if (dm_path_to_handle((char*)path, &dmhandle, &dmhandle_len) != 0) {
181 DEBUG(2,("dm_path_to_handle failed - assuming offline (%s) - %s\n",
182 path, strerror(errno)));
183 offline = true;
184 goto done;
185 }
186
187 memset(&dmname, 0, sizeof(dmname));
188 strlcpy((char *)&dmname.an_chars[0], tsmd->attrib_name, sizeof(dmname.an_chars));
189
190 if (tsmd->attrib_value != NULL) {
191 buflen = strlen(tsmd->attrib_value);
192 } else {
193 buflen = 1;
194 }
195 buf = talloc_zero_size(tsmd, buflen);
196 if (buf == NULL) {
197 DEBUG(0,("out of memory in tsmsm_is_offline -- assuming online (%s)\n", path));
198 errno = ENOMEM;
199 offline = false;
200 goto done;
201 }
202
203 do {
204 lerrno = 0;
205
206 ret = dm_get_dmattr(*dmsession_id, dmhandle, dmhandle_len,
207 DM_NO_TOKEN, &dmname, buflen, buf, &rlen);
208 if (ret == -1 && errno == EINVAL) {
209 DEBUG(0, ("Stale DMAPI session, re-creating it.\n"));
210 lerrno = EINVAL;
211 if (dmapi_new_session()) {
212 dmsession_id = dmapi_get_current_session();
213 } else {
214 DEBUG(0,
215 ("Unable to re-create DMAPI session, assuming offline (%s) - %s\n",
216 path, strerror(errno)));
217 offline = true;
218 dm_handle_free(dmhandle, dmhandle_len);
219 goto done;
220 }
221 }
222 } while (ret == -1 && lerrno == EINVAL);
223
224 /* check if we need a specific attribute value */
225 if (tsmd->attrib_value != NULL) {
226 offline = (ret == 0 && rlen == buflen &&
227 memcmp(buf, tsmd->attrib_value, buflen) == 0);
228 } else {
229 /* its offline if the specified DMAPI attribute exists */
230 offline = (ret == 0 || (ret == -1 && errno == E2BIG));
231 }
232
233 DEBUG(10,("dm_get_dmattr %s ret=%d (%s)\n", path, ret, strerror(errno)));
234
235 ret = 0;
236
237 dm_handle_free(dmhandle, dmhandle_len);
238
239done:
240 talloc_free(buf);
241 unbecome_root();
242 return offline;
243}
244
245
246static bool tsmsm_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
247{
248 SMB_STRUCT_STAT sbuf;
249 struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
250 /* see if the file might be offline. This is called before each IO
251 to ensure we use AIO if the file is offline. We don't do the full dmapi
252 call as that would be too slow, instead we err on the side of using AIO
253 if the file might be offline
254 */
255 if(SMB_VFS_FSTAT(fsp, &sbuf) == 0) {
256 DEBUG(10,("tsmsm_aio_force st_blocks=%ld st_size=%ld "
257 "online_ratio=%.2f\n", (long)sbuf.st_blocks,
258 (long)sbuf.st_size, tsmd->online_ratio));
259 return !(512 * (off_t)sbuf.st_blocks >= sbuf.st_size * tsmd->online_ratio);
260 }
261 return false;
262}
263
264static ssize_t tsmsm_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp,
265 SMB_STRUCT_AIOCB *aiocb)
266{
267 ssize_t result;
268
269 result = SMB_VFS_NEXT_AIO_RETURN(handle, fsp, aiocb);
270 if(result >= 0) {
271 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
272 FILE_NOTIFY_CHANGE_ATTRIBUTES,
273 fsp->fsp_name);
274 }
275
276 return result;
277}
278
279static ssize_t tsmsm_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, const DATA_BLOB *hdr,
280 SMB_OFF_T offset, size_t n)
281{
282 bool file_offline = tsmsm_aio_force(handle, fsp);
283
284 if (file_offline) {
285 DEBUG(10,("tsmsm_sendfile on offline file - rejecting\n"));
286 errno = ENOSYS;
287 return -1;
288 }
289
290 return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
291}
292
293/* We do overload pread to allow notification when file becomes online after offline status */
294/* We don't intercept SMB_VFS_READ here because all file I/O now goes through SMB_VFS_PREAD instead */
295static ssize_t tsmsm_pread(struct vfs_handle_struct *handle, struct files_struct *fsp,
296 void *data, size_t n, SMB_OFF_T offset) {
297 ssize_t result;
298 bool notify_online = tsmsm_aio_force(handle, fsp);
299
300 result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
301 if((result != -1) && notify_online) {
302 /* We can't actually force AIO at this point (came here not from reply_read_and_X)
303 what we can do is to send notification that file became online
304 */
305 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
306 FILE_NOTIFY_CHANGE_ATTRIBUTES,
307 fsp->fsp_name);
308 }
309
310 return result;
311}
312
313static ssize_t tsmsm_pwrite(struct vfs_handle_struct *handle, struct files_struct *fsp,
314 void *data, size_t n, SMB_OFF_T offset) {
315 ssize_t result;
316 bool notify_online = tsmsm_aio_force(handle, fsp);
317
318 result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
319 if((result != -1) && notify_online) {
320 /* We can't actually force AIO at this point (came here not from reply_read_and_X)
321 what we can do is to send notification that file became online
322 */
323 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
324 FILE_NOTIFY_CHANGE_ATTRIBUTES,
325 fsp->fsp_name);
326 }
327
328 return result;
329}
330
331static int tsmsm_set_offline(struct vfs_handle_struct *handle,
332 const char *path) {
333 struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
334 int result = 0;
335 char *command;
336
337 if (tsmd->hsmscript == NULL) {
338 /* no script enabled */
339 DEBUG(1, ("tsmsm_set_offline: No 'tsmsm:hsm script' configured\n"));
340 return 0;
341 }
342
343 /* Now, call the script */
344 command = talloc_asprintf(tsmd, "%s offline \"%s\"", tsmd->hsmscript, path);
345 if(!command) {
346 DEBUG(1, ("tsmsm_set_offline: can't allocate memory to run hsm script"));
347 return -1;
348 }
349 DEBUG(10, ("tsmsm_set_offline: Running [%s]\n", command));
350 if((result = smbrun(command, NULL)) != 0) {
351 DEBUG(1,("tsmsm_set_offline: Running [%s] returned %d\n", command, result));
352 }
353 TALLOC_FREE(command);
354 return result;
355}
356
357static uint32_t tsmsm_fs_capabilities(struct vfs_handle_struct *handle)
358{
359 return SMB_VFS_NEXT_FS_CAPABILITIES(handle) | FILE_SUPPORTS_REMOTE_STORAGE | FILE_SUPPORTS_REPARSE_POINTS;
360}
361
362static vfs_op_tuple vfs_tsmsm_ops[] = {
363
364 /* Disk operations */
365
366 {SMB_VFS_OP(tsmsm_connect), SMB_VFS_OP_CONNECT,
367 SMB_VFS_LAYER_TRANSPARENT},
368 {SMB_VFS_OP(tsmsm_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
369 SMB_VFS_LAYER_TRANSPARENT},
370 {SMB_VFS_OP(tsmsm_aio_force), SMB_VFS_OP_AIO_FORCE,
371 SMB_VFS_LAYER_TRANSPARENT},
372 {SMB_VFS_OP(tsmsm_aio_return), SMB_VFS_OP_AIO_RETURN,
373 SMB_VFS_LAYER_TRANSPARENT},
374 {SMB_VFS_OP(tsmsm_pread), SMB_VFS_OP_PREAD,
375 SMB_VFS_LAYER_TRANSPARENT},
376 {SMB_VFS_OP(tsmsm_pwrite), SMB_VFS_OP_PWRITE,
377 SMB_VFS_LAYER_TRANSPARENT},
378 {SMB_VFS_OP(tsmsm_sendfile), SMB_VFS_OP_SENDFILE,
379 SMB_VFS_LAYER_TRANSPARENT},
380 {SMB_VFS_OP(tsmsm_is_offline), SMB_VFS_OP_IS_OFFLINE,
381 SMB_VFS_LAYER_OPAQUE},
382 {SMB_VFS_OP(tsmsm_set_offline), SMB_VFS_OP_SET_OFFLINE,
383 SMB_VFS_LAYER_OPAQUE},
384
385 /* Finish VFS operations definition */
386
387 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
388 SMB_VFS_LAYER_NOOP}
389};
390
391NTSTATUS vfs_tsmsm_init(void);
392NTSTATUS vfs_tsmsm_init(void)
393{
394 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
395 "tsmsm", vfs_tsmsm_ops);
396}
Note: See TracBrowser for help on using the repository browser.