source3/modules/vfs_commit.c

   1 /*
   2  * Copyright (c) James Peach 2006, 2007
   3  * Copyright (c) David Losada Carballo 2007
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "includes.h"
  20
  21 /* Commit data module.
  22  *
  23  * The purpose of this module is to flush data to disk at regular intervals,
  24  * just like the NFS commit operation. There's two rationales for this. First,
  25  * it minimises the data loss in case of a power outage without incurring
  26  * the poor performance of synchronous I/O. Second, a steady flush rate
  27  * can produce better throughput than suddenly dumping massive amounts of
  28  * writes onto a disk.
  29  *
  30  * Tunables:
  31  *
  32  *  commit: dthresh         Amount of dirty data that can accumulate
  33  *                          before we commit (sync) it.
  34  *
  35  *  commit: debug           Debug level at which to emit messages.
  36  *
  37  *  commit: eof mode        String. Tunes how the module tries to guess when
  38  *                          the client has written the last bytes of the file.
  39  *                          Possible values (default = hinted):
  40  *
  41  *     (*)  = hinted        Some clients (i.e. Windows Explorer) declare the
  42  *                          size of the file before transferring it. With this
  43  *                          option, we remember that hint, and commit after
  44  *                          writing in that file position. If the client
  45  *                          doesn't declare the size of file, commiting on EOF
  46  *                          is not triggered.
  47  *
  48  *          = growth        Commits after a write operation has made the file
  49  *                          size grow. If the client declares a file size, it
  50  *                          refrains to commit until the file has reached it.
  51  *                          Useful for defeating writeback on NFS shares.
  52  *
  53  */
  54
  55 #define MODULE "commit"
  56
  57 static int module_debug;
  58
  59 enum eof_mode
  60 {
  61     EOF_NONE = 0x0000,
  62     EOF_HINTED = 0x0001,
  63     EOF_GROWTH = 0x0002
  64 };
  65
  66 struct commit_info
  67 {
  68         /* For chunk-based commits */
  69         SMB_OFF_T dbytes;       /* Dirty (uncommitted) bytes */
  70         SMB_OFF_T dthresh;      /* Dirty data threshold */
  71         /* For commits on EOF */
  72         enum eof_mode on_eof;
  73         SMB_OFF_T eof;          /* Expected file size */
  74 };
  75
  76 static int commit_do(
  77         struct commit_info *            c,
  78         int                             fd)
  79 {
  80         int result;
  81
  82         DEBUG(module_debug,
  83                 ("%s: flushing %lu dirty bytes\n",
  84                  MODULE, (unsigned long)c->dbytes));
  85
  86 #if HAVE_FDATASYNC
  87         result = fdatasync(fd);
  88 #elif HAVE_FSYNC
  89         result = fsync(fd);
  90 #else
  91         result = 0
  92 #endif
  93         if (result == 0) {
  94                 c->dbytes = 0;  /* on success, no dirty bytes */
  95         }
  96         return result;
  97 }
  98
  99 static int commit_all(
 100         struct vfs_handle_struct *      handle,
 101         files_struct *                  fsp)
 102 {
 103         struct commit_info *c;
 104
 105         if ((c = (struct commit_info *)VFS_FETCH_FSP_EXTENSION(handle, fsp))) {
 106                 if (c->dbytes) {
 107                         DEBUG(module_debug,
 108                                 ("%s: flushing %lu dirty bytes\n",
 109                                  MODULE, (unsigned long)c->dbytes));
 110
 111                         return commit_do(c, fsp->fh->fd);
 112                 }
 113         }
 114         return 0;
 115 }
 116
 117 static int commit(
 118         struct vfs_handle_struct *      handle,
 119         files_struct *                  fsp,
 120         SMB_OFF_T                       offset,
 121         ssize_t                         last_write)
 122 {
 123         struct commit_info *c;
 124
 125         if ((c = (struct commit_info *)VFS_FETCH_FSP_EXTENSION(handle, fsp))
 126             == NULL) {
 127                 return 0;
 128         }
 129
 130         c->dbytes += last_write;        /* dirty bytes always counted */
 131
 132         if (c->dthresh && (c->dbytes > c->dthresh)) {
 133                 return commit_do(c, fsp->fh->fd);
 134         }
 135
 136         /* Return if we are not in EOF mode or if we have temporarily opted
 137          * out of it.
 138          */
 139         if (c->on_eof == EOF_NONE || c->eof < 0) {
 140                 return 0;
 141         }
 142
 143         /* This write hit or went past our cache the file size. */
 144         if ((offset + last_write) >= c->eof) {
 145                 if (commit_do(c, fsp->fh->fd) == -1) {
 146                         return -1;
 147                 }
 148
 149                 /* Hinted mode only commits the first time we hit EOF. */
 150                 if (c->on_eof == EOF_HINTED) {
 151                     c->eof = -1;
 152                 } else if (c->on_eof == EOF_GROWTH) {
 153                     c->eof = offset + last_write;
 154                 }
 155         }
 156
 157         return 0;
 158 }
 159
 160 static int commit_connect(
 161         struct vfs_handle_struct *  handle,
 162         const char *                service,
 163         const char *                user)
 164 {
 165         module_debug = lp_parm_int(SNUM(handle->conn), MODULE, "debug", 100);
 166         return SMB_VFS_NEXT_CONNECT(handle, service, user);
 167 }
 168
 169 static int commit_open(
 170         vfs_handle_struct * handle,
 171         struct smb_filename *smb_fname,
 172         files_struct *      fsp,
 173         int                 flags,
 174         mode_t              mode)
 175 {
 176         SMB_OFF_T dthresh;
 177         const char *eof_mode;
 178         struct commit_info *c = NULL;
 179         int fd;
 180
 181         /* Don't bother with read-only files. */
 182         if ((flags & O_ACCMODE) == O_RDONLY) {
 183                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 184         }
 185
 186         /* Read and check module configuration */
 187         dthresh = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
 188                                         MODULE, "dthresh", NULL));
 189
 190         eof_mode = lp_parm_const_string(SNUM(handle->conn),
 191                                         MODULE, "eof mode", "none");
 192
 193         if (dthresh > 0 || !strequal(eof_mode, "none")) {
 194                 c = (struct commit_info *)VFS_ADD_FSP_EXTENSION(
 195                         handle, fsp, struct commit_info, NULL);
 196                 /* Process main tunables */
 197                 if (c) {
 198                         c->dthresh = dthresh;
 199                         c->dbytes = 0;
 200                         c->on_eof = EOF_NONE;
 201                         c->eof = 0;
 202                 }
 203         }
 204         /* Process eof_mode tunable */
 205         if (c) {
 206                 if (strequal(eof_mode, "hinted")) {
 207                         c->on_eof = EOF_HINTED;
 208                 } else if (strequal(eof_mode, "growth")) {
 209                         c->on_eof = EOF_GROWTH;
 210                 }
 211         }
 212
 213         fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 214         if (fd == -1) {
 215                 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
 216                 return fd;
 217         }
 218
 219         /* EOF commit modes require us to know the initial file size. */
 220         if (c && (c->on_eof != EOF_NONE)) {
 221                 SMB_STRUCT_STAT st;
 222                 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 223                         return -1;
 224                 }
 225                 c->eof = st.st_ex_size;
 226         }
 227
 228         return 0;
 229 }
 230
 231 static ssize_t commit_write(
 232         vfs_handle_struct * handle,
 233         files_struct *      fsp,
 234         const void *        data,
 235         size_t              count)
 236 {
 237         ssize_t ret;
 238         ret = SMB_VFS_NEXT_WRITE(handle, fsp, data, count);
 239
 240         if (ret > 0) {
 241                 if (commit(handle, fsp, fsp->fh->pos, ret) == -1) {
 242                         return -1;
 243                 }
 244         }
 245
 246         return ret;
 247 }
 248
 249 static ssize_t commit_pwrite(
 250         vfs_handle_struct * handle,
 251         files_struct *      fsp,
 252         const void *        data,
 253         size_t              count,
 254         SMB_OFF_T           offset)
 255 {
 256         ssize_t ret;
 257
 258         ret = SMB_VFS_NEXT_PWRITE(handle, fsp, data, count, offset);
 259         if (ret > 0) {
 260                 if (commit(handle, fsp, offset, ret) == -1) {
 261                         return -1;
 262                 }
 263         }
 264
 265         return ret;
 266 }
 267
 268 static int commit_close(
 269         vfs_handle_struct * handle,
 270         files_struct *      fsp)
 271 {
 272         /* Commit errors not checked, close() will find them again */
 273         commit_all(handle, fsp);
 274         return SMB_VFS_NEXT_CLOSE(handle, fsp);
 275 }
 276
 277 static int commit_ftruncate(
 278         vfs_handle_struct * handle,
 279         files_struct *      fsp,
 280         SMB_OFF_T           len)
 281 {
 282         int result;
 283
 284         result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
 285         if (result == 0) {
 286                 struct commit_info *c;
 287                 if ((c = (struct commit_info *)VFS_FETCH_FSP_EXTENSION(
 288                              handle, fsp))) {
 289                         commit(handle, fsp, len, 0);
 290                         c->eof = len;
 291                 }
 292         }
 293
 294         return result;
 295 }
 296
 297 static vfs_op_tuple commit_ops [] =
 298 {
 299         {SMB_VFS_OP(commit_open),
 300                 SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT},
 301         {SMB_VFS_OP(commit_close),
 302                 SMB_VFS_OP_CLOSE, SMB_VFS_LAYER_TRANSPARENT},
 303         {SMB_VFS_OP(commit_write),
 304                 SMB_VFS_OP_WRITE, SMB_VFS_LAYER_TRANSPARENT},
 305         {SMB_VFS_OP(commit_pwrite),
 306                 SMB_VFS_OP_PWRITE, SMB_VFS_LAYER_TRANSPARENT},
 307         {SMB_VFS_OP(commit_connect),
 308                 SMB_VFS_OP_CONNECT,  SMB_VFS_LAYER_TRANSPARENT},
 309         {SMB_VFS_OP(commit_ftruncate),
 310                 SMB_VFS_OP_FTRUNCATE,  SMB_VFS_LAYER_TRANSPARENT},
 311
 312         {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
 313 };
 314
 315 NTSTATUS vfs_commit_init(void);
 316 NTSTATUS vfs_commit_init(void)
 317 {
 318         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE, commit_ops);
 319 }
 320
 321