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
138
139
140
141
142
|
package mmap
import (
"errors"
"io"
"io/fs"
"runtime"
"syscall"
)
// MmapFile maps file at path into memory using syscall.mmap(),
// and returns a protected MmapReader{} for accessing the mapped data.
// Note that the mapped memory is not concurrency safe (other than
// concurrent ReadAt() calls). Any other calls made concurrently to
// Read() or Close() (including ReadAt()) require protection.
func MmapFile(path string) (*MmappedFile, error) {
// Stat file information.
stat, err := stat(path)
if err != nil {
return nil, err
}
// Mmap file into memory.
return openMmap(path, stat)
}
func openMmap(path string, stat *fileStat) (*MmappedFile, error) {
if stat.Size() <= 0 {
// Empty file, no-op read.
return &MmappedFile{}, nil
}
// Check file data size is accessible.
if stat.Size() != int64(int(stat.Size())) {
return nil, errors.New("file is too large")
}
// Open file at path for read-only access.
fd, err := open(path, syscall.O_RDONLY, 0)
if err != nil {
return nil, err
}
// Map this file into memory as slice.
mem, err := mmap(fd, 0, int(stat.Size()),
syscall.PROT_READ, syscall.MAP_PRIVATE)
// Done with file.
_ = close_(fd)
if err != nil {
return nil, err
}
// Return as wrapped reader type.
return newMmapReader(mem, stat), nil
}
// newMmapReader wraps a mapped memory slice in an
// MmappedFile{}, also setting a GC finalizer function.
func newMmapReader(mem []byte, stat *fileStat) *MmappedFile {
r := &MmappedFile{b: mem, s: stat}
runtime.SetFinalizer(r, (*MmappedFile).Close)
return r
}
type MmappedFile struct {
b []byte // mapped memory
n int // read index
s *fileStat // file info
}
func (r *MmappedFile) Name() string {
return r.s.name
}
func (r *MmappedFile) Stat() (fs.FileInfo, error) {
return r.s, nil
}
func (r *MmappedFile) Read(b []byte) (n int, err error) {
if r.n >= len(r.b) {
return 0, io.EOF
}
n = copy(b, r.b[r.n:])
r.n += n
return
}
func (r *MmappedFile) ReadAt(b []byte, off int64) (n int, err error) {
if off > int64(len(r.b)) {
return 0, io.EOF
}
n = copy(b, r.b[off:])
return n, nil
}
func (r *MmappedFile) WriteTo(w io.Writer) (int64, error) {
if r.n >= len(r.b) {
return 0, io.EOF
}
n, err := w.Write(r.b[r.n:])
r.n += n
return int64(n), err
}
func (r *MmappedFile) Seek(off int64, whence int) (int64, error) {
var n int
switch whence {
case io.SeekCurrent:
n = r.n + int(off)
case io.SeekStart:
n = 0 + int(off)
case io.SeekEnd:
n = len(r.b) + int(off)
default:
return 0, errors.New("invalid argument")
}
if n < 0 || n > len(r.b) {
return 0, errors.New("invalid argument")
}
r.n = n
return int64(n), nil
}
func (r *MmappedFile) Len() int {
return len(r.b) - r.n
}
func (r *MmappedFile) Size() int64 {
return int64(len(r.b))
}
func (r *MmappedFile) Close() error {
if b := r.b; b != nil {
r.b = nil
runtime.SetFinalizer(r, nil)
return munmap(b)
}
return nil
}
|
