使用syscall.EpollEvent时事件轮询模型高并发崩溃求助

结构体定义差异 #

Go标准库syscall/ztypes_linux_amd64.go中的EpollEvent定义：

type EpollEvent struct {                                                                             
    Events uint32                                                                                    
    Fd     int32                                                                                     
    Pad    int32                                                                                     
} 

Linux系统调用epoll_ctl的C语言原生定义：

typedef union epoll_data {
   void        *ptr;
   int          fd;
   uint32_t     u32;
   uint64_t     u64;
} epoll_data_t;

struct epoll_event {
   uint32_t     events;      /* Epoll events */
   epoll_data_t data;        /* User data variable */
};

自定义指针复用逻辑 #

尝试通过unsafe.Pointer将syscall.EpollEvent.Fd后的内存区域当作epoll_data_t.ptr使用，代码如下：

type evData struct {
    fd        int
    evHandler EvHandler
}
ev := syscall.EpollEvent{
    Events: syscall.EPOLLIN,
}
*(**evData)(unsafe.Pointer(&ev.Fd)) = ed

崩溃现象 #

低并发请求无异常，并发量提升后触发内存段错误：

unexpected fault address 0x1018
fatal error: fault
[signal SIGSEGV: segmentation violation code=0x1 addr=0x1018 pc=0x473dc7]

goroutine 1 [running, locked to thread]:
runtime.throw({0x48c50d?, 0xc00004bda0?})
    /usr/local/go/src/runtime/panic.go:1047 +0x5d fp=0xc00004bd50 sp=0xc00004bd20 pc=0x43213d
runtime.sigpanic()
    /usr/local/go/src/runtime/signal_unix.go:851 +0x28a fp=0xc00004bdb0 sp=0xc00004bd50 pc=0x44674a
github.com/shaovie/goev.(*evPoll).poll(0xc00005a040, 0x0, 0x0)
    /root/go/src/github.com/shaovie/goev/epoll.go:202 +0x3e7 fp=0xc00004be68 sp=0xc00004bdb0 pc=0x473dc7
github.com/shaovie/goev.(*evPoll).run(0xc00005a040)

自定义epoll实现代码 #

var (
    _zero uintptr
)
type epollEvent struct {
    Events uint32
    Fd    [8]byte
}
func errnoErr(e syscall.Errno) error {
    switch e {
    case 0:
        return nil
    case unix.EAGAIN:
        return syscall.EAGAIN
    case unix.EINVAL:
        return syscall.EINVAL
    case unix.ENOENT:
        return syscall.ENOENT
    }
    return e
}
func epollWait(epfd int, events []epollEvent, msec int) (n int, err error) {
    var _p0 unsafe.Pointer
    if len(events) > 0 {
        _p0 = unsafe.Pointer(&events[0])
    } else {
        _p0 = unsafe.Pointer(&_zero)
    }

    r0, _, e1 := unix.Syscall6(unix.SYS_EPOLL_WAIT, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), 0, 0)
    n = int(r0)
    if e1 != 0 {
        err = errnoErr(e1)
    }

    return
}
func epollCtl(epfd int, op int, fd int, event *epollEvent) (err error) {
    _, _, e1 := unix.RawSyscall6(unix.SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
    if e1 != 0 {
        err = errnoErr(e1)
    }

    return
}

核心原因 #

1. 内存布局不匹配
   Go的syscall.EpollEvent中Fd+Pad虽然总长度为8字节，看似对应C的epoll_data_t，但Go的结构体对齐规则和类型转换逻辑会导致指针访问偏移错误。并发场景下，这种内存访问误差会被放大，触发非法地址访问。

2. 悬空指针被GC回收
   存入epoll事件的evData指针没有被强引用，Go的GC会在并发时回收该内存，导致后续取出的指针指向已释放的无效内存，触发段错误。

3. 自定义epollEvent解析错误
   用[8]byte存储epoll_data_t后，指针转换逻辑错误，会得到如0x1018这类非Go堆内存的无效地址，并发处理时频繁触发错误。

修复方案 #

1. 定义与C完全匹配的结构体 #

直接对齐C的内存布局，避免对齐问题：

type EpollEvent struct {
    Events uint32
    Data   uintptr // 完美对应epoll_data_t的8字节union
}

2. 正确存储与解析指针 #

• 存储指针到epoll事件：

ed := &evData{fd: fd, evHandler: handler}
// 存入全局map保留强引用，防止GC回收
eventMap[fd] = ed
ev := EpollEvent{
    Events: syscall.EPOLLIN | syscall.EPOLLRDHUP,
    Data:   uintptr(unsafe.Pointer(ed)),
}

• 从epoll事件中解析指针：

ed := (*evData)(unsafe.Pointer(event.Data))
// 处理事件逻辑

3. 防止GC回收关键内存 #

将evData实例存入长期存在的容器（如全局map[int]*evData），在fd关闭时再从容器中删除，确保GC不会回收正在使用的内存。

4. 排查并发访问竞争 #

确保事件处理逻辑中对evData的访问无数据竞争，可通过锁保护共享资源，或设计无锁的事件处理流程。

内容的提问来源于stack exchange，提问作者alfiver