Initialize module and dependencies

vendor/golang.org/x/telemetry/internal/mmap/mmap.go

@@ -0,0 +1,36 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This package is a lightly modified version of the mmap code
+// in github.com/google/codesearch/index.
+
+// The mmap package provides an abstraction for memory mapping files
+// on different platforms.
+package mmap
+
+import (
+	"os"
+)
+
+// The backing file is never closed, so Data
+// remains valid for the lifetime of the process.
+type Data struct {
+	// TODO(pjw): might be better to define versions of Data
+	// for the 3 specializations
+	f    *os.File
+	Data []byte
+	// Some windows magic
+	Windows interface{}
+}
+
+// Mmap maps the given file into memory.
+// When remapping a file, pass the most recently returned Data.
+func Mmap(f *os.File) (*Data, error) {
+	return mmapFile(f)
+}
+
+// Munmap unmaps the given file from memory.
+func Munmap(d *Data) error {
+	return munmapFile(d)
+}

vendor/golang.org/x/telemetry/internal/mmap/mmap_other.go

@@ -0,0 +1,25 @@
+// Copyright 2022 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build (js && wasm) || wasip1 || plan9
+
+package mmap
+
+import (
+	"io"
+	"os"
+)
+
+// mmapFile on other systems doesn't mmap the file. It just reads everything.
+func mmapFile(f *os.File) (*Data, error) {
+	b, err := io.ReadAll(f)
+	if err != nil {
+		return nil, err
+	}
+	return &Data{f, b, nil}, nil
+}
+
+func munmapFile(_ *Data) error {
+	return nil
+}

vendor/golang.org/x/telemetry/internal/mmap/mmap_unix.go

@@ -0,0 +1,47 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build unix
+
+package mmap
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"syscall"
+)
+
+func mmapFile(f *os.File) (*Data, error) {
+	st, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+	size := st.Size()
+	pagesize := int64(os.Getpagesize())
+	if int64(int(size+(pagesize-1))) != size+(pagesize-1) {
+		return nil, fmt.Errorf("%s: too large for mmap", f.Name())
+	}
+	n := int(size)
+	if n == 0 {
+		return &Data{f, nil, nil}, nil
+	}
+	mmapLength := int(((size + pagesize - 1) / pagesize) * pagesize) // round up to page size
+	data, err := syscall.Mmap(int(f.Fd()), 0, mmapLength, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
+	if err != nil {
+		return nil, &fs.PathError{Op: "mmap", Path: f.Name(), Err: err}
+	}
+	return &Data{f, data[:n], nil}, nil
+}
+
+func munmapFile(d *Data) error {
+	if len(d.Data) == 0 {
+		return nil
+	}
+	err := syscall.Munmap(d.Data)
+	if err != nil {
+		return &fs.PathError{Op: "munmap", Path: d.f.Name(), Err: err}
+	}
+	return nil
+}

vendor/golang.org/x/telemetry/internal/mmap/mmap_windows.go

@@ -0,0 +1,52 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mmap
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+func mmapFile(f *os.File) (*Data, error) {
+	st, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+	size := st.Size()
+	if size == 0 {
+		return &Data{f, nil, nil}, nil
+	}
+	// set the min and max sizes to zero to map the whole file, as described in
+	// https://learn.microsoft.com/en-us/windows/win32/memory/creating-a-file-mapping-object#file-mapping-size
+	h, err := windows.CreateFileMapping(windows.Handle(f.Fd()), nil, syscall.PAGE_READWRITE, 0, 0, nil)
+	if err != nil {
+		return nil, fmt.Errorf("CreateFileMapping %s: %w", f.Name(), err)
+	}
+	// the mapping extends from zero to the end of the file mapping
+	// https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-mapviewoffile
+	addr, err := windows.MapViewOfFile(h, syscall.FILE_MAP_READ|syscall.FILE_MAP_WRITE, 0, 0, 0)
+	if err != nil {
+		return nil, fmt.Errorf("MapViewOfFile %s: %w", f.Name(), err)
+	}
+	// Note: previously, we called windows.VirtualQuery here to get the exact
+	// size of the memory mapped region, but VirtualQuery reported sizes smaller
+	// than the actual file size (hypothesis: VirtualQuery only reports pages in
+	// a certain state, and newly written pages may not be counted).
+	return &Data{f, unsafe.Slice((*byte)(unsafe.Pointer(addr)), size), h}, nil
+}
+
+func munmapFile(d *Data) error {
+	err := windows.UnmapViewOfFile(uintptr(unsafe.Pointer(&d.Data[0])))
+	x, ok := d.Windows.(windows.Handle)
+	if ok {
+		windows.CloseHandle(x)
+	}
+	d.f.Close()
+	return err
+}