内存映射现有缓冲区到文件描述符的挑战与实践

package main

/*
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h> // For perror

// Define __off_t if not already defined (common in some Cgo setups)
#ifndef __off_t
typedef long __off_t;
#endif

// A dummy function to simulate doing something with a file descriptor
extern int doSomethingWith(int fd);
*/
import "C"
import (
    "fmt"
    "os"
    "syscall"
    "unsafe"
)

// doSomethingWith is a placeholder for actual FD operations
// In a real scenario, this would be a C function that takes an int fd
// For demonstration, we'll just stat the fd.
//export doSomethingWith
func doSomethingWith(fd C.int) C.int {
    var stat C.struct_stat
    ret, err := C.fstat(fd, &stat)
    if ret != 0 {
        fmt.Printf("fstat failed: %v\n", syscall.Errno(ret))
        return C.int(-1)
    }
    fmt.Printf("Successfully fstat'ed FD %d. Size: %d bytes\n", fd, stat.st_size)
    return C.int(0)
}

// ScanBytes 将一个字节切片的内容复制到共享内存区域，并返回一个文件描述符。
func ScanBytes(b []byte) error {
    size := C.size_t(len(b))
    // 使用一个唯一的路径名，通常在/dev/shm下创建
    // 注意：shm_open需要一个以斜杠开头的名称，但不能包含额外的斜杠
    path := C.CString("/my_shared_bytes_region")
    defer C.free(unsafe.Pointer(path)) // 释放C字符串内存

    // 1. 创建或打开一个共享内存对象
    // O_RDWR: 读写模式
    // O_CREAT: 如果不存在则创建
    // O_EXCL: 如果存在则报错 (可选，这里不加是为了方便测试，实际生产中可能需要)
    // mode_t(0600): 权限设置为所有者读写
    fd := C.shm_open(path, C.O_RDWR|C.O_CREAT, C.mode_t(0600))
    if fd == C.int(-1) {
        return fmt.Errorf("shm_open failed: %s", C.GoString(C.strerror(C.errno)))
    }
    // 确保在函数退出时关闭并解除链接共享内存
    defer func() {
        C.close(fd)
        C.shm_unlink(path) // 解除链接，当所有引用关闭后，共享内存将被销毁
    }()

    // 2. 设置共享内存对象的大小
    res := C.ftruncate(fd, C.__off_t(size))
    if res != 0 {
        return fmt.Errorf("ftruncate failed to allocate shared memory region (%d): %s", res, C.GoString(C.strerror(C.errno)))
    }

    // 3. 将原始缓冲区内容写入共享内存区域
    // 注意：这里发生了数据复制
    written, err := syscall.Write(int(fd), b)
    if err != nil {
        return fmt.Errorf("could not write buffer to shared memory: %w", err)
    }
    if written != len(b) {
        return fmt.Errorf("incomplete write to shared memory: wrote %d of %d bytes", written, len(b))
    }

    // 现在 fd 包含了 b 的内容，可以传递给需要文件描述符的 C 函数
    // 例如，如果需要再次mmap这个共享内存到进程地址空间，可以这样做：
    // var mappedAddr unsafe.Pointer
    // mappedAddr = C.mmap(nil, size, C.PROT_READ, C.MAP_SHARED, fd, 0)
    // if mappedAddr == C.MAP_FAILED {
    //     return fmt.Errorf("mmap shared memory failed: %s", C.GoString(C.strerror(C.errno)))
    // }
    // defer C.munmap(mappedAddr, size)
    // fmt.Printf("Mapped shared memory at %p\n", mappedAddr)

    // 假设 doSomethingWith(fd) 是一个需要文件描述符的 C 函数
    ret := C.doSomethingWith(fd)
    if ret != 0 {
        return fmt.Errorf("doSomethingWith failed with return code %d", ret)
    }

    return nil
}

func main() {
    data := []byte("Hello, this is a test string for shared memory mapping!")
    err := ScanBytes(data)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("ScanBytes completed successfully.")

    emptyData := []byte{}
    err = ScanBytes(emptyData)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error with empty data: %v\n", err)
    } else {
        fmt.Println("ScanBytes completed successfully with empty data.")
    }
}