Some more VFS type errors
[kai/samba.git] / 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