Update to current version of Go library.

[pf3gnuchains/gcc-fork.git] / libgo / go / net / fd_linux.go

diff --git a/libgo/go/net/fd_linux.go b/libgo/go/net/fd_linux.go
index ef86cb1..69fbc02 100644 (file)
--- a/libgo/go/net/fd_linux.go
+++ b/libgo/go/net/fd_linux.go
@@ -20,7 +20,17 @@ type pollster struct {
        epfd int
 
        // Events we're already waiting for
+       // Must hold pollServer lock
        events map[int]uint32
+
+       // An event buffer for EpollWait.
+       // Used without a lock, may only be used by WaitFD.
+       waitEventBuf [10]syscall.EpollEvent
+       waitEvents   []syscall.EpollEvent
+
+       // An event buffer for EpollCtl, to avoid a malloc.
+       // Must hold pollServer lock.
+       ctlEvent syscall.EpollEvent
 }
 
 func newpollster() (p *pollster, err os.Error) {
@@ -29,7 +39,7 @@ func newpollster() (p *pollster, err os.Error) {
 
        // The arg to epoll_create is a hint to the kernel
        // about the number of FDs we will care about.
-       // We don't know.
+       // We don't know, and since 2.6.8 the kernel ignores it anyhow.
        if p.epfd, e = syscall.EpollCreate(16); e != 0 {
                return nil, os.NewSyscallError("epoll_create", e)
        }
@@ -38,17 +48,18 @@ func newpollster() (p *pollster, err os.Error) {
 }
 
 func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
-       var ev syscall.EpollEvent
+       // pollServer is locked.
+
        var already bool
-       ev.Fd = int32(fd)
-       ev.Events, already = p.events[fd]
+       p.ctlEvent.Fd = int32(fd)
+       p.ctlEvent.Events, already = p.events[fd]
        if !repeat {
-               ev.Events |= syscall.EPOLLONESHOT
+               p.ctlEvent.Events |= syscall.EPOLLONESHOT
        }
        if mode == 'r' {
-               ev.Events |= readFlags
+               p.ctlEvent.Events |= readFlags
        } else {
-               ev.Events |= writeFlags
+               p.ctlEvent.Events |= writeFlags
        }
 
        var op int
@@ -57,14 +68,16 @@ func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
        } else {
                op = syscall.EPOLL_CTL_ADD
        }
-       if e := syscall.EpollCtl(p.epfd, op, fd, &ev); e != 0 {
+       if e := syscall.EpollCtl(p.epfd, op, fd, &p.ctlEvent); e != 0 {
                return os.NewSyscallError("epoll_ctl", e)
        }
-       p.events[fd] = ev.Events
+       p.events[fd] = p.ctlEvent.Events
        return nil
 }
 
 func (p *pollster) StopWaiting(fd int, bits uint) {
+       // pollServer is locked.
+
        events, already := p.events[fd]
        if !already {
                print("Epoll unexpected fd=", fd, "\n")
@@ -82,10 +95,9 @@ func (p *pollster) StopWaiting(fd int, bits uint) {
        // event in the kernel.  Otherwise, delete it.
        events &= ^uint32(bits)
        if int32(events)&^syscall.EPOLLONESHOT != 0 {
-               var ev syscall.EpollEvent
-               ev.Fd = int32(fd)
-               ev.Events = events
-               if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &ev); e != 0 {
+               p.ctlEvent.Fd = int32(fd)
+               p.ctlEvent.Events = events
+               if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &p.ctlEvent); e != 0 {
                        print("Epoll modify fd=", fd, ": ", os.Errno(e).String(), "\n")
                }
                p.events[fd] = events
@@ -98,6 +110,8 @@ func (p *pollster) StopWaiting(fd int, bits uint) {
 }
 
 func (p *pollster) DelFD(fd int, mode int) {
+       // pollServer is locked.
+
        if mode == 'r' {
                p.StopWaiting(fd, readFlags)
        } else {
@@ -105,24 +119,32 @@ func (p *pollster) DelFD(fd int, mode int) {
        }
 }
 
-func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
-       // Get an event.
-       var evarray [1]syscall.EpollEvent
-       ev := &evarray[0]
-       var msec int = -1
-       if nsec > 0 {
-               msec = int((nsec + 1e6 - 1) / 1e6)
-       }
-       n, e := syscall.EpollWait(p.epfd, evarray[0:], msec)
-       for e == syscall.EAGAIN || e == syscall.EINTR {
-               n, e = syscall.EpollWait(p.epfd, evarray[0:], msec)
-       }
-       if e != 0 {
-               return -1, 0, os.NewSyscallError("epoll_wait", e)
-       }
-       if n == 0 {
-               return -1, 0, nil
+func (p *pollster) WaitFD(s *pollServer, nsec int64) (fd int, mode int, err os.Error) {
+       for len(p.waitEvents) == 0 {
+               var msec int = -1
+               if nsec > 0 {
+                       msec = int((nsec + 1e6 - 1) / 1e6)
+               }
+
+               s.Unlock()
+               n, e := syscall.EpollWait(p.epfd, p.waitEventBuf[0:], msec)
+               s.Lock()
+
+               if e != 0 {
+                       if e == syscall.EAGAIN || e == syscall.EINTR {
+                               continue
+                       }
+                       return -1, 0, os.NewSyscallError("epoll_wait", e)
+               }
+               if n == 0 {
+                       return -1, 0, nil
+               }
+               p.waitEvents = p.waitEventBuf[0:n]
        }
+
+       ev := &p.waitEvents[0]
+       p.waitEvents = p.waitEvents[1:]
+
        fd = int(ev.Fd)
 
        if ev.Events&writeFlags != 0 {