// Init initializes the ring buffer with the given size.
 func (r *Ring) Init(size uintptr) (err error) {
 	if r.buffer != nil {
 		return fmt.Errorf("ring already initialized")
 	}
 
 	if pageSize&(pageSize-1) != 0 {
 		return fmt.Errorf("page size must be a power of 2")
 	}
 
 	if size%pageSize != 0 {
 		return fmt.Errorf("size must be a multiple of the page size")
 	}
 
 	file, err := unix.MemfdCreate("github.com/Jorropo/mmu-ring", unix.MFD_CLOEXEC) // name does nothing and just used for debug
 	if err != nil {
 		return fmt.Errorf("memfd_create: %w", err)
 	}
 	defer unix.Close(file) // linux will cleanup the files once the mappings are unmapped
 
 	if err := unix.Ftruncate(file, int64(size)); err != nil {
 		return fmt.Errorf("ftruncate: %w", err)
 	}
 	totalMappingSize := size * 2
 	if totalMappingSize < size {
 		return fmt.Errorf("size overflow when creating MMU-ring")
 	}
 
 	// temporary mapping to allocate twice the ring of virtual memory
-	orig, err := unix.MmapPtr(-1, 0, nil, totalMappingSize, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_ANONYMOUS|unix.MAP_NORESERVE|unix.MAP_PRIVATE)
+	orig, err := unix.MmapGcPtr(-1, 0, nil, totalMappingSize, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_ANONYMOUS|unix.MAP_NORESERVE|unix.MAP_PRIVATE)
 	if err != nil {
 		return fmt.Errorf("virtual mmap: %w", err)
 	}
 	defer func() {
 		if err != nil {
 			unix.MunmapPtr(orig, totalMappingSize)
 		}
 	}()
 
 	// replace the virtual reservation with the physical memory tail to head
-	_, err = unix.MmapPtr(file, 0, orig, size, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED|unix.MAP_FIXED)
+	_, err = unix.MmapThroughPtr(file, 0, orig, size, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED|unix.MAP_FIXED)
 	if err != nil {
 		return fmt.Errorf("first physical mmap: %w", err)
 	}
-	_, err = unix.MmapPtr(file, 0, unsafe.Add(orig, size), size, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED|unix.MAP_FIXED)
+	_, err = unix.MmapThroughPtr(file, 0, unsafe.Add(orig, size), size, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED|unix.MAP_FIXED)
 	if err != nil {
 		return fmt.Errorf("second physical mmap: %w", err)
 	}
 
 	*r = Ring{size: size, buffer: (*byte)(orig)}
 	return nil
 }
-
-// Close frees up the mmaped memory and must be manually called before the Ring is garbage collected.
-// Very important, any buffer returned by .Context or .Unused, or leaked from .Write or .Read will become invalid and point to who knows what and cannot be used.
-// If you *retain* theses buffers, you might need to set them to nil before calling Close.
-func (r *Ring) Close() error {
-	buf := r.buffer
-	if buf == nil {
-		return nil
-	}
-	r.buffer = nil
-	return unix.MunmapPtr(unsafe.Pointer(buf), r.size*2)
-}