// mmap memory maps a DB's data file.
func mmap(db *DB, sz int) error {
// Truncate and fsync to ensure file size metadata is flushed.
// https://github.com/boltdb/bolt/issues/284
if !db.NoGrowSync && !db.readOnly {
if err := db.file.Truncate(int64(sz)); err != nil {
return fmt.Errorf("file resize error: %s", err)
}
if err := db.file.Sync(); err != nil {
return fmt.Errorf("file sync error: %s", err)
}
}
// Map the data file to memory.
b, err := unix.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED|db.MmapFlags)
if err != nil {
return err
}
// Advise the kernel that the mmap is accessed randomly.
if err := unix.Madvise(b, syscall.MADV_RANDOM); err != nil {
return fmt.Errorf("madvise: %s", err)
}
// Save the original byte slice and convert to a byte array pointer.
db.dataref = b
db.data = (*[maxMapSize]byte)(unsafe.Pointer(&b[0]))
db.datasz = sz
return nil
}
func TestMmap(t *testing.T) {
b, err := unix.Mmap(-1, 0, unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE)
if err != nil {
t.Fatalf("Mmap: %v", err)
}
if err := unix.Munmap(b); err != nil {
t.Fatalf("Munmap: %v", err)
}
}
func mmap(name string) ([]byte, error) {
file, err := os.Open(name)
if err != nil {
return nil, err
}
defer file.Close()
stat, err := file.Stat()
if err != nil {
return nil, err
}
return unix.Mmap(int(file.Fd()), 0, int(stat.Size()), unix.PROT_EXEC|unix.PROT_WRITE|unix.PROT_READ, unix.MAP_PRIVATE)
}
func mmap(f *os.File, offset int64, length int) ([]byte, error) {
mmap, err := unix.Mmap(int(f.Fd()), 0, length, syscall.PROT_READ, syscall.MAP_SHARED)
if err != nil {
return nil, err
}
if err := unix.Madvise(mmap, syscall.MADV_RANDOM); err != nil {
return nil, err
}
return mmap, nil
}
// mmap the given file, get the mincore vector, then
// return it as an []bool
func FileMincore(f *os.File, size int64) ([]bool, error) {
//skip could not mmap error when the file size is 0
if int(size) == 0 {
return nil, nil
}
// mmap is a []byte
mmap, err := unix.Mmap(int(f.Fd()), 0, int(size), unix.PROT_NONE, unix.MAP_SHARED)
if err != nil {
return nil, fmt.Errorf("could not mmap: %v", err)
}
// TODO: check for MAP_FAILED which is ((void *) -1)
// but maybe unnecessary since it looks like errno is always set when MAP_FAILED
// one byte per page, only LSB is used, remainder is reserved and clear
vecsz := (size + int64(os.Getpagesize()) - 1) / int64(os.Getpagesize())
vec := make([]byte, vecsz)
// get all of the arguments to the mincore syscall converted to uintptr
mmap_ptr := uintptr(unsafe.Pointer(&mmap[0]))
size_ptr := uintptr(size)
vec_ptr := uintptr(unsafe.Pointer(&vec[0]))
// use Go's ASM to submit directly to the kernel, no C wrapper needed
// mincore(2): int mincore(void *addr, size_t length, unsigned char *vec);
// 0 on success, takes the pointer to the mmap, a size, which is the
// size that came from f.Stat(), and the vector, which is a pointer
// to the memory behind an []byte
// this writes a snapshot of the data into vec which a list of 8-bit flags
// with the LSB set if the page in that position is currently in VFS cache
ret, _, err := unix.Syscall(unix.SYS_MINCORE, mmap_ptr, size_ptr, vec_ptr)
if ret != 0 {
return nil, fmt.Errorf("syscall SYS_MINCORE failed: %v", err)
}
defer unix.Munmap(mmap)
mc := make([]bool, vecsz)
// there is no bitshift only bool
for i, b := range vec {
if b%2 == 1 {
mc[i] = true
} else {
mc[i] = false
}
}
return mc, nil
}
// mmap memory maps a DB's data file.
func mmap(db *DB, sz int) error {
// Map the data file to memory.
b, err := unix.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED|db.MmapFlags)
if err != nil {
return err
}
// Advise the kernel that the mmap is accessed randomly.
if err := unix.Madvise(b, syscall.MADV_RANDOM); err != nil {
return fmt.Errorf("madvise: %s", err)
}
// Save the original byte slice and convert to a byte array pointer.
db.dataref = b
db.data = (*[maxMapSize]byte)(unsafe.Pointer(&b[0]))
db.datasz = sz
return nil
}
func mmap(fd int, length int) (data []byte, err error) {
return unix.Mmap(fd, 0, length, syscall.PROT_READ, syscall.MAP_SHARED)
}
func (m *mmap) mapFile() error {
var err error
m.buf, err = unix.Mmap(int(m.src.Fd()), 0, int(m.sz), unix.PROT_READ, unix.MAP_SHARED)
return err
}
