2 Unix SMB/CIFS implementation.
3 Samba VFS module for handling offline files
4 with Tivoli Storage Manager Space Management
6 (c) Alexander Bokovoy, 2007, 2008
7 (c) Andrew Tridgell, 2007, 2008
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.
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.
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/>.
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>
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)
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.
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.
44 #error "This module requires DMAPI support!"
47 #ifdef HAVE_XFS_DMAPI_H
48 #include <xfs/dmapi.h>
49 #elif defined(HAVE_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)
59 #ifndef _ISOC99_SOURCE
60 #define _ISOC99_SOURCE
65 /* optimisation tunables - used to avoid the DMAPI slow path */
66 #define FILE_IS_ONLINE_RATIO 0.5
68 /* default attribute name to look for */
69 #define DM_ATTRIB_OBJECT "IBMObj"
74 const char *attrib_name;
77 static void tsmsm_free_data(void **pptr) {
78 struct tsmsm_struct **tsmd = (struct tsmsm_struct **)pptr;
84 called when a client connects to a share
86 static int tsmsm_connect(struct vfs_handle_struct *handle,
89 struct tsmsm_struct *tsmd = TALLOC_ZERO_P(handle, struct tsmsm_struct);
94 DEBUG(0,("tsmsm_connect: out of memory!\n"));
98 if (!dmapi_have_session()) {
99 DEBUG(0,("tsmsm_connect: no DMAPI session for Samba is available!\n"));
104 tsmname = (handle->param ? handle->param : "tsmsm");
106 /* Get 'hsm script' and 'dmapi attribute' parameters to tsmd context */
107 tsmd->hsmscript = lp_parm_talloc_string(SNUM(handle->conn), tsmname,
109 talloc_steal(tsmd, tsmd->hsmscript);
111 tsmd->attrib_name = lp_parm_talloc_string(SNUM(handle->conn), tsmname,
112 "dmapi attribute", DM_ATTRIB_OBJECT);
113 talloc_steal(tsmd, tsmd->attrib_name);
115 /* retrieve 'online ratio'. In case of error default to FILE_IS_ONLINE_RATIO */
116 fres = lp_parm_const_string(SNUM(handle->conn), tsmname,
117 "online ratio", NULL);
119 tsmd->online_ratio = FILE_IS_ONLINE_RATIO;
121 tsmd->online_ratio = strtof(fres, NULL);
122 if (tsmd->online_ration > 1.0 ||
123 tsmd->online_ration <= 0.0) {
124 DEBUG(1, ("tsmsm_connect: invalid online ration %f - using %f.\n",
125 tsmd->online_ration, (float)FILE_IS_ONLINE_RATIO));
129 /* Store the private data. */
130 SMB_VFS_HANDLE_SET_DATA(handle, tsmd, tsmsm_free_data,
131 struct tsmsm_struct, return -1);
132 return SMB_VFS_NEXT_CONNECT(handle, service, user);
135 static bool tsmsm_is_offline(struct vfs_handle_struct *handle,
137 SMB_STRUCT_STAT *stbuf) {
138 struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
139 const dm_sessid_t *dmsession_id;
140 void *dmhandle = NULL;
141 size_t dmhandle_len = 0;
143 dm_attrname_t dmname;
147 /* if the file has more than FILE_IS_ONLINE_RATIO of blocks available,
148 then assume it is not offline (it may not be 100%, as it could be sparse) */
149 if (512 * (off_t)stbuf->st_blocks >= stbuf->st_size * tsmd->online_ratio) {
150 DEBUG(10,("%s not offline: st_blocks=%ld st_size=%ld online_ratio=%.2f\n",
151 path, stbuf->st_blocks, stbuf->st_size, tsmd->online_ratio));
155 dmsession_id = dmapi_get_current_session();
156 if (dmsession_id == NULL) {
157 DEBUG(2, ("tsmsm_is_offline: no DMAPI session available? "
158 "Assume file is online.\n"));
162 /* using POSIX capabilities does not work here. It's a slow path, so
163 * become_root() is just as good anyway (tridge)
166 /* Also, AIX has DMAPI but no POSIX capablities support. In this case,
167 * we need to be root to do DMAPI manipulations.
171 /* go the slow DMAPI route */
172 if (dm_path_to_handle((char*)path, &dmhandle, &dmhandle_len) != 0) {
173 DEBUG(2,("dm_path_to_handle failed - assuming offline (%s) - %s\n",
174 path, strerror(errno)));
179 memset(&dmname, 0, sizeof(dmname));
180 strlcpy((char *)&dmname.an_chars[0], tsmd->attrib_name, sizeof(dmname.an_chars));
182 ret = dm_get_dmattr(*dmsession_id, dmhandle, dmhandle_len,
183 DM_NO_TOKEN, &dmname, 0, NULL, &rlen);
185 /* its offline if the specified DMAPI attribute exists */
186 offline = (ret == 0 || (ret == -1 && errno == E2BIG));
188 DEBUG(10,("dm_get_dmattr %s ret=%d (%s)\n", path, ret, strerror(errno)));
192 dm_handle_free(dmhandle, dmhandle_len);
200 static bool tsmsm_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
202 SMB_STRUCT_STAT sbuf;
203 struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
204 /* see if the file might be offline. This is called before each IO
205 to ensure we use AIO if the file is offline. We don't do the full dmapi
206 call as that would be too slow, instead we err on the side of using AIO
207 if the file might be offline
209 if(SMB_VFS_FSTAT(fsp, &sbuf) == 0) {
210 DEBUG(10,("tsmsm_aio_force st_blocks=%ld st_size=%ld online_ratio=%.2f\n",
211 sbuf.st_blocks, sbuf.st_size, tsmd->online_ratio));
212 return !(512 * (off_t)sbuf.st_blocks >= sbuf.st_size * tsmd->online_ratio);
217 static ssize_t tsmsm_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp,
218 SMB_STRUCT_AIOCB *aiocb)
222 result = SMB_VFS_NEXT_AIO_RETURN(handle, fsp, aiocb);
224 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
225 FILE_NOTIFY_CHANGE_ATTRIBUTES,
232 static ssize_t tsmsm_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, const DATA_BLOB *hdr,
233 SMB_OFF_T offset, size_t n)
235 bool file_online = tsmsm_aio_force(handle, fsp);
240 return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
243 /* We do overload pread to allow notification when file becomes online after offline status */
244 /* We don't intercept SMB_VFS_READ here because all file I/O now goes through SMB_VFS_PREAD instead */
245 static ssize_t tsmsm_pread(struct vfs_handle_struct *handle, struct files_struct *fsp,
246 void *data, size_t n, SMB_OFF_T offset) {
248 bool notify_online = tsmsm_aio_force(handle, fsp);
250 result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
251 if((result != -1) && notify_online) {
252 /* We can't actually force AIO at this point (came here not from reply_read_and_X)
253 what we can do is to send notification that file became online
255 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
256 FILE_NOTIFY_CHANGE_ATTRIBUTES,
263 static ssize_t tsmsm_pwrite(struct vfs_handle_struct *handle, struct files_struct *fsp,
264 void *data, size_t n, SMB_OFF_T offset) {
266 bool notify_online = tsmsm_aio_force(handle, fsp);
268 result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
269 if((result != -1) && notify_online) {
270 /* We can't actually force AIO at this point (came here not from reply_read_and_X)
271 what we can do is to send notification that file became online
273 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
274 FILE_NOTIFY_CHANGE_ATTRIBUTES,
281 static int tsmsm_set_offline(struct vfs_handle_struct *handle,
283 struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
287 if (tsmd->hsmscript == NULL) {
288 /* no script enabled */
289 DEBUG(1, ("tsmsm_set_offline: No tsmsm:hsmscript configured\n"));
293 /* Now, call the script */
294 command = talloc_asprintf(tsmd, "%s offline \"%s\"", tsmd->hsmscript, path);
296 DEBUG(1, ("tsmsm_set_offline: can't allocate memory to run hsm script"));
299 DEBUG(10, ("tsmsm_set_offline: Running [%s]\n", command));
300 if((result = smbrun(command, NULL)) != 0) {
301 DEBUG(1,("tsmsm_set_offline: Running [%s] returned %d\n", command, result));
303 TALLOC_FREE(command);
307 static bool tsmsm_statvfs(struct vfs_handle_struct *handle, const char *path, vfs_statvfs_struct *statbuf)
311 result = SMB_VFS_NEXT_STATVFS(handle, path, statbuf);
312 statbuf->FsCapabilities | = FILE_SUPPORTS_REMOTE_STORAGE | FILE_SUPPORTS_REPARSE_POINTS;
317 static vfs_op_tuple vfs_tsmsm_ops[] = {
319 /* Disk operations */
321 {SMB_VFS_OP(tsmsm_connect), SMB_VFS_OP_CONNECT,
322 SMB_VFS_LAYER_TRANSPARENT},
323 {SMB_VFS_OP(tsmsm_statvfs), SMB_VFS_OP_STATVFS,
324 SMB_VFS_LAYER_TRANSPARENT},
325 {SMB_VFS_OP(tsmsm_aio_force), SMB_VFS_OP_AIO_FORCE,
326 SMB_VFS_LAYER_TRANSPARENT},
327 {SMB_VFS_OP(tsmsm_aio_return), SMB_VFS_OP_AIO_RETURN,
328 SMB_VFS_LAYER_TRANSPARENT},
329 {SMB_VFS_OP(tsmsm_pread), SMB_VFS_OP_PREAD,
330 SMB_VFS_LAYER_TRANSPARENT},
331 {SMB_VFS_OP(tsmsm_pwrite), SMB_VFS_OP_PWRITE,
332 SMB_VFS_LAYER_TRANSPARENT},
333 {SMB_VFS_OP(tsmsm_sendfile), SMB_VFS_OP_SENDFILE,
334 SMB_VFS_LAYER_TRANSPARENT},
335 {SMB_VFS_OP(tsmsm_is_offline), SMB_VFS_OP_IS_OFFLINE,
336 SMB_VFS_LAYER_OPAQUE},
337 {SMB_VFS_OP(tsmsm_set_offline), SMB_VFS_OP_SET_OFFLINE,
338 SMB_VFS_LAYER_OPAQUE},
340 /* Finish VFS operations definition */
342 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
346 NTSTATUS vfs_tsmsm_init(void);
347 NTSTATUS vfs_tsmsm_init(void)
349 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
350 "tsmsm", vfs_tsmsm_ops);