内存缓冲区映射到文件描述符：原理、限制与实践

func ScanBytesAttempt(b []byte) error {
  size := C.size_t(len(b))
  path := C.CString("/bytes")
  fd := C.shm_open(path, C.O_RDWR|C.O_CREAT, C.mode_t(0600))
  if fd == -1 {
    return fmt.Errorf("shm_open failed")
  }
  defer C.shm_unlink(path)
  defer C.close(fd)

  res := C.ftruncate(fd, C.__off_t(size))
  if res != 0 {
    return fmt.Errorf("could not allocate shared memory region (%d)", res)
  }

  // 尝试将现有缓冲区的地址固定映射到共享内存区域
  var addr = unsafe.Pointer(&b[0])
  mappedAddr := C.mmap(addr, size, C.PROT_READ|C.PROT_WRITE, C.MAP_SHARED|C.MAP_FIXED, fd, 0)
  if mappedAddr == C.MAP_FAILED {
    return fmt.Errorf("mmap failed with MAP_FIXED")
  }
  defer C.munmap(mappedAddr, size)

  // 此时如果不对fd进行写入，通过fd读取的内容将是空的
  // 如果写入，则会发生数据拷贝
  // _, err := syscall.Write(int(fd), b)

  // doSomethingWith(fd)
  return nil
}

package main

/*
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h> // For memcpy

// A dummy function to simulate using a file descriptor
int doSomethingWith(int fd) {
    struct stat st;
    if (fstat(fd, &st) == -1) {
        perror("fstat failed");
        return -1;
    }
    printf("File descriptor %d: size=%lld bytes\n", fd, (long long)st.st_size);

    // Optionally read some data
    char buffer[10];
    ssize_t bytesRead = pread(fd, buffer, sizeof(buffer) - 1, 0);
    if (bytesRead > 0) {
        buffer[bytesRead] = '\0';
        printf("Data read from fd: '%s'\n", buffer);
    } else if (bytesRead == -1) {
        perror("pread failed");
    }
    return 0;
}
*/
import "C"
import (
    "fmt"
    "syscall"
    "unsafe"
)

// MapBufferToFileDescriptor 将Go字节切片的内容复制到共享内存，并返回其文件描述符
func MapBufferToFileDescriptor(b []byte) (int, error) {
    size := C.size_t(len(b))
    // 确保路径唯一性，这里简单使用固定路径，实际应用中应生成唯一路径
    path := C.CString("/my_shared_bytes_region") 
    defer C.free(unsafe.Pointer(path)) // 释放C字符串内存

    // 1. 创建共享内存对象
    // O_EXCL 确保如果文件已存在则失败，避免冲突
    // O_CREAT 如果文件不存在则创建
    // O_RDWR 读写权限
    fd := C.shm_open(path, C.O_RDWR|C.O_CREAT|C.O_EXCL, C.mode_t(0600))
    if fd == -1 {
        return -1, fmt.Errorf("shm_open failed: %s", syscall.Errno(C.int(fd)))
    }
    // shm_unlink 应该在不再需要共享内存时调用，通常在程序退出或FD不再使用后。
    // 这里为了简化示例，放在defer中，但实际生产环境需考虑FD的生命周期。
    defer C.shm_unlink(path) 
    // 关闭文件描述符
    defer C.close(fd)

    // 2. 设置共享内存对象的大小
    res := C.ftruncate(fd, C.__off_t(size))
    if res != 0 {
        return -1, fmt.Errorf("ftruncate failed for shared memory (%d): %s", res, syscall.Errno(res))
    }

    // 3. 将Go切片内容写入共享内存
    // 最直接的方式是使用syscall.Write
    n, err := syscall.Write(int(fd), b)
    if err != nil {
        return -1, fmt.Errorf("failed to write buffer to shared memory: %w", err)
    }
    if n != len(b) {
        return -1, fmt.Errorf("incomplete write to shared memory: wrote %d of %d bytes", n, len(b))
    }

    // 另一种写入方式：mmap共享内存，然后使用memcpy
    /*
    // 3.1 mmap共享内存到进程地址空间
    mappedAddr := C.mmap(nil, size, C.PROT_READ|C.PROT_WRITE, C.MAP_SHARED, fd, 0)
    if mappedAddr == C.MAP_FAILED {
        return -1, fmt.Errorf("mmap shared memory failed: %s", syscall.Errno(C.int(intptr(mappedAddr))))
    }
    defer C.munmap(mappedAddr, size)

    // 3.2 将Go切片内容拷贝到映射区域
    C.memcpy(mappedAddr, unsafe.Pointer(&b[0]), size)
    */

    // 返回文件描述符。注意：这里返回的fd在defer中会被关闭，
    // 实际应用中需要更复杂的生命周期管理，例如将fd返回后，
    // 由调用者负责关闭和unlink。
    // 为了示例的完整性，我们复制fd并返回，让调用者持有新的fd。
    // 实际生产中，可能需要一个更高级的封装，或者直接将fd传递给C函数。
    // 这里直接返回fd，并假设调用者会立即使用，且后续C.close/C.shm_unlink会发生。
    return int(fd), nil
}

func main() {
    data := []byte("Hello, shared memory file descriptor!")
    fd, err := MapBufferToFileDescriptor(data)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Successfully created shared memory with FD: %d\n", fd)
    // 现在可以使用这个fd进行操作
    C.doSomethingWith(C.int(fd))

    // 在实际应用中，这里可能会将fd传递给一个需要文件描述符的库函数
    // ...

    // 由于defer C.close(fd)和C.shm_unlink(path)在MapBufferToFileDescriptor函数返回时执行，
    // 如果需要fd在MapBufferToFileDescriptor返回后仍有效，
    // 则需要调整资源管理策略，例如：
    // 1. MapBufferToFileDescriptor不defer close和unlink，由调用者负责。
    // 2. 将fd复制一份（dup），返回复制的fd，原始fd在函数内关闭。
    // 为了示例简洁，我们假设doSomethingWith是同步且快速完成的。
    fmt.Println("Shared memory operations completed.")
}