|
66
|
1 // Copyright 2020 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 //go:build zos && s390x
|
|
|
6 // +build zos,s390x
|
|
|
7
|
|
|
8 package unix
|
|
|
9
|
|
|
10 import (
|
|
|
11 "sync"
|
|
|
12 )
|
|
|
13
|
|
|
14 // This file simulates epoll on z/OS using poll.
|
|
|
15
|
|
|
16 // Analogous to epoll_event on Linux.
|
|
|
17 // TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove?
|
|
|
18 type EpollEvent struct {
|
|
|
19 Events uint32
|
|
|
20 Fd int32
|
|
|
21 Pad int32
|
|
|
22 }
|
|
|
23
|
|
|
24 const (
|
|
|
25 EPOLLERR = 0x8
|
|
|
26 EPOLLHUP = 0x10
|
|
|
27 EPOLLIN = 0x1
|
|
|
28 EPOLLMSG = 0x400
|
|
|
29 EPOLLOUT = 0x4
|
|
|
30 EPOLLPRI = 0x2
|
|
|
31 EPOLLRDBAND = 0x80
|
|
|
32 EPOLLRDNORM = 0x40
|
|
|
33 EPOLLWRBAND = 0x200
|
|
|
34 EPOLLWRNORM = 0x100
|
|
|
35 EPOLL_CTL_ADD = 0x1
|
|
|
36 EPOLL_CTL_DEL = 0x2
|
|
|
37 EPOLL_CTL_MOD = 0x3
|
|
|
38 // The following constants are part of the epoll API, but represent
|
|
|
39 // currently unsupported functionality on z/OS.
|
|
|
40 // EPOLL_CLOEXEC = 0x80000
|
|
|
41 // EPOLLET = 0x80000000
|
|
|
42 // EPOLLONESHOT = 0x40000000
|
|
|
43 // EPOLLRDHUP = 0x2000 // Typically used with edge-triggered notis
|
|
|
44 // EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode
|
|
|
45 // EPOLLWAKEUP = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability
|
|
|
46 )
|
|
|
47
|
|
|
48 // TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL
|
|
|
49 // constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16).
|
|
|
50
|
|
|
51 // epToPollEvt converts epoll event field to poll equivalent.
|
|
|
52 // In epoll, Events is a 32-bit field, while poll uses 16 bits.
|
|
|
53 func epToPollEvt(events uint32) int16 {
|
|
|
54 var ep2p = map[uint32]int16{
|
|
|
55 EPOLLIN: POLLIN,
|
|
|
56 EPOLLOUT: POLLOUT,
|
|
|
57 EPOLLHUP: POLLHUP,
|
|
|
58 EPOLLPRI: POLLPRI,
|
|
|
59 EPOLLERR: POLLERR,
|
|
|
60 }
|
|
|
61
|
|
|
62 var pollEvts int16 = 0
|
|
|
63 for epEvt, pEvt := range ep2p {
|
|
|
64 if (events & epEvt) != 0 {
|
|
|
65 pollEvts |= pEvt
|
|
|
66 }
|
|
|
67 }
|
|
|
68
|
|
|
69 return pollEvts
|
|
|
70 }
|
|
|
71
|
|
|
72 // pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields.
|
|
|
73 func pToEpollEvt(revents int16) uint32 {
|
|
|
74 var p2ep = map[int16]uint32{
|
|
|
75 POLLIN: EPOLLIN,
|
|
|
76 POLLOUT: EPOLLOUT,
|
|
|
77 POLLHUP: EPOLLHUP,
|
|
|
78 POLLPRI: EPOLLPRI,
|
|
|
79 POLLERR: EPOLLERR,
|
|
|
80 }
|
|
|
81
|
|
|
82 var epollEvts uint32 = 0
|
|
|
83 for pEvt, epEvt := range p2ep {
|
|
|
84 if (revents & pEvt) != 0 {
|
|
|
85 epollEvts |= epEvt
|
|
|
86 }
|
|
|
87 }
|
|
|
88
|
|
|
89 return epollEvts
|
|
|
90 }
|
|
|
91
|
|
|
92 // Per-process epoll implementation.
|
|
|
93 type epollImpl struct {
|
|
|
94 mu sync.Mutex
|
|
|
95 epfd2ep map[int]*eventPoll
|
|
|
96 nextEpfd int
|
|
|
97 }
|
|
|
98
|
|
|
99 // eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances.
|
|
|
100 // On Linux, this is an in-kernel data structure accessed through a fd.
|
|
|
101 type eventPoll struct {
|
|
|
102 mu sync.Mutex
|
|
|
103 fds map[int]*EpollEvent
|
|
|
104 }
|
|
|
105
|
|
|
106 // epoll impl for this process.
|
|
|
107 var impl epollImpl = epollImpl{
|
|
|
108 epfd2ep: make(map[int]*eventPoll),
|
|
|
109 nextEpfd: 0,
|
|
|
110 }
|
|
|
111
|
|
|
112 func (e *epollImpl) epollcreate(size int) (epfd int, err error) {
|
|
|
113 e.mu.Lock()
|
|
|
114 defer e.mu.Unlock()
|
|
|
115 epfd = e.nextEpfd
|
|
|
116 e.nextEpfd++
|
|
|
117
|
|
|
118 e.epfd2ep[epfd] = &eventPoll{
|
|
|
119 fds: make(map[int]*EpollEvent),
|
|
|
120 }
|
|
|
121 return epfd, nil
|
|
|
122 }
|
|
|
123
|
|
|
124 func (e *epollImpl) epollcreate1(flag int) (fd int, err error) {
|
|
|
125 return e.epollcreate(4)
|
|
|
126 }
|
|
|
127
|
|
|
128 func (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) {
|
|
|
129 e.mu.Lock()
|
|
|
130 defer e.mu.Unlock()
|
|
|
131
|
|
|
132 ep, ok := e.epfd2ep[epfd]
|
|
|
133 if !ok {
|
|
|
134
|
|
|
135 return EBADF
|
|
|
136 }
|
|
|
137
|
|
|
138 switch op {
|
|
|
139 case EPOLL_CTL_ADD:
|
|
|
140 // TODO(neeilan): When we make epfds and fds disjoint, detect epoll
|
|
|
141 // loops here (instances watching each other) and return ELOOP.
|
|
|
142 if _, ok := ep.fds[fd]; ok {
|
|
|
143 return EEXIST
|
|
|
144 }
|
|
|
145 ep.fds[fd] = event
|
|
|
146 case EPOLL_CTL_MOD:
|
|
|
147 if _, ok := ep.fds[fd]; !ok {
|
|
|
148 return ENOENT
|
|
|
149 }
|
|
|
150 ep.fds[fd] = event
|
|
|
151 case EPOLL_CTL_DEL:
|
|
|
152 if _, ok := ep.fds[fd]; !ok {
|
|
|
153 return ENOENT
|
|
|
154 }
|
|
|
155 delete(ep.fds, fd)
|
|
|
156
|
|
|
157 }
|
|
|
158 return nil
|
|
|
159 }
|
|
|
160
|
|
|
161 // Must be called while holding ep.mu
|
|
|
162 func (ep *eventPoll) getFds() []int {
|
|
|
163 fds := make([]int, len(ep.fds))
|
|
|
164 for fd := range ep.fds {
|
|
|
165 fds = append(fds, fd)
|
|
|
166 }
|
|
|
167 return fds
|
|
|
168 }
|
|
|
169
|
|
|
170 func (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) {
|
|
|
171 e.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait
|
|
|
172 ep, ok := e.epfd2ep[epfd]
|
|
|
173
|
|
|
174 if !ok {
|
|
|
175 e.mu.Unlock()
|
|
|
176 return 0, EBADF
|
|
|
177 }
|
|
|
178
|
|
|
179 pollfds := make([]PollFd, 4)
|
|
|
180 for fd, epollevt := range ep.fds {
|
|
|
181 pollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)})
|
|
|
182 }
|
|
|
183 e.mu.Unlock()
|
|
|
184
|
|
|
185 n, err = Poll(pollfds, msec)
|
|
|
186 if err != nil {
|
|
|
187 return n, err
|
|
|
188 }
|
|
|
189
|
|
|
190 i := 0
|
|
|
191 for _, pFd := range pollfds {
|
|
|
192 if pFd.Revents != 0 {
|
|
|
193 events[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)}
|
|
|
194 i++
|
|
|
195 }
|
|
|
196
|
|
|
197 if i == n {
|
|
|
198 break
|
|
|
199 }
|
|
|
200 }
|
|
|
201
|
|
|
202 return n, nil
|
|
|
203 }
|
|
|
204
|
|
|
205 func EpollCreate(size int) (fd int, err error) {
|
|
|
206 return impl.epollcreate(size)
|
|
|
207 }
|
|
|
208
|
|
|
209 func EpollCreate1(flag int) (fd int, err error) {
|
|
|
210 return impl.epollcreate1(flag)
|
|
|
211 }
|
|
|
212
|
|
|
213 func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
|
|
|
214 return impl.epollctl(epfd, op, fd, event)
|
|
|
215 }
|
|
|
216
|
|
|
217 // Because EpollWait mutates events, the caller is expected to coordinate
|
|
|
218 // concurrent access if calling with the same epfd from multiple goroutines.
|
|
|
219 func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
|
|
|
220 return impl.epollwait(epfd, events, msec)
|
|
|
221 }
|
