2 Unix SMB/Netbios implementation.
4 read/write to a files_struct
5 Copyright (C) Andrew Tridgell 1992-1998
6 Copyright (C) Jeremy Allison 2000-2002. - write cache.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "smbd/globals.h"
26 static bool setup_write_cache(files_struct
*, SMB_OFF_T
);
28 /****************************************************************************
29 Read from write cache if we can.
30 ****************************************************************************/
32 static bool read_from_write_cache(files_struct
*fsp
,char *data
,SMB_OFF_T pos
,size_t n
)
34 write_cache
*wcp
= fsp
->wcp
;
40 if( n
> wcp
->data_size
|| pos
< wcp
->offset
|| pos
+ n
> wcp
->offset
+ wcp
->data_size
) {
44 memcpy(data
, wcp
->data
+ (pos
- wcp
->offset
), n
);
46 DO_PROFILE_INC(writecache_read_hits
);
51 /****************************************************************************
53 ****************************************************************************/
55 ssize_t
read_file(files_struct
*fsp
,char *data
,SMB_OFF_T pos
,size_t n
)
57 ssize_t ret
=0,readret
;
59 /* you can't read from print files */
60 if (fsp
->print_file
) {
66 * Serve from write cache if we can.
69 if(read_from_write_cache(fsp
, data
, pos
, n
)) {
70 fsp
->fh
->pos
= pos
+ n
;
71 fsp
->fh
->position_information
= fsp
->fh
->pos
;
75 flush_write_cache(fsp
, READ_FLUSH
);
83 readret
= SMB_VFS_PREAD(fsp
,data
,n
,pos
);
86 if ((errno
== EAGAIN
) && numretries
) {
87 DEBUG(3,("read_file EAGAIN retry in 10 seconds\n"));
94 #else /* NO DMF fix. */
95 readret
= SMB_VFS_PREAD(fsp
,data
,n
,pos
);
106 DEBUG(10,("read_file (%s): pos = %.0f, size = %lu, returned %lu\n",
107 fsp_str_dbg(fsp
), (double)pos
, (unsigned long)n
, (long)ret
));
110 fsp
->fh
->position_information
= fsp
->fh
->pos
;
115 /****************************************************************************
116 *Really* write to a file.
117 ****************************************************************************/
119 static ssize_t
real_write_file(struct smb_request
*req
,
128 ret
= vfs_write_data(req
, fsp
, data
, n
);
131 if (pos
&& lp_strict_allocate(SNUM(fsp
->conn
))) {
132 if (vfs_fill_sparse(fsp
, pos
) == -1) {
136 ret
= vfs_pwrite_data(req
, fsp
, data
, n
, pos
);
139 DEBUG(10,("real_write_file (%s): pos = %.0f, size = %lu, returned %ld\n",
140 fsp_str_dbg(fsp
), (double)pos
, (unsigned long)n
, (long)ret
));
145 /* Yes - this is correct - writes don't update this. JRA. */
146 /* Found by Samba4 tests. */
148 fsp
->position_information
= fsp
->pos
;
155 /****************************************************************************
156 File size cache change.
157 Updates size on disk but doesn't flush the cache.
158 ****************************************************************************/
160 static int wcp_file_size_change(files_struct
*fsp
)
163 write_cache
*wcp
= fsp
->wcp
;
165 wcp
->file_size
= wcp
->offset
+ wcp
->data_size
;
166 ret
= SMB_VFS_FTRUNCATE(fsp
, wcp
->file_size
);
168 DEBUG(0,("wcp_file_size_change (%s): ftruncate of size %.0f "
169 "error %s\n", fsp_str_dbg(fsp
),
170 (double)wcp
->file_size
, strerror(errno
)));
175 void update_write_time_handler(struct event_context
*ctx
,
176 struct timed_event
*te
,
180 files_struct
*fsp
= (files_struct
*)private_data
;
182 DEBUG(5, ("Update write time on %s\n", fsp_str_dbg(fsp
)));
184 /* change the write time in the open file db. */
185 (void)set_write_time(fsp
->file_id
, timespec_current());
188 notify_fname(fsp
->conn
, NOTIFY_ACTION_MODIFIED
,
189 FILE_NOTIFY_CHANGE_LAST_WRITE
, fsp
->fsp_name
->base_name
);
191 /* Remove the timed event handler. */
192 TALLOC_FREE(fsp
->update_write_time_event
);
195 /*********************************************************
196 Schedule a write time update for WRITE_TIME_UPDATE_USEC_DELAY
198 *********************************************************/
200 void trigger_write_time_update(struct files_struct
*fsp
)
204 if (fsp
->posix_open
) {
205 /* Don't use delayed writes on POSIX files. */
209 if (fsp
->write_time_forced
) {
210 /* No point - "sticky" write times
216 /* We need to remember someone did a write
217 * and update to current time on close. */
219 fsp
->update_write_time_on_close
= true;
221 if (fsp
->update_write_time_triggered
) {
223 * We only update the write time after 2 seconds
224 * on the first normal write. After that
225 * no other writes affect this until close.
229 fsp
->update_write_time_triggered
= true;
231 delay
= lp_parm_int(SNUM(fsp
->conn
),
232 "smbd", "writetimeupdatedelay",
233 WRITE_TIME_UPDATE_USEC_DELAY
);
235 DEBUG(5, ("Update write time %d usec later on %s\n",
236 delay
, fsp_str_dbg(fsp
)));
238 /* trigger the update 2 seconds later */
239 fsp
->update_write_time_event
=
240 event_add_timed(smbd_event_context(), NULL
,
241 timeval_current_ofs(0, delay
),
242 update_write_time_handler
, fsp
);
245 void trigger_write_time_update_immediate(struct files_struct
*fsp
)
247 struct smb_file_time ft
;
249 if (fsp
->posix_open
) {
250 /* Don't use delayed writes on POSIX files. */
254 if (fsp
->write_time_forced
) {
256 * No point - "sticky" write times
262 TALLOC_FREE(fsp
->update_write_time_event
);
263 DEBUG(5, ("Update write time immediate on %s\n",
266 /* After an immediate update, reset the trigger. */
267 fsp
->update_write_time_triggered
= true;
268 fsp
->update_write_time_on_close
= false;
271 ft
.mtime
= timespec_current();
273 /* Update the time in the open file db. */
274 (void)set_write_time(fsp
->file_id
, ft
.mtime
);
276 /* Now set on disk - takes care of notify. */
277 (void)smb_set_file_time(fsp
->conn
, fsp
, fsp
->fsp_name
, &ft
, false);
280 /****************************************************************************
282 ****************************************************************************/
284 ssize_t
write_file(struct smb_request
*req
,
290 write_cache
*wcp
= fsp
->wcp
;
291 ssize_t total_written
= 0;
294 if (fsp
->print_file
) {
298 ret
= print_spool_write(fsp
, data
, n
, pos
, &t
);
306 if (!fsp
->can_write
) {
311 if (!fsp
->modified
) {
312 fsp
->modified
= True
;
314 if (SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
) == 0) {
315 trigger_write_time_update(fsp
);
316 if (!fsp
->posix_open
&&
317 (lp_store_dos_attributes(SNUM(fsp
->conn
)) ||
318 MAP_ARCHIVE(fsp
->conn
))) {
319 int dosmode
= dos_mode(fsp
->conn
, fsp
->fsp_name
);
320 if (!IS_DOS_ARCHIVE(dosmode
)) {
321 file_set_dosmode(fsp
->conn
, fsp
->fsp_name
,
322 dosmode
| aARCH
, NULL
, false);
327 * If this is the first write and we have an exclusive oplock then setup
331 if (EXCLUSIVE_OPLOCK_TYPE(fsp
->oplock_type
) && !wcp
) {
332 setup_write_cache(fsp
,
333 fsp
->fsp_name
->st
.st_ex_size
);
340 DO_PROFILE_INC(writecache_total_writes
);
341 if (!fsp
->oplock_type
) {
342 DO_PROFILE_INC(writecache_non_oplock_writes
);
347 * If this file is level II oplocked then we need
348 * to grab the shared memory lock and inform all
349 * other files with a level II lock that they need
350 * to flush their read caches. We keep the lock over
351 * the shared memory area whilst doing this.
354 /* This should actually be improved to span the write. */
355 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_WRITE
);
356 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_WRITE
);
359 if (profile_p
&& profile_p
->writecache_total_writes
% 500 == 0) {
360 DEBUG(3,("WRITECACHE: initwrites=%u abutted=%u total=%u \
361 nonop=%u allocated=%u active=%u direct=%u perfect=%u readhits=%u\n",
362 profile_p
->writecache_init_writes
,
363 profile_p
->writecache_abutted_writes
,
364 profile_p
->writecache_total_writes
,
365 profile_p
->writecache_non_oplock_writes
,
366 profile_p
->writecache_allocated_write_caches
,
367 profile_p
->writecache_num_write_caches
,
368 profile_p
->writecache_direct_writes
,
369 profile_p
->writecache_num_perfect_writes
,
370 profile_p
->writecache_read_hits
));
372 DEBUG(3,("WRITECACHE: Flushes SEEK=%d, READ=%d, WRITE=%d, READRAW=%d, OPLOCK=%d, CLOSE=%d, SYNC=%d\n",
373 profile_p
->writecache_flushed_writes
[SEEK_FLUSH
],
374 profile_p
->writecache_flushed_writes
[READ_FLUSH
],
375 profile_p
->writecache_flushed_writes
[WRITE_FLUSH
],
376 profile_p
->writecache_flushed_writes
[READRAW_FLUSH
],
377 profile_p
->writecache_flushed_writes
[OPLOCK_RELEASE_FLUSH
],
378 profile_p
->writecache_flushed_writes
[CLOSE_FLUSH
],
379 profile_p
->writecache_flushed_writes
[SYNC_FLUSH
] ));
383 if (wcp
&& req
->unread_bytes
) {
384 /* If we're using receivefile don't
385 * deal with a write cache.
387 flush_write_cache(fsp
, WRITE_FLUSH
);
388 delete_write_cache(fsp
);
393 DO_PROFILE_INC(writecache_direct_writes
);
394 total_written
= real_write_file(req
, fsp
, data
, pos
, n
);
395 return total_written
;
398 DEBUG(9,("write_file (%s)(fd=%d pos=%.0f size=%u) wcp->offset=%.0f "
399 "wcp->data_size=%u\n", fsp_str_dbg(fsp
), fsp
->fh
->fd
,
400 (double)pos
, (unsigned int)n
, (double)wcp
->offset
,
401 (unsigned int)wcp
->data_size
));
403 fsp
->fh
->pos
= pos
+ n
;
405 if ((n
== 1) && (data
[0] == '\0') && (pos
> wcp
->file_size
)) {
409 * This is a 1-byte write of a 0 beyond the EOF and
410 * thus implicitly also beyond the current active
411 * write cache, the typical file-extending (and
412 * allocating, but we're using the write cache here)
413 * write done by Windows. We just have to ftruncate
414 * the file and rely on posix semantics to return
415 * zeros for non-written file data that is within the
418 * We can not use wcp_file_size_change here because we
419 * might have an existing write cache, and
420 * wcp_file_size_change assumes a change to just the
421 * end of the current write cache.
424 wcp
->file_size
= pos
+ 1;
425 ret
= SMB_VFS_FTRUNCATE(fsp
, wcp
->file_size
);
427 DEBUG(0,("wcp_file_size_change (%s): ftruncate of size %.0f"
428 "error %s\n", fsp_str_dbg(fsp
),
429 (double)wcp
->file_size
, strerror(errno
)));
437 * If we have active cache and it isn't contiguous then we flush.
438 * NOTE: There is a small problem with running out of disk ....
441 if (wcp
->data_size
) {
442 bool cache_flush_needed
= False
;
444 if ((pos
>= wcp
->offset
) && (pos
<= wcp
->offset
+ wcp
->data_size
)) {
446 /* ASCII art.... JRA.
448 +--------------+-----
449 | Cached data | Rest of allocated cache buffer....
450 +--------------+-----
452 +-------------------+
454 +-------------------+
459 * Start of write overlaps or abutts the existing data.
462 size_t data_used
= MIN((wcp
->alloc_size
- (pos
- wcp
->offset
)), n
);
464 memcpy(wcp
->data
+ (pos
- wcp
->offset
), data
, data_used
);
467 * Update the current buffer size with the new data.
470 if(pos
+ data_used
> wcp
->offset
+ wcp
->data_size
) {
471 wcp
->data_size
= pos
+ data_used
- wcp
->offset
;
475 * Update the file size if changed.
478 if (wcp
->offset
+ wcp
->data_size
> wcp
->file_size
) {
479 if (wcp_file_size_change(fsp
) == -1) {
485 * If we used all the data then
492 cache_flush_needed
= True
;
495 * Move the start of data forward by the amount used,
496 * cut down the amount left by the same amount.
503 DO_PROFILE_INC(writecache_abutted_writes
);
504 total_written
= data_used
;
508 } else if ((pos
< wcp
->offset
) && (pos
+ n
> wcp
->offset
) &&
509 (pos
+ n
<= wcp
->offset
+ wcp
->alloc_size
)) {
511 /* ASCII art.... JRA.
517 +-------------------+
519 +-------------------+
524 * End of write overlaps the existing data.
527 size_t data_used
= pos
+ n
- wcp
->offset
;
529 memcpy(wcp
->data
, data
+ n
- data_used
, data_used
);
532 * Update the current buffer size with the new data.
535 if(pos
+ n
> wcp
->offset
+ wcp
->data_size
) {
536 wcp
->data_size
= pos
+ n
- wcp
->offset
;
540 * Update the file size if changed.
543 if (wcp
->offset
+ wcp
->data_size
> wcp
->file_size
) {
544 if (wcp_file_size_change(fsp
) == -1) {
550 * We don't need to move the start of data, but we
551 * cut down the amount left by the amount used.
557 * We cannot have used all the data here.
560 cache_flush_needed
= True
;
562 DO_PROFILE_INC(writecache_abutted_writes
);
563 total_written
= data_used
;
567 } else if ( (pos
>= wcp
->file_size
) &&
568 (wcp
->offset
+ wcp
->data_size
== wcp
->file_size
) &&
569 (pos
> wcp
->offset
+ wcp
->data_size
) &&
570 (pos
< wcp
->offset
+ wcp
->alloc_size
) ) {
572 /* ASCII art.... JRA.
576 +---------------+---------------+
577 | Cached data | Cache buffer |
578 +---------------+---------------+
580 +-------------------+
582 +-------------------+
587 * Non-contiguous write part of which fits within
588 * the cache buffer and is extending the file
589 * and the cache contents reflect the current
590 * data up to the current end of the file.
595 if(pos
+ n
<= wcp
->offset
+ wcp
->alloc_size
) {
598 data_used
= wcp
->offset
+ wcp
->alloc_size
- pos
;
602 * Fill in the non-continuous area with zeros.
605 memset(wcp
->data
+ wcp
->data_size
, '\0',
606 pos
- (wcp
->offset
+ wcp
->data_size
) );
608 memcpy(wcp
->data
+ (pos
- wcp
->offset
), data
, data_used
);
611 * Update the current buffer size with the new data.
614 if(pos
+ data_used
> wcp
->offset
+ wcp
->data_size
) {
615 wcp
->data_size
= pos
+ data_used
- wcp
->offset
;
619 * Update the file size if changed.
622 if (wcp
->offset
+ wcp
->data_size
> wcp
->file_size
) {
623 if (wcp_file_size_change(fsp
) == -1) {
629 * If we used all the data then
636 cache_flush_needed
= True
;
640 * Move the start of data forward by the amount used,
641 * cut down the amount left by the same amount.
648 DO_PROFILE_INC(writecache_abutted_writes
);
649 total_written
= data_used
;
653 } else if ( (pos
>= wcp
->file_size
) &&
655 (wcp
->file_size
== wcp
->offset
+ wcp
->data_size
) &&
656 (pos
< wcp
->file_size
+ wcp
->alloc_size
)) {
662 +---------------+---------------+
663 | Cached data | Cache buffer |
664 +---------------+---------------+
666 |<------- allocated size ---------------->|
672 MS-Office seems to do this a lot to determine if there's enough
673 space on the filesystem to write a new file.
678 +-----------------------+--------+
679 | Zeroed Cached data | 1 Byte |
680 +-----------------------+--------+
683 flush_write_cache(fsp
, WRITE_FLUSH
);
684 wcp
->offset
= wcp
->file_size
;
685 wcp
->data_size
= pos
- wcp
->file_size
+ 1;
686 memset(wcp
->data
, '\0', wcp
->data_size
);
687 memcpy(wcp
->data
+ wcp
->data_size
-1, data
, 1);
690 * Update the file size if changed.
693 if (wcp
->offset
+ wcp
->data_size
> wcp
->file_size
) {
694 if (wcp_file_size_change(fsp
) == -1) {
703 /* ASCII art..... JRA.
707 +---------------+---------------+
708 | Cached data | Cache buffer |
709 +---------------+---------------+
711 +-------------------+
713 +-------------------+
717 +---------------+---------------+
718 | Cached data | Cache buffer |
719 +---------------+---------------+
721 +-------------------+
723 +-------------------+
727 +---------------+---------------+
728 | Cached data | Cache buffer |
729 +---------------+---------------+
731 +-----------------------------------------------------+
733 +-----------------------------------------------------+
738 * Write is bigger than buffer, or there is no overlap on the
742 DEBUG(9,("write_file: non cacheable write : fd = %d, pos = %.0f, len = %u, current cache pos = %.0f \
743 len = %u\n",fsp
->fh
->fd
, (double)pos
, (unsigned int)n
, (double)wcp
->offset
, (unsigned int)wcp
->data_size
));
746 * If write would fit in the cache, and is larger than
747 * the data already in the cache, flush the cache and
748 * preferentially copy the data new data into it. Otherwise
749 * just write the data directly.
752 if ( n
<= wcp
->alloc_size
&& n
> wcp
->data_size
) {
753 cache_flush_needed
= True
;
755 ssize_t ret
= real_write_file(NULL
,fsp
, data
, pos
, n
);
758 * If the write overlaps the entire cache, then
759 * discard the current contents of the cache.
760 * Fix from Rasmus Borup Hansen rbh@math.ku.dk.
763 if ((pos
<= wcp
->offset
) &&
764 (pos
+ n
>= wcp
->offset
+ wcp
->data_size
) ) {
765 DEBUG(9,("write_file: discarding overwritten write \
766 cache: fd = %d, off=%.0f, size=%u\n", fsp
->fh
->fd
, (double)wcp
->offset
, (unsigned int)wcp
->data_size
));
770 DO_PROFILE_INC(writecache_direct_writes
);
775 if (pos
+ ret
> wcp
->file_size
) {
776 wcp
->file_size
= pos
+ ret
;
786 if (cache_flush_needed
) {
787 DEBUG(3,("WRITE_FLUSH:%d: due to noncontinuous write: fd = %d, size = %.0f, pos = %.0f, \
788 n = %u, wcp->offset=%.0f, wcp->data_size=%u\n",
789 write_path
, fsp
->fh
->fd
, (double)wcp
->file_size
, (double)pos
, (unsigned int)n
,
790 (double)wcp
->offset
, (unsigned int)wcp
->data_size
));
792 flush_write_cache(fsp
, WRITE_FLUSH
);
797 * If the write request is bigger than the cache
798 * size, write it all out.
801 if (n
> wcp
->alloc_size
) {
802 ssize_t ret
= real_write_file(NULL
,fsp
, data
, pos
, n
);
807 if (pos
+ ret
> wcp
->file_size
) {
808 wcp
->file_size
= pos
+ n
;
811 DO_PROFILE_INC(writecache_direct_writes
);
812 return total_written
+ n
;
816 * If there's any data left, cache it.
821 if (wcp
->data_size
) {
822 DO_PROFILE_INC(writecache_abutted_writes
);
824 DO_PROFILE_INC(writecache_init_writes
);
828 if ((wcp
->data_size
== 0)
829 && (pos
> wcp
->file_size
)
830 && (pos
+ n
<= wcp
->file_size
+ wcp
->alloc_size
)) {
832 * This is a write completely beyond the
833 * current EOF, but within reach of the write
834 * cache. We expect fill-up writes pretty
835 * soon, so it does not make sense to start
836 * the write cache at the current
837 * offset. These fill-up writes would trigger
838 * separate pwrites or even unnecessary cache
839 * flushes because they overlap if this is a
840 * one-byte allocating write.
842 wcp
->offset
= wcp
->file_size
;
843 wcp
->data_size
= pos
- wcp
->file_size
;
844 memset(wcp
->data
, 0, wcp
->data_size
);
847 memcpy(wcp
->data
+wcp
->data_size
, data
, n
);
848 if (wcp
->data_size
== 0) {
850 DO_PROFILE_INC(writecache_num_write_caches
);
855 * Update the file size if changed.
858 if (wcp
->offset
+ wcp
->data_size
> wcp
->file_size
) {
859 if (wcp_file_size_change(fsp
) == -1) {
863 DEBUG(9,("wcp->offset = %.0f wcp->data_size = %u cache return %u\n",
864 (double)wcp
->offset
, (unsigned int)wcp
->data_size
, (unsigned int)n
));
867 return total_written
; /* .... that's a write :) */
870 return total_written
;
873 /****************************************************************************
874 Delete the write cache structure.
875 ****************************************************************************/
877 void delete_write_cache(files_struct
*fsp
)
885 if(!(wcp
= fsp
->wcp
)) {
889 DO_PROFILE_DEC(writecache_allocated_write_caches
);
890 allocated_write_caches
--;
892 SMB_ASSERT(wcp
->data_size
== 0);
894 SAFE_FREE(wcp
->data
);
897 DEBUG(10,("delete_write_cache: File %s deleted write cache\n",
901 /****************************************************************************
902 Setup the write cache structure.
903 ****************************************************************************/
905 static bool setup_write_cache(files_struct
*fsp
, SMB_OFF_T file_size
)
907 ssize_t alloc_size
= lp_write_cache_size(SNUM(fsp
->conn
));
910 if (allocated_write_caches
>= MAX_WRITE_CACHES
) {
914 if(alloc_size
== 0 || fsp
->wcp
) {
918 if((wcp
= SMB_MALLOC_P(write_cache
)) == NULL
) {
919 DEBUG(0,("setup_write_cache: malloc fail.\n"));
923 wcp
->file_size
= file_size
;
925 wcp
->alloc_size
= alloc_size
;
927 if((wcp
->data
= (char *)SMB_MALLOC(wcp
->alloc_size
)) == NULL
) {
928 DEBUG(0,("setup_write_cache: malloc fail for buffer size %u.\n",
929 (unsigned int)wcp
->alloc_size
));
934 memset(wcp
->data
, '\0', wcp
->alloc_size
);
937 DO_PROFILE_INC(writecache_allocated_write_caches
);
938 allocated_write_caches
++;
940 DEBUG(10,("setup_write_cache: File %s allocated write cache size %lu\n",
941 fsp_str_dbg(fsp
), (unsigned long)wcp
->alloc_size
));
946 /****************************************************************************
947 Cope with a size change.
948 ****************************************************************************/
950 void set_filelen_write_cache(files_struct
*fsp
, SMB_OFF_T file_size
)
953 /* The cache *must* have been flushed before we do this. */
954 if (fsp
->wcp
->data_size
!= 0) {
956 if (asprintf(&msg
, "set_filelen_write_cache: size change "
957 "on file %s with write cache size = %lu\n",
958 fsp
->fsp_name
->base_name
,
959 (unsigned long)fsp
->wcp
->data_size
) != -1) {
962 smb_panic("set_filelen_write_cache");
965 fsp
->wcp
->file_size
= file_size
;
969 /*******************************************************************
970 Flush a write cache struct to disk.
971 ********************************************************************/
973 ssize_t
flush_write_cache(files_struct
*fsp
, enum flush_reason_enum reason
)
975 write_cache
*wcp
= fsp
->wcp
;
979 if(!wcp
|| !wcp
->data_size
) {
983 data_size
= wcp
->data_size
;
986 DO_PROFILE_DEC_INC(writecache_num_write_caches
,writecache_flushed_writes
[reason
]);
988 DEBUG(9,("flushing write cache: fd = %d, off=%.0f, size=%u\n",
989 fsp
->fh
->fd
, (double)wcp
->offset
, (unsigned int)data_size
));
992 if(data_size
== wcp
->alloc_size
) {
993 DO_PROFILE_INC(writecache_num_perfect_writes
);
997 ret
= real_write_file(NULL
, fsp
, wcp
->data
, wcp
->offset
, data_size
);
1000 * Ensure file size if kept up to date if write extends file.
1003 if ((ret
!= -1) && (wcp
->offset
+ ret
> wcp
->file_size
)) {
1004 wcp
->file_size
= wcp
->offset
+ ret
;
1010 /*******************************************************************
1012 ********************************************************************/
1014 NTSTATUS
sync_file(connection_struct
*conn
, files_struct
*fsp
, bool write_through
)
1016 if (fsp
->fh
->fd
== -1)
1017 return NT_STATUS_INVALID_HANDLE
;
1019 if (lp_strict_sync(SNUM(conn
)) &&
1020 (lp_syncalways(SNUM(conn
)) || write_through
)) {
1021 int ret
= flush_write_cache(fsp
, SYNC_FLUSH
);
1023 return map_nt_error_from_unix(errno
);
1025 ret
= SMB_VFS_FSYNC(fsp
);
1027 return map_nt_error_from_unix(errno
);
1030 return NT_STATUS_OK
;
1033 /************************************************************
1034 Perform a stat whether a valid fd or not.
1035 ************************************************************/
1037 int fsp_stat(files_struct
*fsp
)
1039 if (fsp
->fh
->fd
== -1) {
1040 if (fsp
->posix_open
) {
1041 return SMB_VFS_LSTAT(fsp
->conn
, fsp
->fsp_name
);
1043 return SMB_VFS_STAT(fsp
->conn
, fsp
->fsp_name
);
1046 return SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
);