libgo/go/runtime/netpoll_epoll.go

   1 // Copyright 2013 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build linux
   6
   7 package runtime
   8
   9 import "unsafe"
  10
  11 //extern epoll_create
  12 func epollcreate(size int32) int32
  13
  14 //extern epoll_create1
  15 func epollcreate1(flags int32) int32
  16
  17 //go:noescape
  18 //extern epoll_ctl
  19 func epollctl(epfd, op, fd int32, ev *epollevent) int32
  20
  21 //go:noescape
  22 //extern epoll_wait
  23 func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32
  24
  25 //extern __go_fcntl_uintptr
  26 func fcntlUintptr(fd, cmd, arg uintptr) (uintptr, uintptr)
  27
  28 func closeonexec(fd int32) {
  29         fcntlUintptr(uintptr(fd), _F_SETFD, _FD_CLOEXEC)
  30 }
  31
  32 var (
  33         epfd int32 = -1 // epoll descriptor
  34 )
  35
  36 func netpollinit() {
  37         epfd = epollcreate1(_EPOLL_CLOEXEC)
  38         if epfd >= 0 {
  39                 return
  40         }
  41         epfd = epollcreate(1024)
  42         if epfd >= 0 {
  43                 closeonexec(epfd)
  44                 return
  45         }
  46         println("netpollinit: failed to create epoll descriptor", errno())
  47         throw("netpollinit: failed to create descriptor")
  48 }
  49
  50 func netpolldescriptor() uintptr {
  51         return uintptr(epfd)
  52 }
  53
  54 func netpollopen(fd uintptr, pd *pollDesc) int32 {
  55         var ev epollevent
  56         ev.events = _EPOLLIN | _EPOLLOUT | _EPOLLRDHUP | _EPOLLETpos
  57         *(**pollDesc)(unsafe.Pointer(&ev.data)) = pd
  58         if epollctl(epfd, _EPOLL_CTL_ADD, int32(fd), &ev) < 0 {
  59                 return int32(errno())
  60         }
  61         return 0
  62 }
  63
  64 func netpollclose(fd uintptr) int32 {
  65         var ev epollevent
  66         if epollctl(epfd, _EPOLL_CTL_DEL, int32(fd), &ev) < 0 {
  67                 return int32(errno())
  68         }
  69         return 0
  70 }
  71
  72 func netpollarm(pd *pollDesc, mode int) {
  73         throw("runtime: unused")
  74 }
  75
  76 // polls for ready network connections
  77 // returns list of goroutines that become runnable
  78 func netpoll(block bool) *g {
  79         if epfd == -1 {
  80                 return nil
  81         }
  82         waitms := int32(-1)
  83         if !block {
  84                 waitms = 0
  85         }
  86         var events [128]epollevent
  87 retry:
  88         n := epollwait(epfd, &events[0], int32(len(events)), waitms)
  89         if n < 0 {
  90                 e := errno()
  91                 if e != _EINTR {
  92                         println("runtime: epollwait on fd", epfd, "failed with", e)
  93                         throw("runtime: netpoll failed")
  94                 }
  95                 goto retry
  96         }
  97         var gp guintptr
  98         for i := int32(0); i < n; i++ {
  99                 ev := &events[i]
 100                 if ev.events == 0 {
 101                         continue
 102                 }
 103                 var mode int32
 104                 if ev.events&(_EPOLLIN|_EPOLLRDHUP|_EPOLLHUP|_EPOLLERR) != 0 {
 105                         mode += 'r'
 106                 }
 107                 if ev.events&(_EPOLLOUT|_EPOLLHUP|_EPOLLERR) != 0 {
 108                         mode += 'w'
 109                 }
 110                 if mode != 0 {
 111                         pd := *(**pollDesc)(unsafe.Pointer(&ev.data))
 112
 113                         netpollready(&gp, pd, mode)
 114                 }
 115         }
 116         if block && gp == 0 {
 117                 goto retry
 118         }
 119         return gp.ptr()
 120 }