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 #include "system/filesys.h"
  21 #include "smbd/smbd.h"
  22 #include "lib/util/tevent_unix.h"
  23
  24 /* Commit data module.
  25  *
  26  * The purpose of this module is to flush data to disk at regular intervals,
  27  * just like the NFS commit operation. There's two rationales for this. First,
  28  * it minimises the data loss in case of a power outage without incurring
  29  * the poor performance of synchronous I/O. Second, a steady flush rate
  30  * can produce better throughput than suddenly dumping massive amounts of
  31  * writes onto a disk.
  32  *
  33  * Tunables:
  34  *
  35  *  commit: dthresh         Amount of dirty data that can accumulate
  36  *                          before we commit (sync) it.
  37  *
  38  *  commit: debug           Debug level at which to emit messages.
  39  *
  40  *  commit: eof mode        String. Tunes how the module tries to guess when
  41  *                          the client has written the last bytes of the file.
  42  *                          Possible values (default = hinted):
  43  *
  44  *     (*)  = hinted        Some clients (i.e. Windows Explorer) declare the
  45  *                          size of the file before transferring it. With this
  46  *                          option, we remember that hint, and commit after
  47  *                          writing in that file position. If the client
  48  *                          doesn't declare the size of file, commiting on EOF
  49  *                          is not triggered.
  50  *
  51  *          = growth        Commits after a write operation has made the file
  52  *                          size grow. If the client declares a file size, it
  53  *                          refrains to commit until the file has reached it.
  54  *                          Useful for defeating writeback on NFS shares.
  55  *
  56  */
  57
  58 #define MODULE "commit"
  59
  60 static int module_debug;
  61
  62 enum eof_mode
  63 {
  64     EOF_NONE = 0x0000,
  65     EOF_HINTED = 0x0001,
  66     EOF_GROWTH = 0x0002
  67 };
  68
  69 struct commit_info
  70 {
  71         /* For chunk-based commits */
  72         off_t dbytes;   /* Dirty (uncommitted) bytes */
  73         off_t dthresh;  /* Dirty data threshold */
  74         /* For commits on EOF */
  75         enum eof_mode on_eof;
  76         off_t eof;              /* Expected file size */
  77 };
  78
  79 static int commit_do(
  80         struct commit_info *            c,
  81         int                             fd)
  82 {
  83         int result;
  84
  85         DEBUG(module_debug,
  86                 ("%s: flushing %lu dirty bytes\n",
  87                  MODULE, (unsigned long)c->dbytes));
  88
  89 #if HAVE_FDATASYNC
  90         result = fdatasync(fd);
  91 #elif HAVE_FSYNC
  92         result = fsync(fd);
  93 #else
  94         DEBUG(0, ("%s: WARNING: no commit support on this platform\n",
  95                 MODULE));
  96         result = 0
  97 #endif
  98         if (result == 0) {
  99                 c->dbytes = 0;  /* on success, no dirty bytes */
 100         }
 101         return result;
 102 }
 103
 104 static int commit_all(
 105         struct vfs_handle_struct *      handle,
 106         files_struct *                  fsp)
 107 {
 108         struct commit_info *c;
 109
 110         if ((c = (struct commit_info *)VFS_FETCH_FSP_EXTENSION(handle, fsp))) {
 111                 if (c->dbytes) {
 112                         DEBUG(module_debug,
 113                                 ("%s: flushing %lu dirty bytes\n",
 114                                  MODULE, (unsigned long)c->dbytes));
 115
 116                         return commit_do(c, fsp->fh->fd);
 117                 }
 118         }
 119         return 0;
 120 }
 121
 122 static int commit(
 123         struct vfs_handle_struct *      handle,
 124         files_struct *                  fsp,
 125         off_t                   offset,
 126         ssize_t                         last_write)
 127 {
 128         struct commit_info *c;
 129
 130         if ((c = (struct commit_info *)VFS_FETCH_FSP_EXTENSION(handle, fsp))
 131             == NULL) {
 132                 return 0;
 133         }
 134
 135         c->dbytes += last_write;        /* dirty bytes always counted */
 136
 137         if (c->dthresh && (c->dbytes > c->dthresh)) {
 138                 return commit_do(c, fsp->fh->fd);
 139         }
 140
 141         /* Return if we are not in EOF mode or if we have temporarily opted
 142          * out of it.
 143          */
 144         if (c->on_eof == EOF_NONE || c->eof < 0) {
 145                 return 0;
 146         }
 147
 148         /* This write hit or went past our cache the file size. */
 149         if ((offset + last_write) >= c->eof) {
 150                 if (commit_do(c, fsp->fh->fd) == -1) {
 151                         return -1;
 152                 }
 153
 154                 /* Hinted mode only commits the first time we hit EOF. */
 155                 if (c->on_eof == EOF_HINTED) {
 156                     c->eof = -1;
 157                 } else if (c->on_eof == EOF_GROWTH) {
 158                     c->eof = offset + last_write;
 159                 }
 160         }
 161
 162         return 0;
 163 }
 164
 165 static int commit_connect(
 166         struct vfs_handle_struct *  handle,
 167         const char *                service,
 168         const char *                user)
 169 {
 170         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
 171
 172         if (ret < 0) {
 173                 return ret;
 174         }
 175
 176         module_debug = lp_parm_int(SNUM(handle->conn), MODULE, "debug", 100);
 177         return 0;
 178 }
 179
 180 static int commit_open(
 181         vfs_handle_struct * handle,
 182         struct smb_filename *smb_fname,
 183         files_struct *      fsp,
 184         int                 flags,
 185         mode_t              mode)
 186 {
 187         off_t dthresh;
 188         const char *eof_mode;
 189         struct commit_info *c = NULL;
 190         int fd;
 191
 192         /* Don't bother with read-only files. */
 193         if ((flags & O_ACCMODE) == O_RDONLY) {
 194                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 195         }
 196
 197         /* Read and check module configuration */
 198         dthresh = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
 199                                         MODULE, "dthresh", NULL));
 200
 201         eof_mode = lp_parm_const_string(SNUM(handle->conn),
 202                                         MODULE, "eof mode", "none");
 203
 204         if (dthresh > 0 || !strequal(eof_mode, "none")) {
 205                 c = (struct commit_info *)VFS_ADD_FSP_EXTENSION(
 206                         handle, fsp, struct commit_info, NULL);
 207                 /* Process main tunables */
 208                 if (c) {
 209                         c->dthresh = dthresh;
 210                         c->dbytes = 0;
 211                         c->on_eof = EOF_NONE;
 212                         c->eof = 0;
 213                 }
 214         }
 215         /* Process eof_mode tunable */
 216         if (c) {
 217                 if (strequal(eof_mode, "hinted")) {
 218                         c->on_eof = EOF_HINTED;
 219                 } else if (strequal(eof_mode, "growth")) {
 220                         c->on_eof = EOF_GROWTH;
 221                 }
 222         }
 223
 224         fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 225         if (fd == -1) {
 226                 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
 227                 return fd;
 228         }
 229
 230         /* EOF commit modes require us to know the initial file size. */
 231         if (c && (c->on_eof != EOF_NONE)) {
 232                 SMB_STRUCT_STAT st;
 233                 /*
 234                  * Setting the fd of the FSP is a hack
 235                  * but also practiced elsewhere -
 236                  * needed for calling the VFS.
 237                  */
 238                 fsp->fh->fd = fd;
 239                 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 240                         int saved_errno = errno;
 241                         SMB_VFS_CLOSE(fsp);
 242                         errno = saved_errno;
 243                         return -1;
 244                 }
 245                 c->eof = st.st_ex_size;
 246         }
 247
 248         return fd;
 249 }
 250
 251 static ssize_t commit_write(
 252         vfs_handle_struct * handle,
 253         files_struct *      fsp,
 254         const void *        data,
 255         size_t              count)
 256 {
 257         ssize_t ret;
 258         ret = SMB_VFS_NEXT_WRITE(handle, fsp, data, count);
 259
 260         if (ret > 0) {
 261                 if (commit(handle, fsp, fsp->fh->pos, ret) == -1) {
 262                         return -1;
 263                 }
 264         }
 265
 266         return ret;
 267 }
 268
 269 static ssize_t commit_pwrite(
 270         vfs_handle_struct * handle,
 271         files_struct *      fsp,
 272         const void *        data,
 273         size_t              count,
 274         off_t       offset)
 275 {
 276         ssize_t ret;
 277
 278         ret = SMB_VFS_NEXT_PWRITE(handle, fsp, data, count, offset);
 279         if (ret > 0) {
 280                 if (commit(handle, fsp, offset, ret) == -1) {
 281                         return -1;
 282                 }
 283         }
 284
 285         return ret;
 286 }
 287
 288 struct commit_pwrite_state {
 289         struct vfs_handle_struct *handle;
 290         struct files_struct *fsp;
 291         ssize_t ret;
 292         struct vfs_aio_state vfs_aio_state;
 293 };
 294
 295 static void commit_pwrite_written(struct tevent_req *subreq);
 296
 297 static struct tevent_req *commit_pwrite_send(struct vfs_handle_struct *handle,
 298                                              TALLOC_CTX *mem_ctx,
 299                                              struct tevent_context *ev,
 300                                              struct files_struct *fsp,
 301                                              const void *data,
 302                                              size_t n, off_t offset)
 303 {
 304         struct tevent_req *req, *subreq;
 305         struct commit_pwrite_state *state;
 306
 307         req = tevent_req_create(mem_ctx, &state, struct commit_pwrite_state);
 308         if (req == NULL) {
 309                 return NULL;
 310         }
 311         state->handle = handle;
 312         state->fsp = fsp;
 313
 314         subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp, data,
 315                                           n, offset);
 316         if (tevent_req_nomem(subreq, req)) {
 317                 return tevent_req_post(req, ev);
 318         }
 319         tevent_req_set_callback(subreq, commit_pwrite_written, req);
 320         return req;
 321 }
 322
 323 static void commit_pwrite_written(struct tevent_req *subreq)
 324 {
 325         struct tevent_req *req = tevent_req_callback_data(
 326                 subreq, struct tevent_req);
 327         struct commit_pwrite_state *state = tevent_req_data(
 328                 req, struct commit_pwrite_state);
 329         int commit_ret;
 330
 331         state->ret = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
 332         TALLOC_FREE(subreq);
 333
 334         if (state->ret <= 0) {
 335                 tevent_req_done(req);
 336                 return;
 337         }
 338
 339         /*
 340          * Ok, this is a sync fake. We should make the sync async as well, but
 341          * I'm too lazy for that right now -- vl
 342          */
 343         commit_ret = commit(state->handle, state->fsp, state->fsp->fh->pos,
 344                             state->ret);
 345
 346         if (commit_ret == -1) {
 347                 state->ret = -1;
 348         }
 349
 350         tevent_req_done(req);
 351 }
 352
 353 static ssize_t commit_pwrite_recv(struct tevent_req *req,
 354                                   struct vfs_aio_state *vfs_aio_state)
 355 {
 356         struct commit_pwrite_state *state =
 357                 tevent_req_data(req, struct commit_pwrite_state);
 358
 359         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
 360                 return -1;
 361         }
 362         *vfs_aio_state = state->vfs_aio_state;
 363         return state->ret;
 364 }
 365
 366 static int commit_close(
 367         vfs_handle_struct * handle,
 368         files_struct *      fsp)
 369 {
 370         /* Commit errors not checked, close() will find them again */
 371         commit_all(handle, fsp);
 372         return SMB_VFS_NEXT_CLOSE(handle, fsp);
 373 }
 374
 375 static int commit_ftruncate(
 376         vfs_handle_struct * handle,
 377         files_struct *      fsp,
 378         off_t           len)
 379 {
 380         int result;
 381
 382         result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
 383         if (result == 0) {
 384                 struct commit_info *c;
 385                 if ((c = (struct commit_info *)VFS_FETCH_FSP_EXTENSION(
 386                              handle, fsp))) {
 387                         commit(handle, fsp, len, 0);
 388                         c->eof = len;
 389                 }
 390         }
 391
 392         return result;
 393 }
 394
 395 static struct vfs_fn_pointers vfs_commit_fns = {
 396         .open_fn = commit_open,
 397         .close_fn = commit_close,
 398         .write_fn = commit_write,
 399         .pwrite_fn = commit_pwrite,
 400         .pwrite_send_fn = commit_pwrite_send,
 401         .pwrite_recv_fn = commit_pwrite_recv,
 402         .connect_fn = commit_connect,
 403         .ftruncate_fn = commit_ftruncate
 404 };
 405
 406 NTSTATUS vfs_commit_init(TALLOC_CTX *);
 407 NTSTATUS vfs_commit_init(TALLOC_CTX *ctx)
 408 {
 409         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE,
 410                                 &vfs_commit_fns);
 411 }
 412
 413