Ensure fsp->size is correct so readraw's return correct data.
[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                 if (readret > 0)
134                         ret += readret;
135         }
136
137         return(ret);
138 }
139
140 /* how many write cache buffers have been allocated */
141 static unsigned int allocated_write_caches;
142
143 /****************************************************************************
144  *Really* write to a file.
145 ****************************************************************************/
146
147 static ssize_t real_write_file(files_struct *fsp,char *data,SMB_OFF_T pos, size_t n)
148 {
149   if ((pos != -1) && (seek_file(fsp,pos) == -1))
150     return -1;
151
152   return vfs_write_data(fsp,data,n);
153 }
154
155 /****************************************************************************
156 write to a file
157 ****************************************************************************/
158
159 ssize_t write_file(files_struct *fsp, char *data, SMB_OFF_T pos, size_t n)
160 {
161   write_cache *wcp = fsp->wcp;
162   ssize_t total_written = 0;
163   int write_path = -1; 
164
165   if (fsp->print_file) {
166           return print_job_write(fsp->print_jobid, data, n);
167   }
168
169   if (!fsp->can_write) {
170     errno = EPERM;
171     return(0);
172   }
173
174   if (!fsp->modified) {
175     SMB_STRUCT_STAT st;
176     fsp->modified = True;
177
178     if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&st) == 0) {
179       int dosmode = dos_mode(fsp->conn,fsp->fsp_name,&st);
180       fsp->size = st.st_size;
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     total_written = real_write_file(fsp, data, pos, n);
242     if ((total_written != -1) && (pos + total_written > fsp->size))
243       fsp->size = pos + total_written;
244     return total_written;
245   }
246
247   DEBUG(9,("write_file(fd=%d pos=%.0f size=%u) wcp->offset=%.0f wcp->data_size=%u\n",
248            fsp->fd, (double)pos, (unsigned int)n, (double)wcp->offset, (unsigned int)wcp->data_size));
249
250   /* 
251    * If we have active cache and it isn't contiguous then we flush.
252    * NOTE: There is a small problem with running out of disk ....
253    */
254
255   if (wcp->data_size) {
256
257     BOOL cache_flush_needed = False;
258
259     if ((pos >= wcp->offset) && (pos <= wcp->offset + wcp->data_size)) {
260       
261       /*
262        * Start of write overlaps or abutts the existing data.
263        */
264
265       size_t data_used = MIN((wcp->alloc_size - (pos - wcp->offset)), n);
266
267       memcpy(wcp->data + (pos - wcp->offset), data, data_used);
268
269       /*
270        * Update the current buffer size with the new data.
271        */
272
273       if(pos + data_used > wcp->offset + wcp->data_size)
274         wcp->data_size = pos + data_used - wcp->offset;
275
276       /*
277        * Update the file size if changed.
278        */
279
280       if (wcp->offset + wcp->data_size > wcp->file_size)
281         fsp->size = wcp->file_size = wcp->offset + wcp->data_size;
282
283       /*
284        * If we used all the data then
285        * return here.
286        */
287
288       if(n == data_used)
289         return n;
290       else
291         cache_flush_needed = True;
292
293       /*
294        * Move the start of data forward by the amount used,
295        * cut down the amount left by the same amount.
296        */
297
298       data += data_used;
299       pos += data_used;
300       n -= data_used;
301
302       DO_PROFILE_INC(writecache_abutted_writes);
303       total_written = data_used;
304
305       write_path = 1;
306
307     } else if ((pos < wcp->offset) && (pos + n > wcp->offset) && 
308                (pos + n <= wcp->offset + wcp->alloc_size)) {
309
310       /*
311        * End of write overlaps the existing data.
312        */
313
314       size_t data_used = pos + n - wcp->offset;
315
316       memcpy(wcp->data, data + n - data_used, data_used);
317
318       /*
319        * Update the current buffer size with the new data.
320        */
321
322       if(pos + n > wcp->offset + wcp->data_size)
323         wcp->data_size = pos + n - wcp->offset;
324
325       /*
326        * Update the file size if changed.
327        */
328
329       if (wcp->offset + wcp->data_size > wcp->file_size)
330         fsp->size = wcp->file_size = wcp->offset + wcp->data_size;
331
332       /*
333        * We don't need to move the start of data, but we
334        * cut down the amount left by the amount used.
335        */
336
337       n -= data_used;
338
339       /*
340        * We cannot have used all the data here.
341        */
342
343       cache_flush_needed = True;
344
345       DO_PROFILE_INC(writecache_abutted_writes);
346       total_written = data_used;
347
348       write_path = 2;
349
350     } else if ( (pos >= wcp->file_size) && 
351                 (wcp->offset + wcp->data_size == wcp->file_size) &&
352                 (pos > wcp->offset + wcp->data_size) && 
353                 (pos < wcp->offset + wcp->alloc_size) ) {
354
355       /*
356        * Non-contiguous write part of which fits within
357        * the cache buffer and is extending the file
358        * and the cache contents reflect the current
359        * data up to the current end of the file.
360        */
361
362       size_t data_used;
363
364       if(pos + n <= wcp->offset + wcp->alloc_size)
365         data_used = n;
366       else
367         data_used = wcp->offset + wcp->alloc_size - pos;
368
369       /*
370        * Fill in the non-continuous area with zeros.
371        */
372
373       memset(wcp->data + wcp->data_size, '\0',
374              pos - (wcp->offset + wcp->data_size) );
375
376       memcpy(wcp->data + (pos - wcp->offset), data, data_used);
377
378       /*
379        * Update the current buffer size with the new data.
380        */
381
382       if(pos + data_used > wcp->offset + wcp->data_size)
383         wcp->data_size = pos + data_used - wcp->offset;
384
385       /*
386        * Update the file size if changed.
387        */
388
389       if (wcp->offset + wcp->data_size > wcp->file_size)
390         fsp->size = wcp->file_size = wcp->offset + wcp->data_size;
391
392       /*
393        * If we used all the data then
394        * return here.
395        */
396
397       if(n == data_used)
398         return n;
399       else
400         cache_flush_needed = True;
401
402       /*
403        * Move the start of data forward by the amount used,
404        * cut down the amount left by the same amount.
405        */
406
407       data += data_used;
408       pos += data_used;
409       n -= data_used;
410
411       DO_PROFILE_INC(writecache_abutted_writes);
412       total_written = data_used;
413
414       write_path = 3;
415
416     } else {
417
418       /*
419        * Write is bigger than buffer, or there is no overlap on the
420        * low or high ends.
421        */
422
423       DEBUG(9,("write_file: non cacheable write : fd = %d, pos = %.0f, len = %u, current cache pos = %.0f \
424 len = %u\n",fsp->fd, (double)pos, (unsigned int)n, (double)wcp->offset, (unsigned int)wcp->data_size ));
425
426       /*
427        * Update the file size if needed.
428        */
429
430       if(pos + n > wcp->file_size)
431         fsp->size = wcp->file_size = pos + n;
432
433       /*
434        * If write would fit in the cache, and is larger than
435        * the data already in the cache, flush the cache and
436        * preferentially copy the data new data into it. Otherwise
437        * just write the data directly.
438        */
439
440       if ( n <= wcp->alloc_size && n > wcp->data_size) {
441         cache_flush_needed = True;
442       } else {
443         ssize_t ret = real_write_file(fsp, data, pos, n);
444
445         DO_PROFILE_INC(writecache_direct_writes);
446         if (ret == -1)
447           return ret;
448
449         if (pos + ret > wcp->file_size)
450           fsp->size = wcp->file_size = pos + ret;
451
452         return ret;
453       }
454
455       write_path = 4;
456
457     }
458
459     if(wcp->data_size > wcp->file_size)
460       fsp->size = wcp->file_size = wcp->data_size;
461
462     if (cache_flush_needed) {
463       DEBUG(3,("WRITE_FLUSH:%d: due to noncontinuous write: fd = %d, size = %.0f, pos = %.0f, \
464 n = %u, wcp->offset=%.0f, wcp->data_size=%u\n",
465              write_path, fsp->fd, (double)wcp->file_size, (double)pos, (unsigned int)n,
466              (double)wcp->offset, (unsigned int)wcp->data_size ));
467
468       flush_write_cache(fsp, WRITE_FLUSH);
469     }
470   }
471
472   /*
473    * If the write request is bigger than the cache
474    * size, write it all out.
475    */
476
477   if (n > wcp->alloc_size ) {
478     ssize_t ret = real_write_file(fsp, data, pos, n);
479     if (ret == -1)
480       return -1;
481
482     if (pos + ret > wcp->file_size)
483       fsp->size = wcp->file_size = pos + n;
484
485     DO_PROFILE_INC(writecache_direct_writes);
486     return total_written + n;
487   }
488
489   /*
490    * If there's any data left, cache it.
491    */
492
493   if (n) {
494 #ifdef WITH_PROFILE
495     if (wcp->data_size) {
496       DO_PROFILE_INC(writecache_abutted_writes);
497     } else {
498       DO_PROFILE_INC(writecache_init_writes);
499     }
500 #endif
501     memcpy(wcp->data+wcp->data_size, data, n);
502     if (wcp->data_size == 0) {
503       wcp->offset = pos;
504       DO_PROFILE_INC(writecache_num_write_caches);
505     }
506     wcp->data_size += n;
507
508     /*
509      * Update the file size if changed.
510      */
511
512     if (wcp->offset + wcp->data_size > wcp->file_size)
513       fsp->size = wcp->file_size = wcp->offset + wcp->data_size;
514     DEBUG(9,("wcp->offset = %.0f wcp->data_size = %u cache return %u\n",
515                 (double)wcp->offset, (unsigned int)wcp->data_size, (unsigned int)n));
516
517     total_written += n;
518     return total_written; /* .... that's a write :) */
519   }
520   
521   return total_written;
522 }
523
524 /****************************************************************************
525  Delete the write cache structure.
526 ****************************************************************************/
527
528 void delete_write_cache(files_struct *fsp)
529 {
530   write_cache *wcp;
531
532   if(!fsp)
533     return;
534
535   if(!(wcp = fsp->wcp))
536     return;
537
538   DO_PROFILE_DEC(writecache_allocated_write_caches);
539   allocated_write_caches--;
540
541   SMB_ASSERT(wcp->data_size == 0);
542
543   SAFE_FREE(wcp->data);
544   SAFE_FREE(fsp->wcp);
545
546   DEBUG(10,("delete_write_cache: File %s deleted write cache\n", fsp->fsp_name ));
547
548 }
549
550 /****************************************************************************
551  Setup the write cache structure.
552 ****************************************************************************/
553
554 static BOOL setup_write_cache(files_struct *fsp, SMB_OFF_T file_size)
555 {
556   ssize_t alloc_size = lp_write_cache_size(SNUM(fsp->conn));
557   write_cache *wcp;
558
559   if (allocated_write_caches >= MAX_WRITE_CACHES) 
560         return False;
561
562   if(alloc_size == 0 || fsp->wcp)
563     return False;
564
565   if((wcp = (write_cache *)malloc(sizeof(write_cache))) == NULL) {
566     DEBUG(0,("setup_write_cache: malloc fail.\n"));
567     return False;
568   }
569
570   wcp->file_size = file_size;
571   wcp->offset = 0;
572   wcp->alloc_size = alloc_size;
573   wcp->data_size = 0;
574   if((wcp->data = malloc(wcp->alloc_size)) == NULL) {
575     DEBUG(0,("setup_write_cache: malloc fail for buffer size %u.\n",
576           (unsigned int)wcp->alloc_size ));
577     SAFE_FREE(wcp);
578     return False;
579   }
580
581   memset(wcp->data, '\0', wcp->alloc_size );
582
583   fsp->wcp = wcp;
584   DO_PROFILE_INC(writecache_allocated_write_caches);
585   allocated_write_caches++;
586
587   DEBUG(10,("setup_write_cache: File %s allocated write cache size %u\n",
588                 fsp->fsp_name, wcp->alloc_size ));
589
590   return True;
591 }
592
593 /****************************************************************************
594  Cope with a size change.
595 ****************************************************************************/
596
597 void set_filelen_write_cache(files_struct *fsp, SMB_OFF_T file_size)
598 {
599   fsp->size = file_size;
600   if(fsp->wcp) {
601     /* The cache *must* have been flushed before we do this. */
602     if (fsp->wcp->data_size != 0) {
603       pstring msg;
604       slprintf(msg, sizeof(msg)-1, "set_filelen_write_cache: size change \
605 on file %s with write cache size = %u\n", fsp->fsp_name, fsp->wcp->data_size );
606       smb_panic(msg);
607     }
608     fsp->wcp->file_size = file_size;
609   }
610 }
611
612 /*******************************************************************
613  Flush a write cache struct to disk.
614 ********************************************************************/
615
616 ssize_t flush_write_cache(files_struct *fsp, enum flush_reason_enum reason)
617 {
618   write_cache *wcp = fsp->wcp;
619   size_t data_size;
620   ssize_t ret;
621
622   if(!wcp || !wcp->data_size)
623     return 0;
624
625   data_size = wcp->data_size;
626   wcp->data_size = 0;
627
628   DO_PROFILE_DEC_INC(writecache_num_write_caches,writecache_flushed_writes[reason]);
629
630   DEBUG(9,("flushing write cache: fd = %d, off=%.0f, size=%u\n",
631            fsp->fd, (double)wcp->offset, (unsigned int)data_size));
632
633 #ifdef WITH_PROFILE
634   if(data_size == wcp->alloc_size)
635     DO_PROFILE_INC(writecache_num_perfect_writes);
636 #endif
637
638   ret = real_write_file(fsp, wcp->data, wcp->offset, data_size);
639
640   /*
641    * Ensure file size if kept up to date if write extends file.
642    */
643
644   if ((ret != -1) && (wcp->offset + ret > wcp->file_size))
645     wcp->file_size = wcp->offset + ret;
646
647   return ret;
648 }
649
650 /*******************************************************************
651 sync a file
652 ********************************************************************/
653
654 void sync_file(connection_struct *conn, files_struct *fsp)
655 {
656     if(lp_strict_sync(SNUM(conn)) && fsp->fd != -1) {
657       flush_write_cache(fsp, SYNC_FLUSH);
658       conn->vfs_ops.fsync(fsp,fsp->fd);
659     }
660 }