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
8package unix
9
10import (
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?
18type EpollEvent struct {
19 Events uint32
20 Fd int32
21 Pad int32
22}
23
24const (
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.
53func 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.
73func 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.
93type 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.
101type eventPoll struct {
102 mu sync.Mutex
103 fds map[int]*EpollEvent
104}
105
106// epoll impl for this process.
107var impl epollImpl = epollImpl{
108 epfd2ep: make(map[int]*eventPoll),
109 nextEpfd: 0,
110}
111
112func (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
124func (e *epollImpl) epollcreate1(flag int) (fd int, err error) {
125 return e.epollcreate(4)
126}
127
128func (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
162func (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
170func (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
205func EpollCreate(size int) (fd int, err error) {
206 return impl.epollcreate(size)
207}
208
209func EpollCreate1(flag int) (fd int, err error) {
210 return impl.epollcreate1(flag)
211}
212
213func 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.
219func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
220 return impl.epollwait(epfd, events, msec)
221}