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