source3/modules/vfs_syncops.c

   1 /*
   2  * ensure meta data operations are performed synchronously
   3  *
   4  * Copyright (C) Andrew Tridgell     2007
   5  * Copyright (C) Christian Ambach, 2010-2011
   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 2 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, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "includes.h"
  23 #include "system/filesys.h"
  24 #include "smbd/smbd.h"
  25
  26 /*
  27
  28   Some filesystems (even some journaled filesystems) require that a
  29   fsync() be performed on many meta data operations to ensure that the
  30   operation is guaranteed to remain in the filesystem after a power
  31   failure. This is particularly important for some cluster filesystems
  32   which are participating in a node failover system with clustered
  33   Samba
  34
  35   On those filesystems this module provides a way to perform those
  36   operations safely.
  37
  38   most of the performance loss with this module is in fsync on close().
  39   You can disable that with
  40      syncops:onclose = no
  41   that can be set either globally or per share.
  42
  43   On certain filesystems that only require the last data written to be
  44   fsync()'ed, you can disable the metadata synchronization of this module with
  45      syncops:onmeta = no
  46   This option can be set either globally or per share.
  47
  48   you can also disable the module completely for a share with
  49      syncops:disable = true
  50
  51  */
  52
  53 struct syncops_config_data {
  54         bool onclose;
  55         bool onmeta;
  56         bool disable;
  57 };
  58
  59 /*
  60   given a filename, find the parent directory
  61  */
  62 static char *parent_dir(TALLOC_CTX *mem_ctx, const char *name)
  63 {
  64         const char *p = strrchr(name, '/');
  65         if (p == NULL) {
  66                 return talloc_strdup(mem_ctx, ".");
  67         }
  68         return talloc_strndup(mem_ctx, name, (p+1) - name);
  69 }
  70
  71 /*
  72   fsync a directory by name
  73  */
  74 static void syncops_sync_directory(const char *dname)
  75 {
  76 #ifdef O_DIRECTORY
  77         int fd = open(dname, O_DIRECTORY|O_RDONLY);
  78         if (fd != -1) {
  79                 fsync(fd);
  80                 close(fd);
  81         }
  82 #else
  83         DIR *d = opendir(dname);
  84         if (d != NULL) {
  85                 fsync(dirfd(d));
  86                 closedir(d);
  87         }
  88 #endif
  89 }
  90
  91 /*
  92   sync two meta data changes for 2 names
  93  */
  94 static void syncops_two_names(const char *name1, const char *name2)
  95 {
  96         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
  97         char *parent1, *parent2;
  98         parent1 = parent_dir(tmp_ctx, name1);
  99         parent2 = parent_dir(tmp_ctx, name2);
 100         if (!parent1 || !parent2) {
 101                 talloc_free(tmp_ctx);
 102                 return;
 103         }
 104         syncops_sync_directory(parent1);
 105         if (strcmp(parent1, parent2) != 0) {
 106                 syncops_sync_directory(parent2);
 107         }
 108         talloc_free(tmp_ctx);
 109 }
 110
 111 /*
 112   sync two meta data changes for 1 names
 113  */
 114 static void syncops_smb_fname(const struct smb_filename *smb_fname)
 115 {
 116         char *parent = NULL;
 117         if (smb_fname != NULL) {
 118                 parent = parent_dir(NULL, smb_fname->base_name);
 119                 if (parent != NULL) {
 120                         syncops_sync_directory(parent);
 121                         talloc_free(parent);
 122                 }
 123         }
 124 }
 125
 126
 127 /*
 128   renameat needs special handling, as we may need to fsync two directories
 129  */
 130 static int syncops_renameat(vfs_handle_struct *handle,
 131                         files_struct *srcfsp,
 132                         const struct smb_filename *smb_fname_src,
 133                         files_struct *dstfsp,
 134                         const struct smb_filename *smb_fname_dst)
 135 {
 136
 137         int ret;
 138         struct syncops_config_data *config;
 139
 140         SMB_VFS_HANDLE_GET_DATA(handle, config,
 141                                 struct syncops_config_data,
 142                                 return -1);
 143
 144         ret = SMB_VFS_NEXT_RENAMEAT(handle,
 145                         srcfsp,
 146                         smb_fname_src,
 147                         dstfsp,
 148                         smb_fname_dst);
 149         if (ret == 0 && config->onmeta && !config->disable) {
 150                 syncops_two_names(smb_fname_src->base_name,
 151                                   smb_fname_dst->base_name);
 152         }
 153         return ret;
 154 }
 155
 156 #define SYNCOPS_NEXT_SMB_FNAME(op, fname, args) do {   \
 157         int ret; \
 158         struct syncops_config_data *config; \
 159         SMB_VFS_HANDLE_GET_DATA(handle, config, \
 160                                 struct syncops_config_data, \
 161                                 return -1); \
 162         ret = SMB_VFS_NEXT_ ## op args; \
 163         if (ret == 0 \
 164         && config->onmeta && !config->disable \
 165         && fname) syncops_smb_fname(fname); \
 166         return ret; \
 167 } while (0)
 168
 169 static int syncops_symlinkat(vfs_handle_struct *handle,
 170                         const char *link_contents,
 171                         struct files_struct *dirfsp,
 172                         const struct smb_filename *new_smb_fname)
 173 {
 174         int ret;
 175         struct syncops_config_data *config;
 176
 177         SMB_VFS_HANDLE_GET_DATA(handle, config,
 178                                 struct syncops_config_data,
 179                                 return -1);
 180
 181         ret = SMB_VFS_NEXT_SYMLINKAT(handle,
 182                                 link_contents,
 183                                 dirfsp,
 184                                 new_smb_fname);
 185
 186         if (ret == 0 && config->onmeta && !config->disable) {
 187                 syncops_two_names(link_contents,
 188                                   new_smb_fname->base_name);
 189         }
 190         return ret;
 191 }
 192
 193 static int syncops_linkat(vfs_handle_struct *handle,
 194                         files_struct *srcfsp,
 195                         const struct smb_filename *old_smb_fname,
 196                         files_struct *dstfsp,
 197                         const struct smb_filename *new_smb_fname,
 198                         int flags)
 199 {
 200         int ret;
 201         struct syncops_config_data *config;
 202
 203         SMB_VFS_HANDLE_GET_DATA(handle, config,
 204                                 struct syncops_config_data,
 205                                 return -1);
 206
 207         SMB_ASSERT(srcfsp == srcfsp->conn->cwd_fsp);
 208         SMB_ASSERT(dstfsp == dstfsp->conn->cwd_fsp);
 209
 210         ret = SMB_VFS_NEXT_LINKAT(handle,
 211                         srcfsp,
 212                         old_smb_fname,
 213                         dstfsp,
 214                         new_smb_fname,
 215                         flags);
 216
 217         if (ret == 0 && config->onmeta && !config->disable) {
 218                 syncops_two_names(old_smb_fname->base_name,
 219                                   new_smb_fname->base_name);
 220         }
 221         return ret;
 222 }
 223
 224
 225 static int syncops_open(vfs_handle_struct *handle,
 226                         struct smb_filename *smb_fname, files_struct *fsp,
 227                         int flags, mode_t mode)
 228 {
 229         SYNCOPS_NEXT_SMB_FNAME(OPEN, (flags&O_CREAT?smb_fname:NULL),
 230                                (handle, smb_fname, fsp, flags, mode));
 231 }
 232
 233 static int syncops_unlinkat(vfs_handle_struct *handle,
 234                         files_struct *dirfsp,
 235                         const struct smb_filename *smb_fname,
 236                         int flags)
 237 {
 238         SYNCOPS_NEXT_SMB_FNAME(UNLINKAT,
 239                         smb_fname,
 240                                 (handle,
 241                                 dirfsp,
 242                                 smb_fname,
 243                                 flags));
 244 }
 245
 246 static int syncops_mknodat(vfs_handle_struct *handle,
 247                         files_struct *dirfsp,
 248                         const struct smb_filename *smb_fname,
 249                         mode_t mode,
 250                         SMB_DEV_T dev)
 251 {
 252         SYNCOPS_NEXT_SMB_FNAME(MKNODAT,
 253                         smb_fname,
 254                                 (handle,
 255                                 dirfsp,
 256                                 smb_fname,
 257                                 mode,
 258                                 dev));
 259 }
 260
 261 static int syncops_mkdirat(vfs_handle_struct *handle,
 262                         struct files_struct *dirfsp,
 263                         const struct smb_filename *smb_fname,
 264                         mode_t mode)
 265 {
 266         SYNCOPS_NEXT_SMB_FNAME(MKDIRAT,
 267                         smb_fname,
 268                                 (handle,
 269                                 dirfsp,
 270                                 smb_fname,
 271                                 mode));
 272 }
 273
 274 /* close needs to be handled specially */
 275 static int syncops_close(vfs_handle_struct *handle, files_struct *fsp)
 276 {
 277         struct syncops_config_data *config;
 278
 279         SMB_VFS_HANDLE_GET_DATA(handle, config,
 280                                 struct syncops_config_data,
 281                                 return -1);
 282
 283         if (fsp->can_write && config->onclose) {
 284                 /* ideally we'd only do this if we have written some
 285                  data, but there is no flag for that in fsp yet. */
 286                 fsync(fsp->fh->fd);
 287         }
 288         return SMB_VFS_NEXT_CLOSE(handle, fsp);
 289 }
 290
 291 static int syncops_connect(struct vfs_handle_struct *handle, const char *service,
 292                            const char *user)
 293 {
 294
 295         struct syncops_config_data *config;
 296         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
 297         if (ret < 0) {
 298                 return ret;
 299         }
 300
 301         config = talloc_zero(handle->conn, struct syncops_config_data);
 302         if (!config) {
 303                 SMB_VFS_NEXT_DISCONNECT(handle);
 304                 DEBUG(0, ("talloc_zero() failed\n"));
 305                 return -1;
 306         }
 307
 308         config->onclose = lp_parm_bool(SNUM(handle->conn), "syncops",
 309                                         "onclose", true);
 310
 311         config->onmeta = lp_parm_bool(SNUM(handle->conn), "syncops",
 312                                         "onmeta", true);
 313
 314         config->disable = lp_parm_bool(SNUM(handle->conn), "syncops",
 315                                         "disable", false);
 316
 317         SMB_VFS_HANDLE_SET_DATA(handle, config,
 318                                 NULL, struct syncops_config_data,
 319                                 return -1);
 320
 321         return 0;
 322
 323 }
 324
 325 static struct vfs_fn_pointers vfs_syncops_fns = {
 326         .connect_fn = syncops_connect,
 327         .mkdirat_fn = syncops_mkdirat,
 328         .open_fn = syncops_open,
 329         .renameat_fn = syncops_renameat,
 330         .unlinkat_fn = syncops_unlinkat,
 331         .symlinkat_fn = syncops_symlinkat,
 332         .linkat_fn = syncops_linkat,
 333         .mknodat_fn = syncops_mknodat,
 334         .close_fn = syncops_close,
 335 };
 336
 337 static_decl_vfs;
 338 NTSTATUS vfs_syncops_init(TALLOC_CTX *ctx)
 339 {
 340         NTSTATUS ret;
 341
 342         ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "syncops",
 343                                &vfs_syncops_fns);
 344
 345         if (!NT_STATUS_IS_OK(ret))
 346                 return ret;
 347
 348         return ret;
 349 }