#ifdefed DMF fix so not compiled by default. We need to look at this...
[tprouty/samba.git] / source / smbd / fileio.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    read/write to a files_struct
5    Copyright (C) Andrew Tridgell 1992-1998
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
24 static BOOL setup_write_cache(files_struct *, SMB_OFF_T);
25
26 /****************************************************************************
27 seek a file. Try to avoid the seek if possible
28 ****************************************************************************/
29
30 SMB_OFF_T seek_file(files_struct *fsp,SMB_OFF_T pos)
31 {
32   SMB_OFF_T offset = 0;
33   SMB_OFF_T seek_ret;
34
35   if (fsp->print_file && lp_postscript(fsp->conn->service))
36     offset = 3;
37
38   seek_ret = fsp->conn->vfs_ops.lseek(fsp,fsp->fd,pos+offset,SEEK_SET);
39
40   /*
41    * We want to maintain the fiction that we can seek
42    * on a fifo for file system purposes. This allows 
43    * people to set up UNIX fifo's that feed data to Windows
44    * applications. JRA.
45    */
46
47   if((seek_ret == -1) && (errno == ESPIPE)) {
48     seek_ret = pos+offset;
49     errno = 0;
50   }
51
52   if((seek_ret == -1) || (seek_ret != pos+offset)) {
53     DEBUG(0,("seek_file: sys_lseek failed. Error was %s\n", strerror(errno) ));
54     fsp->pos = -1;
55     return -1;
56   }
57
58   fsp->pos = seek_ret - offset;
59
60   DEBUG(10,("seek_file: requested pos = %.0f, new pos = %.0f\n",
61         (double)(pos+offset), (double)fsp->pos ));
62
63   return(fsp->pos);
64 }
65
66 /****************************************************************************
67  Read from write cache if we can.
68 ****************************************************************************/
69
70
71 BOOL read_from_write_cache(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
72 {
73   write_cache *wcp = fsp->wcp;
74
75   if(!wcp)
76     return False;
77
78   if(n > wcp->data_size || pos < wcp->offset || pos + n > wcp->offset + wcp->data_size)
79     return False;
80
81   memcpy(data, wcp->data + (pos - wcp->offset), n);
82
83   DO_PROFILE_INC(writecache_read_hits);
84
85   return True;
86 }
87
88 /****************************************************************************
89 read from a file
90 ****************************************************************************/
91
92 ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
93 {
94         ssize_t ret=0,readret;
95
96         /* you can't read from print files */
97         if (fsp->print_file)
98                 return -1;
99
100         /*
101          * Serve from write cache if we can.
102          */
103
104         if(read_from_write_cache(fsp, data, pos, n))
105                 return n;
106
107         flush_write_cache(fsp, READ_FLUSH);
108
109         if (seek_file(fsp,pos) == -1) {
110                 DEBUG(3,("read_file: Failed to seek to %.0f\n",(double)pos));
111                 return(ret);
112         }
113   
114         if (n > 0) {
115 #ifdef DMF_FIX
116                 int numretries = 3;
117 tryagain:
118                 readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
119                 if (readret == -1) {
120                         if ((errno == EAGAIN) && numretries) {
121                                 DEBUG(3,("read_file EAGAIN retry in 10 seconds\n"));
122                                 (void)sleep(10);
123                                 --numretries;
124                                 goto tryagain;
125                         }
126                         return -1;
127                 }
128 #else /* NO DMF fix. */
129                 readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
130                 if (readret == -1)
131                         return -1;
132 #endif
133
134                 if (readret > 0)
135                         ret += readret;
136         }
137
138         return(ret);
139 }
140
141 /* how many write cache buffers have been allocated */
142 static unsigned int allocated_write_caches;
143
144 /****************************************************************************
145  *Really* write to a file.
146 ****************************************************************************/
147
148 static ssize_t real_write_file(files_struct *fsp,char *data,SMB_OFF_T pos, size_t n)
149 {
150   if ((pos != -1) && (seek_file(fsp,pos) == -1))
151     return -1;
152
153   return vfs_write_data(fsp,data,n);
154 }
155
156 /****************************************************************************
157 write to a file
158 ****************************************************************************/
159
160 ssize_t write_file(files_struct *fsp, char *data, SMB_OFF_T pos, size_t n)
161 {
162   write_cache *wcp = fsp->wcp;
163   ssize_t total_written = 0;
164   int write_path = -1; 
165
166   if (fsp->print_file) {
167           return print_job_write(fsp->print_jobid, data, n);
168   }
169
170   if (!fsp->can_write) {
171     errno = EPERM;
172     return(0);
173   }
174
175   if (!fsp->modified) {
176     SMB_STRUCT_STAT st;
177     fsp->modified = True;
178
179     if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&st) == 0) {
180       int dosmode = dos_mode(fsp->conn,fsp->fsp_name,&st);
181       if (MAP_ARCHIVE(fsp->conn) && !IS_DOS_ARCHIVE(dosmode)) { 
182         file_chmod(fsp->conn,fsp->fsp_name,dosmode | aARCH,&st);
183       }
184
185       /*
186        * If this is the first write and we have an exclusive oplock then setup
187        * the write cache.
188        */
189
190       if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !wcp) {
191         setup_write_cache(fsp, st.st_size);
192         wcp = fsp->wcp;
193       } 
194     }  
195   }
196
197 #ifdef WITH_PROFILE
198   DO_PROFILE_INC(writecache_total_writes);
199   if (!fsp->oplock_type) {
200     DO_PROFILE_INC(writecache_non_oplock_writes);
201   }
202 #endif
203
204   /*
205    * If this file is level II oplocked then we need
206    * to grab the shared memory lock and inform all
207    * other files with a level II lock that they need
208    * to flush their read caches. We keep the lock over
209    * the shared memory area whilst doing this.
210    */
211
212   release_level_2_oplocks_on_change(fsp);
213
214 #ifdef WITH_PROFILE
215   if (profile_p && profile_p->writecache_total_writes % 500 == 0) {
216     DEBUG(3,("WRITECACHE: initwrites=%u abutted=%u total=%u \
217 nonop=%u allocated=%u active=%u direct=%u perfect=%u readhits=%u\n",
218         profile_p->writecache_init_writes,
219         profile_p->writecache_abutted_writes,
220         profile_p->writecache_total_writes,
221         profile_p->writecache_non_oplock_writes,
222         profile_p->writecache_allocated_write_caches,
223         profile_p->writecache_num_write_caches,
224         profile_p->writecache_direct_writes,
225         profile_p->writecache_num_perfect_writes,
226         profile_p->writecache_read_hits ));
227
228     DEBUG(3,("WRITECACHE: Flushes SEEK=%d, READ=%d, WRITE=%d, READRAW=%d, OPLOCK=%d, CLOSE=%d, SYNC=%d\n",
229         profile_p->writecache_flushed_writes[SEEK_FLUSH],
230         profile_p->writecache_flushed_writes[READ_FLUSH],
231         profile_p->writecache_flushed_writes[WRITE_FLUSH],
232         profile_p->writecache_flushed_writes[READRAW_FLUSH],
233         profile_p->writecache_flushed_writes[OPLOCK_RELEASE_FLUSH],
234         profile_p->writecache_flushed_writes[CLOSE_FLUSH],
235         profile_p->writecache_flushed_writes[SYNC_FLUSH] ));
236   }
237 #endif
238
239   if(!wcp) {
240     DO_PROFILE_INC(writecache_direct_writes);
241     return real_write_file(fsp, data, pos, n);
242   }
243
244   DEBUG(9,("write_file(fd=%d pos=%d size=%d) wofs=%d wsize=%d\n",
245            fsp->fd, (int)pos, (int)n, (int)wcp->offset, (int)wcp->data_size));
246
247   /* 
248    * If we have active cache and it isn't contiguous then we flush.
249    * NOTE: There is a small problem with running out of disk ....
250    */
251
252   if (wcp->data_size) {
253
254     BOOL cache_flush_needed = False;
255
256     if ((pos >= wcp->offset) && (pos <= wcp->offset + wcp->data_size)) {
257       
258       /*
259        * Start of write overlaps or abutts the existing data.
260        */
261
262       size_t data_used = MIN((wcp->alloc_size - (pos - wcp->offset)), n);
263
264       memcpy(wcp->data + (pos - wcp->offset), data, data_used);
265
266       /*
267        * Update the current buffer size with the new data.
268        */
269
270       if(pos + data_used > wcp->offset + wcp->data_size)
271         wcp->data_size = pos + data_used - wcp->offset;
272
273       /*
274        * If we used all the data then
275        * return here.
276        */
277
278       if(n == data_used)
279         return n;
280       else
281         cache_flush_needed = True;
282
283       /*
284        * Move the start of data forward by the amount used,
285        * cut down the amount left by the same amount.
286        */
287
288       data += data_used;
289       pos += data_used;
290       n -= data_used;
291
292       DO_PROFILE_INC(writecache_abutted_writes);
293       total_written = data_used;
294
295       write_path = 1;
296
297     } else if ((pos < wcp->offset) && (pos + n > wcp->offset) && 
298                (pos + n <= wcp->offset + wcp->alloc_size)) {
299
300       /*
301        * End of write overlaps the existing data.
302        */
303
304       size_t data_used = pos + n - wcp->offset;
305
306       memcpy(wcp->data, data + n - data_used, data_used);
307
308       /*
309        * Update the current buffer size with the new data.
310        */
311
312       if(pos + n > wcp->offset + wcp->data_size)
313         wcp->data_size = pos + n - wcp->offset;
314
315       /*
316        * We don't need to move the start of data, but we
317        * cut down the amount left by the amount used.
318        */
319
320       n -= data_used;
321
322       /*
323        * We cannot have used all the data here.
324        */
325
326       cache_flush_needed = True;
327
328       DO_PROFILE_INC(writecache_abutted_writes);
329       total_written = data_used;
330
331       write_path = 2;
332
333     } else if ( (pos >= wcp->file_size) && 
334                 (pos > wcp->offset + wcp->data_size) && 
335                 (pos < wcp->offset + wcp->alloc_size) ) {
336
337       /*
338        * Non-contiguous write part of which fits within
339        * the cache buffer and is extending the file.
340        */
341
342       size_t data_used;
343
344       if(pos + n <= wcp->offset + wcp->alloc_size)
345         data_used = n;
346       else
347         data_used = wcp->offset + wcp->alloc_size - pos;
348
349       /*
350        * Fill in the non-continuous area with zeros.
351        */
352
353       memset(wcp->data + wcp->data_size, '\0',
354              pos - (wcp->offset + wcp->data_size) );
355
356       memcpy(wcp->data + (pos - wcp->offset), data, data_used);
357
358       /*
359        * Update the current buffer size with the new data.
360        */
361
362       if(pos + data_used > wcp->offset + wcp->data_size)
363         wcp->data_size = pos + data_used - wcp->offset;
364
365       /*
366        * Update the known file length.
367        */
368
369       wcp->file_size = wcp->offset + wcp->data_size;
370
371       /*
372        * If we used all the data then
373        * return here.
374        */
375
376       if(n == data_used)
377         return n;
378       else
379         cache_flush_needed = True;
380
381       /*
382        * Move the start of data forward by the amount used,
383        * cut down the amount left by the same amount.
384        */
385
386       data += data_used;
387       pos += data_used;
388       n -= data_used;
389
390       DO_PROFILE_INC(writecache_abutted_writes);
391       total_written = data_used;
392
393       write_path = 3;
394
395     } else {
396
397       /*
398        * Write is bigger than buffer, or there is no overlap on the
399        * low or high ends.
400        */
401
402       DEBUG(9,("write_file: non cacheable write : fd = %d, pos = %.0f, len = %u, current cache pos = %.0f \
403 len = %u\n",fsp->fd, (double)pos, (unsigned int)n, (double)wcp->offset, (unsigned int)wcp->data_size ));
404
405       /*
406        * Update the file size if needed.
407        */
408
409       if(pos + n > wcp->file_size)
410         wcp->file_size = pos + n;
411
412       /*
413        * If write would fit in the cache, and is larger than
414        * the data already in the cache, flush the cache and
415        * preferentially copy the data new data into it. Otherwise
416        * just write the data directly.
417        */
418
419       if ( n <= wcp->alloc_size && n > wcp->data_size) {
420         cache_flush_needed = True;
421       } else {
422         DO_PROFILE_INC(writecache_direct_writes);
423         return real_write_file(fsp, data, pos, n);
424       }
425
426       write_path = 4;
427
428     }
429
430     if(wcp->data_size > wcp->file_size)
431       wcp->file_size = wcp->data_size;
432
433     if (cache_flush_needed) {
434       DEBUG(3,("WRITE_FLUSH:%d: due to noncontinuous write: fd = %d, size = %.0f, pos = %.0f, \
435 n = %u, wcp->offset=%.0f, wcp->data_size=%u\n",
436              write_path, fsp->fd, (double)wcp->file_size, (double)pos, (unsigned int)n,
437              (double)wcp->offset, (unsigned int)wcp->data_size ));
438
439       flush_write_cache(fsp, WRITE_FLUSH);
440     }
441   }
442
443   /*
444    * If the write request is bigger than the cache
445    * size, write it all out.
446    */
447
448   if (n > wcp->alloc_size ) {
449     if(real_write_file(fsp, data, pos, n) == -1)
450       return -1;
451     DO_PROFILE_INC(writecache_direct_writes);
452     return total_written + n;
453   }
454
455   /*
456    * If there's any data left, cache it.
457    */
458
459   if (n) {
460 #ifdef WITH_PROFILE
461     if (wcp->data_size) {
462       DO_PROFILE_INC(writecache_abutted_writes);
463     } else {
464       DO_PROFILE_INC(writecache_init_writes);
465     }
466 #endif
467     memcpy(wcp->data+wcp->data_size, data, n);
468     if (wcp->data_size == 0) {
469       wcp->offset = pos;
470       DO_PROFILE_INC(writecache_num_write_caches);
471     }
472     wcp->data_size += n;
473     DEBUG(9,("cache return %u\n", (unsigned int)n));
474     total_written += n;
475     return total_written; /* .... that's a write :) */
476   }
477   
478   return total_written;
479 }
480
481 /****************************************************************************
482  Delete the write cache structure.
483 ****************************************************************************/
484
485 void delete_write_cache(files_struct *fsp)
486 {
487   write_cache *wcp;
488
489   if(!fsp)
490     return;
491
492   if(!(wcp = fsp->wcp))
493     return;
494
495   DO_PROFILE_DEC(writecache_allocated_write_caches);
496   allocated_write_caches--;
497
498   SMB_ASSERT(wcp->data_size == 0);
499
500   SAFE_FREE(wcp->data);
501   SAFE_FREE(fsp->wcp);
502
503   DEBUG(10,("delete_write_cache: File %s deleted write cache\n", fsp->fsp_name ));
504
505 }
506
507 /****************************************************************************
508  Setup the write cache structure.
509 ****************************************************************************/
510
511 static BOOL setup_write_cache(files_struct *fsp, SMB_OFF_T file_size)
512 {
513   ssize_t alloc_size = lp_write_cache_size(SNUM(fsp->conn));
514   write_cache *wcp;
515
516   if (allocated_write_caches >= MAX_WRITE_CACHES) 
517         return False;
518
519   if(alloc_size == 0 || fsp->wcp)
520     return False;
521
522   if((wcp = (write_cache *)malloc(sizeof(write_cache))) == NULL) {
523     DEBUG(0,("setup_write_cache: malloc fail.\n"));
524     return False;
525   }
526
527   wcp->file_size = file_size;
528   wcp->offset = 0;
529   wcp->alloc_size = alloc_size;
530   wcp->data_size = 0;
531   if((wcp->data = malloc(wcp->alloc_size)) == NULL) {
532     DEBUG(0,("setup_write_cache: malloc fail for buffer size %u.\n",
533           (unsigned int)wcp->alloc_size ));
534     SAFE_FREE(wcp);
535     return False;
536   }
537
538   fsp->wcp = wcp;
539   DO_PROFILE_INC(writecache_allocated_write_caches);
540   allocated_write_caches++;
541
542   DEBUG(10,("setup_write_cache: File %s allocated write cache size %u\n",
543                 fsp->fsp_name, wcp->alloc_size ));
544
545   return True;
546 }
547
548 /****************************************************************************
549  Cope with a size change.
550 ****************************************************************************/
551
552 void set_filelen_write_cache(files_struct *fsp, SMB_OFF_T file_size)
553 {
554   if(fsp->wcp) {
555     flush_write_cache(fsp, SIZECHANGE_FLUSH);
556     fsp->wcp->file_size = file_size;
557   }
558 }
559
560 /*******************************************************************
561  Flush a write cache struct to disk.
562 ********************************************************************/
563
564 ssize_t flush_write_cache(files_struct *fsp, enum flush_reason_enum reason)
565 {
566   write_cache *wcp = fsp->wcp;
567   size_t data_size;
568
569   if(!wcp || !wcp->data_size)
570     return 0;
571
572   data_size = wcp->data_size;
573   wcp->data_size = 0;
574
575   DO_PROFILE_DEC_INC(writecache_num_write_caches,writecache_flushed_writes[reason]);
576
577   DEBUG(9,("flushing write cache: fd = %d, off=%.0f, size=%u\n",
578            fsp->fd, (double)wcp->offset, (unsigned int)data_size));
579
580 #ifdef WITH_PROFILE
581   if(data_size == wcp->alloc_size)
582     DO_PROFILE_INC(writecache_num_perfect_writes);
583 #endif
584
585   return real_write_file(fsp, wcp->data, wcp->offset, data_size);
586 }
587
588 /*******************************************************************
589 sync a file
590 ********************************************************************/
591
592 void sync_file(connection_struct *conn, files_struct *fsp)
593 {
594     if(lp_strict_sync(SNUM(conn)) && fsp->fd != -1) {
595       flush_write_cache(fsp, SYNC_FLUSH);
596       conn->vfs_ops.fsync(fsp,fsp->fd);
597     }
598 }