source: trunk/server/source3/modules/vfs_syncops.c@ 920

/* 
 * ensure meta data operations are performed synchronously
 *
 * Copyright (C) Andrew Tridgell     2007
 * Copyright (C) Christian Ambach, 2010-2011
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *  
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *  
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "includes.h"
#include "system/filesys.h"
#include "smbd/smbd.h"

/*

  Some filesystems (even some journaled filesystems) require that a
  fsync() be performed on many meta data operations to ensure that the
  operation is guaranteed to remain in the filesystem after a power
  failure. This is particularly important for some cluster filesystems
  which are participating in a node failover system with clustered
  Samba

  On those filesystems this module provides a way to perform those
  operations safely.  

  most of the performance loss with this module is in fsync on close(). 
  You can disable that with
     syncops:onclose = no
  that can be set either globally or per share.

  On certain filesystems that only require the last data written to be
  fsync()'ed, you can disable the metadata synchronization of this module with
     syncops:onmeta = no
  This option can be set either globally or per share.

  you can also disable the module completely for a share with
     syncops:disable = true

 */

struct syncops_config_data {
        bool onclose;
        bool onmeta;
        bool disable;
};

/*
  given a filename, find the parent directory
 */
static char *parent_dir(TALLOC_CTX *mem_ctx, const char *name)
{
        const char *p = strrchr(name, '/');
        if (p == NULL) {
                return talloc_strdup(mem_ctx, ".");
        }
        return talloc_strndup(mem_ctx, name, (p+1) - name);
}

/*
  fsync a directory by name
 */
static void syncops_sync_directory(const char *dname)
{
#ifdef O_DIRECTORY
        int fd = open(dname, O_DIRECTORY|O_RDONLY);
        if (fd != -1) {
                fsync(fd);
                close(fd);
        }
#else
        DIR *d = opendir(dname);
        if (d != NULL) {
                fsync(dirfd(d));
                closedir(d);
        }
#endif
}

/*
  sync two meta data changes for 2 names
 */
static void syncops_two_names(const char *name1, const char *name2)
{
        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
        char *parent1, *parent2;
        parent1 = parent_dir(tmp_ctx, name1);
        parent2 = parent_dir(tmp_ctx, name2);
        if (!parent1 || !parent2) {
                talloc_free(tmp_ctx);
                return;
        }
        syncops_sync_directory(parent1);
        if (strcmp(parent1, parent2) != 0) {
                syncops_sync_directory(parent2);                
        }
        talloc_free(tmp_ctx);
}

/*
  sync two meta data changes for 1 names
 */
static void syncops_name(const char *name)
{
        char *parent;
        parent = parent_dir(NULL, name);
        if (parent) {
                syncops_sync_directory(parent);
                talloc_free(parent);
        }
}

/*
  sync two meta data changes for 1 names
 */
static void syncops_smb_fname(const struct smb_filename *smb_fname)
{
        char *parent;
        parent = parent_dir(NULL, smb_fname->base_name);
        if (parent) {
                syncops_sync_directory(parent);
                talloc_free(parent);
        }
}


/*
  rename needs special handling, as we may need to fsync two directories
 */
static int syncops_rename(vfs_handle_struct *handle,
                          const struct smb_filename *smb_fname_src,
                          const struct smb_filename *smb_fname_dst)
{

        int ret;
        struct syncops_config_data *config;

        SMB_VFS_HANDLE_GET_DATA(handle, config,
                                struct syncops_config_data,
                                return -1);

        ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
        if (ret == 0 && config->onmeta && !config->disable) {
                syncops_two_names(smb_fname_src->base_name,
                                  smb_fname_dst->base_name);
        }
        return ret;
}

/* handle the rest with a macro */
#define SYNCOPS_NEXT(op, fname, args) do {   \