← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/net/fd_darwin.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/net/fd_darwin.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 kqueue/kevent.
 
6
 
 
7
package net
 
8
 
 
9
import (
 
10
        "os"
 
11
        "syscall"
 
12
)
 
13
 
 
14
type pollster struct {
 
15
        kq       int
 
16
        eventbuf [10]syscall.Kevent_t
 
17
        events   []syscall.Kevent_t
 
18
}
 
19
 
 
20
func newpollster() (p *pollster, err os.Error) {
 
21
        p = new(pollster)
 
22
        var e int
 
23
        if p.kq, e = syscall.Kqueue(); e != 0 {
 
24
                return nil, os.NewSyscallError("kqueue", e)
 
25
        }
 
26
        p.events = p.eventbuf[0:0]
 
27
        return p, nil
 
28
}
 
29
 
 
30
func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
 
31
        var kmode int
 
32
        if mode == 'r' {
 
33
                kmode = syscall.EVFILT_READ
 
34
        } else {
 
35
                kmode = syscall.EVFILT_WRITE
 
36
        }
 
37
        var events [1]syscall.Kevent_t
 
38
        ev := &events[0]
 
39
        // EV_ADD - add event to kqueue list
 
40
        // EV_RECEIPT - generate fake EV_ERROR as result of add,
 
41
        //      rather than waiting for real event
 
42
        // EV_ONESHOT - delete the event the first time it triggers
 
43
        flags := syscall.EV_ADD | syscall.EV_RECEIPT
 
44
        if !repeat {
 
45
                flags |= syscall.EV_ONESHOT
 
46
        }
 
47
        syscall.SetKevent(ev, fd, kmode, flags)
 
48
 
 
49
        n, e := syscall.Kevent(p.kq, events[0:], events[0:], nil)
 
50
        if e != 0 {
 
51
                return os.NewSyscallError("kevent", e)
 
52
        }
 
53
        if n != 1 || (ev.Flags&syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
 
54
                return os.ErrorString("kqueue phase error")
 
55
        }
 
56
        if ev.Data != 0 {
 
57
                return os.Errno(int(ev.Data))
 
58
        }
 
59
        return nil
 
60
}
 
61
 
 
62
func (p *pollster) DelFD(fd int, mode int) {
 
63
        var kmode int
 
64
        if mode == 'r' {
 
65
                kmode = syscall.EVFILT_READ
 
66
        } else {
 
67
                kmode = syscall.EVFILT_WRITE
 
68
        }
 
69
        var events [1]syscall.Kevent_t
 
70
        ev := &events[0]
 
71
        // EV_DELETE - delete event from kqueue list
 
72
        // EV_RECEIPT - generate fake EV_ERROR as result of add,
 
73
        //      rather than waiting for real event
 
74
        syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE|syscall.EV_RECEIPT)
 
75
        syscall.Kevent(p.kq, events[0:], events[0:], nil)
 
76
}
 
77
 
 
78
func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
 
79
        var t *syscall.Timespec
 
80
        for len(p.events) == 0 {
 
81
                if nsec > 0 {
 
82
                        if t == nil {
 
83
                                t = new(syscall.Timespec)
 
84
                        }
 
85
                        *t = syscall.NsecToTimespec(nsec)
 
86
                }
 
87
                nn, e := syscall.Kevent(p.kq, nil, p.eventbuf[0:], t)
 
88
                if e != 0 {
 
89
                        if e == syscall.EINTR {
 
90
                                continue
 
91
                        }
 
92
                        return -1, 0, os.NewSyscallError("kevent", e)
 
93
                }
 
94
                if nn == 0 {
 
95
                        return -1, 0, nil
 
96
                }
 
97
                p.events = p.eventbuf[0:nn]
 
98
        }
 
99
        ev := &p.events[0]
 
100
        p.events = p.events[1:]
 
101
        fd = int(ev.Ident)
 
102
        if ev.Filter == syscall.EVFILT_READ {
 
103
                mode = 'r'
 
104
        } else {
 
105
                mode = 'w'
 
106
        }
 
107
        return fd, mode, nil
 
108
}
 
109
 
 
110
func (p *pollster) Close() os.Error { return os.NewSyscallError("close", syscall.Close(p.kq)) }