Calling mremap in Go doesn't work, but gives no error

Question

I'm trying to mremap a file from Go, but the size of the file doesn't seem to be changing, despite the returned errno of 0. This results in a segfault when I try to access the mapped memory.

I've included the code below. The implementation is similar to the mmap implementation in the sys package, so I'm not sure what's going wrong here:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "reflect"
    "unsafe"

    "golang.org/x/sys/unix"
)

// taken from <https://github.com/torvalds/linux/blob/f8394f232b1eab649ce2df5c5f15b0e528c92091/include/uapi/linux/mman.h#L8>
const (
    MREMAP_MAYMOVE = 0x1
    // MREMAP_FIXED     = 0x2
    // MREMAP_DONTUNMAP = 0x4
)

func mremap(data []byte, size int) ([]byte, error) {
    header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
    mmapAddr, mmapSize, errno := unix.Syscall6(
        unix.SYS_MREMAP,
        header.Data,
        uintptr(header.Len),
        uintptr(size),
        uintptr(MREMAP_MAYMOVE),
        0,
        0,
    )
    if errno != 0 {
        return nil, fmt.Errorf("mremap failed with errno: %s", errno)
    }
    if mmapSize != uintptr(size) {
        return nil, fmt.Errorf("mremap size mismatch: requested: %d got: %d", size, mmapSize)
    }

    header.Data = mmapAddr
    header.Cap = size
    header.Len = size
    return data, nil
}

func main() {
    log.SetFlags(log.LstdFlags | log.Lshortfile)
    const mmPath = "/tmp/mm_test"

    // create a file for mmap with 1 byte of data.
    // this should take up 1 block on disk (4096 bytes).
    err := ioutil.WriteFile(mmPath, []byte{0x1}, 0755)
    if err != nil {
        log.Fatal(err)
    }

    // open and stat the file.
    file, err := os.OpenFile(mmPath, os.O_RDWR, 0)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    stat, err := file.Stat()
    if err != nil {
        log.Fatal(err)
    }

    // mmap the file and print the contents.
    // this should print only one byte of data.
    data, err := unix.Mmap(int(file.Fd()), 0, int(stat.Size()), unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("mmap data: %+v\n", data)

    // mremap the file to a size of 2 blocks.
    data, err = mremap(data, 2*4096)
    if err != nil {
        log.Fatal(err)
    }

    // access the mremapped data.
    fmt.Println(data[:4096]) // accessing the first block works.
    fmt.Println(data[:4097]) // accessing the second block fails with `SIGBUS: unexpected fault address`.
}

I tried looking for other Go code that uses mremap, but I can't seem to find any. I would appreciate any input!

Answer 1

As @kostix mentioned in the comments, mmap is being used to map a regular file into memory. The reason that accessing the buffer results in a segfault is that the underlying file itself is not large enough. The solution is to truncate the file to the desired length before calling mremap:

if err := file.Truncate(2*4096); err != nil {
  log.Fatal(err)
}
data, err = mremap(data, 2*4096)