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
|
//go:build unix
package mmap
import (
"fmt"
"os"
"syscall"
"lindenii.org/go/lgo/intconv"
)
// Mmap is one read-only memory mapping of an entire file.
//
// The mapping remains valid
// after the originating file is closed.
//
// Truncating the mapped file can cause
// a fatal SIGBUS on later access;
// callers should only map files
// that are never truncated while in use.
//
// Labels: Close-Caller.
type Mmap struct {
// data is the mapped region,
// or nil for empty files and closed mappings.
data []byte
}
// Open maps file read-only in its entirety.
//
// file is only used during Open
// and may be closed once Open returns.
func Open(file *os.File) (*Mmap, error) {
info, err := file.Stat()
if err != nil {
return nil, fmt.Errorf("internal/mmap: %w", err)
}
size64, err := intconv.Int64ToUint64(info.Size())
if err != nil {
return nil, fmt.Errorf("internal/mmap: %w", err)
}
size, err := intconv.Uint64ToInt(size64)
if err != nil {
return nil, fmt.Errorf("internal/mmap: %w", err)
}
if size == 0 {
return &Mmap{data: nil}, nil
}
fd, err := intconv.UintptrToInt(file.Fd())
if err != nil {
return nil, fmt.Errorf("internal/mmap: %w", err)
}
data, err := syscall.Mmap(fd, 0, size, syscall.PROT_READ, syscall.MAP_PRIVATE)
if err != nil {
return nil, fmt.Errorf("internal/mmap: %w", err)
}
return &Mmap{data: data}, nil
}
// Data returns the mapped bytes.
//
// Labels: Life-Parent, Mut-No.
func (mmap *Mmap) Data() []byte {
return mmap.data
}
// Close unmaps the mapping,
// invalidating previously returned data.
//
// Labels: Idem-Yes, MT-Unsafe.
func (mmap *Mmap) Close() error {
if mmap.data == nil {
return nil
}
data := mmap.data
mmap.data = nil
err := syscall.Munmap(data)
if err != nil {
return fmt.Errorf("internal/mmap: %w", err)
}
return nil
}
|
