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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
package main
import (
"fmt"
"path/filepath"
"syscall"
)
// syncBasic opens a file, writes data, and fsyncs it.
func syncBasic() error {
dir, cleanup, err := makeTempDir("sync-basic")
if err != nil {
return err
}
defer cleanup()
path := filepath.Join(dir, "syncfile.txt")
fd, err := syscall.Open(path, syscall.O_RDWR|syscall.O_CREAT, 0o644)
if err != nil {
return fmt.Errorf("open: %w", err)
}
defer syscall.Close(fd)
if _, err := syscall.Write(fd, []byte("sync me")); err != nil {
return fmt.Errorf("write: %w", err)
}
return syscall.Fsync(fd)
}
// syncFdatasync opens a file, writes data, and fdatasyncs it.
func syncFdatasync() error {
dir, cleanup, err := makeTempDir("sync-fdatasync")
if err != nil {
return err
}
defer cleanup()
path := filepath.Join(dir, "fdatasyncfile.txt")
fd, err := syscall.Open(path, syscall.O_RDWR|syscall.O_CREAT, 0o644)
if err != nil {
return fmt.Errorf("open: %w", err)
}
defer syscall.Close(fd)
if _, err := syscall.Write(fd, []byte("fdatasync me")); err != nil {
return fmt.Errorf("write: %w", err)
}
return syscall.Fdatasync(fd)
}
// syncSync calls sync(2) to flush all filesystem caches.
// sync is a null_event with no file arguments.
func syncSync() error {
syscall.Sync()
return nil
}
// syncSyncFileRange opens a file, writes data, then calls sync_file_range(2).
func syncSyncFileRange() error {
dir, cleanup, err := makeTempDir("sync-sync-file-range")
if err != nil {
return err
}
defer cleanup()
path := filepath.Join(dir, "syncrangefile.txt")
fd, err := syscall.Open(path, syscall.O_RDWR|syscall.O_CREAT, 0o644)
if err != nil {
return fmt.Errorf("open: %w", err)
}
defer syscall.Close(fd)
data := []byte("sync file range data")
if _, err := syscall.Write(fd, data); err != nil {
return fmt.Errorf("write: %w", err)
}
return syscall.SyncFileRange(fd, 0, int64(len(data)), 0)
}
// syncSyncFileRangeToEOF calls sync_file_range(2) with nbytes=0.
// Per sync_file_range(2), nbytes=0 means "sync from offset through end-of-file".
func syncSyncFileRangeToEOF() error {
dir, cleanup, err := makeTempDir("sync-sync-file-range-to-eof")
if err != nil {
return err
}
defer cleanup()
path := filepath.Join(dir, "syncrangeeoffile.txt")
fd, err := syscall.Open(path, syscall.O_RDWR|syscall.O_CREAT, 0o644)
if err != nil {
return fmt.Errorf("open: %w", err)
}
defer syscall.Close(fd)
if _, err := syscall.Write(fd, []byte("sync file range to eof")); err != nil {
return fmt.Errorf("write: %w", err)
}
return syscall.SyncFileRange(fd, 0, 0, 0)
}
// syncFsyncEbadf calls fsync on an invalid fd.
// The syscall fails with EBADF, but ior captures the enter_fsync tracepoint.
func syncFsyncEbadf() error {
for i := 0; i < 5; i++ {
_, _, errno := syscall.Syscall(syscall.SYS_FSYNC, 99999, 0, 0)
if errno == 0 {
return fmt.Errorf("expected EBADF, but fsync succeeded")
}
}
return nil
}
// syncFdatasyncEbadf calls fdatasync on an invalid fd.
// The syscall fails with EBADF, but ior captures the enter_fdatasync tracepoint.
func syncFdatasyncEbadf() error {
for i := 0; i < 5; i++ {
_, _, errno := syscall.Syscall(syscall.SYS_FDATASYNC, 99999, 0, 0)
if errno == 0 {
return fmt.Errorf("expected EBADF, but fdatasync succeeded")
}
}
return nil
}
// syncFileRangeEbadf calls sync_file_range on an invalid fd.
// The syscall fails with EBADF, but ior captures the enter_sync_file_range tracepoint.
func syncFileRangeEbadf() error {
for i := 0; i < 5; i++ {
_, _, errno := syscall.Syscall6(syscall.SYS_SYNC_FILE_RANGE, 99999, 0, 0, 0, 0, 0)
if errno == 0 {
return fmt.Errorf("expected EBADF, but sync_file_range succeeded")
}
}
return nil
}
|
