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}
222