libgo/go/net/fd_linux.go

   1 // Copyright 2009 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 // Waiting for FDs via epoll(7).
   6
   7 package net
   8
   9 import (
  10         "os"
  11         "syscall"
  12 )
  13
  14 const (
  15         readFlags  = syscall.EPOLLIN | syscall.EPOLLRDHUP
  16         writeFlags = syscall.EPOLLOUT
  17 )
  18
  19 type pollster struct {
  20         epfd int
  21
  22         // Events we're already waiting for
  23         // Must hold pollServer lock
  24         events map[int]uint32
  25
  26         // An event buffer for EpollWait.
  27         // Used without a lock, may only be used by WaitFD.
  28         waitEventBuf [10]syscall.EpollEvent
  29         waitEvents   []syscall.EpollEvent
  30
  31         // An event buffer for EpollCtl, to avoid a malloc.
  32         // Must hold pollServer lock.
  33         ctlEvent syscall.EpollEvent
  34 }
  35
  36 func newpollster() (p *pollster, err error) {
  37         p = new(pollster)
  38         if p.epfd, err = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC); err != nil {
  39                 if err != syscall.ENOSYS {
  40                         return nil, os.NewSyscallError("epoll_create1", err)
  41                 }
  42                 // The arg to epoll_create is a hint to the kernel
  43                 // about the number of FDs we will care about.
  44                 // We don't know, and since 2.6.8 the kernel ignores it anyhow.
  45                 if p.epfd, err = syscall.EpollCreate(16); err != nil {
  46                         return nil, os.NewSyscallError("epoll_create", err)
  47                 }
  48                 syscall.CloseOnExec(p.epfd)
  49         }
  50         p.events = make(map[int]uint32)
  51         return p, nil
  52 }
  53
  54 func (p *pollster) AddFD(fd int, mode int, repeat bool) (bool, error) {
  55         // pollServer is locked.
  56
  57         var already bool
  58         p.ctlEvent.Fd = int32(fd)
  59         p.ctlEvent.Events, already = p.events[fd]
  60         if !repeat {
  61                 p.ctlEvent.Events |= syscall.EPOLLONESHOT
  62         }
  63         if mode == 'r' {
  64                 p.ctlEvent.Events |= readFlags
  65         } else {
  66                 p.ctlEvent.Events |= writeFlags
  67         }
  68
  69         var op int
  70         if already {
  71                 op = syscall.EPOLL_CTL_MOD
  72         } else {
  73                 op = syscall.EPOLL_CTL_ADD
  74         }
  75         if err := syscall.EpollCtl(p.epfd, op, fd, &p.ctlEvent); err != nil {
  76                 return false, os.NewSyscallError("epoll_ctl", err)
  77         }
  78         p.events[fd] = p.ctlEvent.Events
  79         return false, nil
  80 }
  81
  82 func (p *pollster) StopWaiting(fd int, bits uint) {
  83         // pollServer is locked.
  84
  85         events, already := p.events[fd]
  86         if !already {
  87                 // The fd returned by the kernel may have been
  88                 // cancelled already; return silently.
  89                 return
  90         }
  91
  92         // If syscall.EPOLLONESHOT is not set, the wait
  93         // is a repeating wait, so don't change it.
  94         if events&syscall.EPOLLONESHOT == 0 {
  95                 return
  96         }
  97
  98         // Disable the given bits.
  99         // If we're still waiting for other events, modify the fd
 100         // event in the kernel.  Otherwise, delete it.
 101         events &= ^uint32(bits)
 102         if int32(events)&^syscall.EPOLLONESHOT != 0 {
 103                 p.ctlEvent.Fd = int32(fd)
 104                 p.ctlEvent.Events = events
 105                 if err := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &p.ctlEvent); err != nil {
 106                         print("Epoll modify fd=", fd, ": ", err.Error(), "\n")
 107                 }
 108                 p.events[fd] = events
 109         } else {
 110                 if err := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_DEL, fd, nil); err != nil {
 111                         print("Epoll delete fd=", fd, ": ", err.Error(), "\n")
 112                 }
 113                 delete(p.events, fd)
 114         }
 115 }
 116
 117 func (p *pollster) DelFD(fd int, mode int) {
 118         // pollServer is locked.
 119
 120         if mode == 'r' {
 121                 p.StopWaiting(fd, readFlags)
 122         } else {
 123                 p.StopWaiting(fd, writeFlags)
 124         }
 125
 126         // Discard any queued up events.
 127         i := 0
 128         for i < len(p.waitEvents) {
 129                 if fd == int(p.waitEvents[i].Fd) {
 130                         copy(p.waitEvents[i:], p.waitEvents[i+1:])
 131                         p.waitEvents = p.waitEvents[:len(p.waitEvents)-1]
 132                 } else {
 133                         i++
 134                 }
 135         }
 136 }
 137
 138 func (p *pollster) WaitFD(s *pollServer, nsec int64) (fd int, mode int, err error) {
 139         for len(p.waitEvents) == 0 {
 140                 var msec int = -1
 141                 if nsec > 0 {
 142                         msec = int((nsec + 1e6 - 1) / 1e6)
 143                 }
 144
 145                 s.Unlock()
 146                 n, err := syscall.EpollWait(p.epfd, p.waitEventBuf[0:], msec)
 147                 s.Lock()
 148
 149                 if err != nil {
 150                         if err == syscall.EAGAIN || err == syscall.EINTR {
 151                                 continue
 152                         }
 153                         return -1, 0, os.NewSyscallError("epoll_wait", err)
 154                 }
 155                 if n == 0 {
 156                         return -1, 0, nil
 157                 }
 158                 p.waitEvents = p.waitEventBuf[0:n]
 159         }
 160
 161         ev := &p.waitEvents[0]
 162         p.waitEvents = p.waitEvents[1:]
 163
 164         fd = int(ev.Fd)
 165
 166         if ev.Events&writeFlags != 0 {
 167                 p.StopWaiting(fd, writeFlags)
 168                 return fd, 'w', nil
 169         }
 170         if ev.Events&readFlags != 0 {
 171                 p.StopWaiting(fd, readFlags)
 172                 return fd, 'r', nil
 173         }
 174
 175         // Other events are error conditions - wake whoever is waiting.
 176         events, _ := p.events[fd]
 177         if events&writeFlags != 0 {
 178                 p.StopWaiting(fd, writeFlags)
 179                 return fd, 'w', nil
 180         }
 181         p.StopWaiting(fd, readFlags)
 182         return fd, 'r', nil
 183 }
 184
 185 func (p *pollster) Close() error {
 186         return os.NewSyscallError("close", syscall.Close(p.epfd))
 187 }