fflush 和 fsync的区别

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <stdio.h>
#include <stdlib.h>
...
FILE *fp = fopen("./interface.log", "a+");
if (fp == NULL) {
    perror("open file: interface.log failed ");
    abort();
}

fprintf(fp, "[DEBUG] Interface: GenerateIndex\n");
fclose(fp);

1

[core:notice] [pid 7203] AH00052: child pid 19370 exit signal Aborted (6)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

NAME
       fflush - flush a stream

SYNOPSIS
       #include <stdio.h>

       int fflush(FILE *stream);

DESCRIPTION
       For  output  streams,  fflush()  forces  a write of all user-space
       buffered data for the  given  output  or  update  stream  via  the
       stream's underlying write function.

       For  input  streams  associated  with  seekable  files (e.g., disk
       files, but not pipes or terminals), fflush() discards any buffered
       data  that  has been fetched from the underlying file, but has not
       been consumed by the application.

NOTES
       Note that fflush() flushes only the user-space buffers provided by
       the C library.  To ensure that the data is  physically  stored  on
       disk  the  kernel  buffers  must be flushed too, for example, with
       sync(2) or fsync(2).

1
2
3
4
5
6
7

int fd = fileno(fp);
fprintf(fp, "[DEBUG] Interface: GenerateIndex\n");
// 想测试Apache是不是会将stderr的信息重定向到原来的日志文件(答案是否定的)
fprintf(stderr, "[DEBUG] Interface: GenerateIndex\n");
fflush(fp);
fsync(fileno(fp));
fclose(fp);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

NAME
       fsync, fdatasync - synchronize a file's in-core state with storage device

SYNOPSIS
       #include <unistd.h>

       int fsync(int fd);

       int fdatasync(int fd);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):


DESCRIPTION
       # fsync 将文件相关的所有更改都刷新到disk device, 这个调用是阻塞的,
       # 直到disk通知此函数传输完成。此函数也会将该文件的文件元信息(访问
       # 时间或者修改时间等)刷新到磁盘。
       fsync()  transfers ("flushes") all modified in-core data of (i.e.,
       modified buffer cache pages for) the file referred to by the  file
       descriptor  fd  to the disk device (or other permanent storage de‐
       vice) so that all changed information can be retrieved even if the
       system  crashes  or is rebooted.  This includes writing through or
       flushing a disk cache if present.  The call blocks until  the  de‐
       vice reports that the transfer has completed.

       As  well as flushing the file data, fsync() also flushes the meta‐
       data information associated with the file (see inode(7)).

       Calling fsync() does not necessarily ensure that the entry in  the
       directory  containing the file has also reached disk.  For that an
       explicit fsync() on a file descriptor for the  directory  is  also
       needed.

       fdatasync()  is  similar  to  fsync(), but does not flush modified
       metadata unless that metadata is needed in order to allow a subse‐
       quent  data  retrieval  to  be  correctly  handled.   For example,
       changes to st_atime or st_mtime (respectively, time of last access
       and time of last modification; see inode(7)) do not require flush‐
       ing because they are not necessary for a subsequent data  read  to
       be  handled  correctly.   On  the other hand, a change to the file
       size (st_size, as made by say ftruncate(2)), would require a meta‐
       data flush.

       The aim of fdatasync() is to reduce disk activity for applications
       that do not require all metadata to be synchronized with the disk.

1
2

fflush(fp);
fsync(fileno(fp));