source3/modules/vfs_tsmsm.c

   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
  71 struct tsmsm_struct {
  72         float online_ratio;
  73         char *hsmscript;
  74         const char *attrib_name;
  75 };
  76
  77 static void tsmsm_free_data(void **pptr) {
  78         struct tsmsm_struct **tsmd = (struct tsmsm_struct **)pptr;
  79         if(!tsmd) return;
  80         TALLOC_FREE(*tsmd);
  81 }
  82
  83 /*
  84    called when a client connects to a share
  85 */
  86 static int tsmsm_connect(struct vfs_handle_struct *handle,
  87                          const char *service,
  88                          const char *user) {
  89         struct tsmsm_struct *tsmd = TALLOC_ZERO_P(handle, struct tsmsm_struct);
  90         const char *fres;
  91         const char *tsmname;
  92
  93         if (!tsmd) {
  94                 DEBUG(0,("tsmsm_connect: out of memory!\n"));
  95                 return -1;
  96         }
  97
  98         if (!dmapi_have_session()) {
  99                 DEBUG(0,("tsmsm_connect: no DMAPI session for Samba is available!\n"));
 100                 TALLOC_FREE(tsmd);
 101                 return -1;
 102         }
 103
 104         tsmname = (handle->param ? handle->param : "tsmsm");
 105
 106         /* Get 'hsm script' and 'dmapi attribute' parameters to tsmd context */
 107         tsmd->hsmscript = lp_parm_talloc_string(SNUM(handle->conn), tsmname,
 108                                                 "hsm script", NULL);
 109         talloc_steal(tsmd, tsmd->hsmscript);
 110
 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);
 114
 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);
 118         if (fres == NULL) {
 119                 tsmd->online_ratio = FILE_IS_ONLINE_RATIO;
 120         } else {
 121                 tsmd->online_ratio = strtof(fres, NULL);
 122                 if (tsmd->online_ratio > 1.0 ||
 123                     tsmd->online_ratio <= 0.0) {
 124                         DEBUG(1, ("tsmsm_connect: invalid online ration %f - using %f.\n",
 125                                   tsmd->online_ratio, (float)FILE_IS_ONLINE_RATIO));
 126                 }
 127         }
 128
 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);
 133 }
 134
 135 static bool tsmsm_is_offline(struct vfs_handle_struct *handle,
 136                             const char *path,
 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;
 142         size_t rlen;
 143         dm_attrname_t dmname;
 144         int ret, lerrno;
 145         bool offline;
 146         char buf[1];
 147
 148         /* if the file has more than FILE_IS_ONLINE_RATIO of blocks available,
 149            then assume it is not offline (it may not be 100%, as it could be sparse) */
 150         if (512 * (off_t)stbuf->st_blocks >= stbuf->st_size * tsmd->online_ratio) {
 151                 DEBUG(10,("%s not offline: st_blocks=%ld st_size=%ld online_ratio=%.2f\n",
 152                           path, stbuf->st_blocks, stbuf->st_size, tsmd->online_ratio));
 153                 return false;
 154         }
 155
 156         dmsession_id = dmapi_get_current_session();
 157         if (dmsession_id == NULL) {
 158                 DEBUG(2, ("tsmsm_is_offline: no DMAPI session available? "
 159                           "Assume file is online.\n"));
 160                 return false;
 161         }
 162
 163         /* using POSIX capabilities does not work here. It's a slow path, so
 164          * become_root() is just as good anyway (tridge)
 165          */
 166
 167         /* Also, AIX has DMAPI but no POSIX capablities support. In this case,
 168          * we need to be root to do DMAPI manipulations.
 169          */
 170         become_root();
 171
 172         /* go the slow DMAPI route */
 173         if (dm_path_to_handle((char*)path, &dmhandle, &dmhandle_len) != 0) {
 174                 DEBUG(2,("dm_path_to_handle failed - assuming offline (%s) - %s\n",
 175                          path, strerror(errno)));
 176                 offline = true;
 177                 goto done;
 178         }
 179
 180         memset(&dmname, 0, sizeof(dmname));
 181         strlcpy((char *)&dmname.an_chars[0], tsmd->attrib_name, sizeof(dmname.an_chars));
 182
 183         lerrno = 0;
 184
 185         do {
 186                 ret = dm_get_dmattr(*dmsession_id, dmhandle, dmhandle_len,
 187                                     DM_NO_TOKEN, &dmname, sizeof(buf), buf, &rlen);
 188                 if (ret == -1 && errno == EINVAL) {
 189                         DEBUG(0, ("Stale DMAPI session, re-creating it.\n"));
 190                         lerrno = EINVAL;
 191                         if (dmapi_new_session()) {
 192                                 dmsession_id = dmapi_get_current_session();
 193                         } else {
 194                                 DEBUG(0,
 195                                       ("Unable to re-create DMAPI session, assuming offline (%s) - %s\n",
 196                                        path, strerror(errno)));
 197                                 offline = true;
 198                                 dm_handle_free(dmhandle, dmhandle_len);
 199                                 goto done;
 200                         }
 201                 }
 202         } while (ret == -1 && lerrno == EINVAL);
 203
 204         /* its offline if the specified DMAPI attribute exists */
 205         offline = (ret == 0 || (ret == -1 && errno == E2BIG));
 206
 207         DEBUG(10,("dm_get_dmattr %s ret=%d (%s)\n", path, ret, strerror(errno)));
 208
 209         ret = 0;
 210
 211         dm_handle_free(dmhandle, dmhandle_len);
 212
 213 done:
 214         unbecome_root();
 215         return offline;
 216 }
 217
 218
 219 static bool tsmsm_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
 220 {
 221         SMB_STRUCT_STAT sbuf;
 222         struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
 223         /* see if the file might be offline. This is called before each IO
 224            to ensure we use AIO if the file is offline. We don't do the full dmapi
 225            call as that would be too slow, instead we err on the side of using AIO
 226            if the file might be offline
 227         */
 228         if(SMB_VFS_FSTAT(fsp, &sbuf) == 0) {
 229                 DEBUG(10,("tsmsm_aio_force st_blocks=%ld st_size=%ld online_ratio=%.2f\n",
 230                           sbuf.st_blocks, sbuf.st_size, tsmd->online_ratio));
 231                 return !(512 * (off_t)sbuf.st_blocks >= sbuf.st_size * tsmd->online_ratio);
 232         }
 233         return false;
 234 }
 235
 236 static ssize_t tsmsm_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp,
 237                                 SMB_STRUCT_AIOCB *aiocb)
 238 {
 239         ssize_t result;
 240
 241         result = SMB_VFS_NEXT_AIO_RETURN(handle, fsp, aiocb);
 242         if(result >= 0) {
 243                 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
 244                              FILE_NOTIFY_CHANGE_ATTRIBUTES,
 245                              fsp->fsp_name);
 246         }
 247
 248         return result;
 249 }
 250
 251 static ssize_t tsmsm_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, const DATA_BLOB *hdr,
 252                               SMB_OFF_T offset, size_t n)
 253 {
 254         bool file_online = tsmsm_aio_force(handle, fsp);
 255
 256         if(!file_online)
 257             return ENOSYS;
 258
 259         return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
 260 }
 261
 262 /* We do overload pread to allow notification when file becomes online after offline status */
 263 /* We don't intercept SMB_VFS_READ here because all file I/O now goes through SMB_VFS_PREAD instead */
 264 static ssize_t tsmsm_pread(struct vfs_handle_struct *handle, struct files_struct *fsp,
 265                            void *data, size_t n, SMB_OFF_T offset) {
 266         ssize_t result;
 267         bool notify_online = tsmsm_aio_force(handle, fsp);
 268
 269         result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
 270         if((result != -1) && notify_online) {
 271             /* We can't actually force AIO at this point (came here not from reply_read_and_X)
 272                what we can do is to send notification that file became online
 273             */
 274                 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
 275                              FILE_NOTIFY_CHANGE_ATTRIBUTES,
 276                              fsp->fsp_name);
 277         }
 278
 279         return result;
 280 }
 281
 282 static ssize_t tsmsm_pwrite(struct vfs_handle_struct *handle, struct files_struct *fsp,
 283                            void *data, size_t n, SMB_OFF_T offset) {
 284         ssize_t result;
 285         bool notify_online = tsmsm_aio_force(handle, fsp);
 286
 287         result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
 288         if((result != -1) && notify_online) {
 289             /* We can't actually force AIO at this point (came here not from reply_read_and_X)
 290                what we can do is to send notification that file became online
 291             */
 292                 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
 293                              FILE_NOTIFY_CHANGE_ATTRIBUTES,
 294                              fsp->fsp_name);
 295         }
 296
 297         return result;
 298 }
 299
 300 static int tsmsm_set_offline(struct vfs_handle_struct *handle,
 301                              const char *path) {
 302         struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
 303         int result = 0;
 304         char *command;
 305
 306         if (tsmd->hsmscript == NULL) {
 307                 /* no script enabled */
 308                 DEBUG(1, ("tsmsm_set_offline: No tsmsm:hsmscript configured\n"));
 309                 return 0;
 310         }
 311
 312         /* Now, call the script */
 313         command = talloc_asprintf(tsmd, "%s offline \"%s\"", tsmd->hsmscript, path);
 314         if(!command) {
 315                 DEBUG(1, ("tsmsm_set_offline: can't allocate memory to run hsm script"));
 316                 return -1;
 317         }
 318         DEBUG(10, ("tsmsm_set_offline: Running [%s]\n", command));
 319         if((result = smbrun(command, NULL)) != 0) {
 320                 DEBUG(1,("tsmsm_set_offline: Running [%s] returned %d\n", command, result));
 321         }
 322         TALLOC_FREE(command);
 323         return result;
 324 }
 325
 326 static uint32_t tsmsm_fs_capabilities(struct vfs_handle_struct *handle)
 327 {
 328         return SMB_VFS_NEXT_FS_CAPABILITIES(handle) | FILE_SUPPORTS_REMOTE_STORAGE | FILE_SUPPORTS_REPARSE_POINTS;
 329 }
 330
 331 static vfs_op_tuple vfs_tsmsm_ops[] = {
 332
 333         /* Disk operations */
 334
 335         {SMB_VFS_OP(tsmsm_connect),     SMB_VFS_OP_CONNECT,
 336          SMB_VFS_LAYER_TRANSPARENT},
 337         {SMB_VFS_OP(tsmsm_fs_capabilities),     SMB_VFS_OP_FS_CAPABILITIES,
 338          SMB_VFS_LAYER_TRANSPARENT},
 339         {SMB_VFS_OP(tsmsm_aio_force),   SMB_VFS_OP_AIO_FORCE,
 340          SMB_VFS_LAYER_TRANSPARENT},
 341         {SMB_VFS_OP(tsmsm_aio_return),  SMB_VFS_OP_AIO_RETURN,
 342          SMB_VFS_LAYER_TRANSPARENT},
 343         {SMB_VFS_OP(tsmsm_pread),       SMB_VFS_OP_PREAD,
 344          SMB_VFS_LAYER_TRANSPARENT},
 345         {SMB_VFS_OP(tsmsm_pwrite),      SMB_VFS_OP_PWRITE,
 346          SMB_VFS_LAYER_TRANSPARENT},
 347         {SMB_VFS_OP(tsmsm_sendfile),    SMB_VFS_OP_SENDFILE,
 348          SMB_VFS_LAYER_TRANSPARENT},
 349         {SMB_VFS_OP(tsmsm_is_offline),  SMB_VFS_OP_IS_OFFLINE,
 350          SMB_VFS_LAYER_OPAQUE},
 351         {SMB_VFS_OP(tsmsm_set_offline), SMB_VFS_OP_SET_OFFLINE,
 352          SMB_VFS_LAYER_OPAQUE},
 353
 354         /* Finish VFS operations definition */
 355
 356         {SMB_VFS_OP(NULL),              SMB_VFS_OP_NOOP,
 357          SMB_VFS_LAYER_NOOP}
 358 };
 359
 360 NTSTATUS vfs_tsmsm_init(void);
 361 NTSTATUS vfs_tsmsm_init(void)
 362 {
 363         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
 364                                 "tsmsm", vfs_tsmsm_ops);
 365 }