Make Nix builds work

1 files changed, 220 insertions, 0 deletions

diff --git a/vendor/golang.org/x/sys/unix/epoll_zos.go b/vendor/golang.org/x/sys/unix/epoll_zos.go
new file mode 100644
index 0000000..7753fdd
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/epoll_zos.go
@@ -0,0 +1,220 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build zos && s390x
+
+package unix
+
+import (
+        "sync"
+)
+
+// This file simulates epoll on z/OS using poll.
+
+// Analogous to epoll_event on Linux.
+// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove?
+type EpollEvent struct {
+        Events uint32
+        Fd     int32
+        Pad    int32
+}
+
+const (
+        EPOLLERR      = 0x8
+        EPOLLHUP      = 0x10
+        EPOLLIN       = 0x1
+        EPOLLMSG      = 0x400
+        EPOLLOUT      = 0x4
+        EPOLLPRI      = 0x2
+        EPOLLRDBAND   = 0x80
+        EPOLLRDNORM   = 0x40
+        EPOLLWRBAND   = 0x200
+        EPOLLWRNORM   = 0x100
+        EPOLL_CTL_ADD = 0x1
+        EPOLL_CTL_DEL = 0x2
+        EPOLL_CTL_MOD = 0x3
+        // The following constants are part of the epoll API, but represent
+        // currently unsupported functionality on z/OS.
+        // EPOLL_CLOEXEC  = 0x80000
+        // EPOLLET        = 0x80000000
+        // EPOLLONESHOT   = 0x40000000
+        // EPOLLRDHUP     = 0x2000     // Typically used with edge-triggered notis
+        // EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode
+        // EPOLLWAKEUP    = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability
+)
+
+// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL
+// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16).
+
+// epToPollEvt converts epoll event field to poll equivalent.
+// In epoll, Events is a 32-bit field, while poll uses 16 bits.
+func epToPollEvt(events uint32) int16 {
+        var ep2p = map[uint32]int16{
+                EPOLLIN:  POLLIN,
+                EPOLLOUT: POLLOUT,
+                EPOLLHUP: POLLHUP,
+                EPOLLPRI: POLLPRI,
+                EPOLLERR: POLLERR,
+        }
+
+        var pollEvts int16 = 0
+        for epEvt, pEvt := range ep2p {
+                if (events & epEvt) != 0 {
+                        pollEvts |= pEvt
+                }
+        }
+
+        return pollEvts
+}
+
+// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields.
+func pToEpollEvt(revents int16) uint32 {
+        var p2ep = map[int16]uint32{
+                POLLIN:  EPOLLIN,
+                POLLOUT: EPOLLOUT,
+                POLLHUP: EPOLLHUP,
+                POLLPRI: EPOLLPRI,
+                POLLERR: EPOLLERR,
+        }
+
+        var epollEvts uint32 = 0
+        for pEvt, epEvt := range p2ep {
+                if (revents & pEvt) != 0 {
+                        epollEvts |= epEvt
+                }
+        }
+
+        return epollEvts
+}
+
+// Per-process epoll implementation.
+type epollImpl struct {
+        mu       sync.Mutex
+        epfd2ep  map[int]*eventPoll
+        nextEpfd int
+}
+
+// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances.
+// On Linux, this is an in-kernel data structure accessed through a fd.
+type eventPoll struct {
+        mu  sync.Mutex
+        fds map[int]*EpollEvent
+}
+
+// epoll impl for this process.
+var impl epollImpl = epollImpl{
+        epfd2ep:  make(map[int]*eventPoll),
+        nextEpfd: 0,
+}
+
+func (e *epollImpl) epollcreate(size int) (epfd int, err error) {
+        e.mu.Lock()
+        defer e.mu.Unlock()
+        epfd = e.nextEpfd
+        e.nextEpfd++
+
+        e.epfd2ep[epfd] = &eventPoll{
+                fds: make(map[int]*EpollEvent),
+        }
+        return epfd, nil
+}
+
+func (e *epollImpl) epollcreate1(flag int) (fd int, err error) {
+        return e.epollcreate(4)
+}
+
+func (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) {
+        e.mu.Lock()
+        defer e.mu.Unlock()
+
+        ep, ok := e.epfd2ep[epfd]
+        if !ok {
+
+                return EBADF
+        }
+
+        switch op {
+        case EPOLL_CTL_ADD:
+                // TODO(neeilan): When we make epfds and fds disjoint, detect epoll
+                // loops here (instances watching each other) and return ELOOP.
+                if _, ok := ep.fds[fd]; ok {
+                        return EEXIST
+                }
+                ep.fds[fd] = event
+        case EPOLL_CTL_MOD:
+                if _, ok := ep.fds[fd]; !ok {
+                        return ENOENT
+                }
+                ep.fds[fd] = event
+        case EPOLL_CTL_DEL:
+                if _, ok := ep.fds[fd]; !ok {
+                        return ENOENT
+                }
+                delete(ep.fds, fd)
+
+        }
+        return nil
+}
+
+// Must be called while holding ep.mu
+func (ep *eventPoll) getFds() []int {
+        fds := make([]int, len(ep.fds))
+        for fd := range ep.fds {
+                fds = append(fds, fd)
+        }
+        return fds
+}
+
+func (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) {
+        e.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait
+        ep, ok := e.epfd2ep[epfd]
+
+        if !ok {
+                e.mu.Unlock()
+                return 0, EBADF
+        }
+
+        pollfds := make([]PollFd, 4)
+        for fd, epollevt := range ep.fds {
+                pollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)})
+        }
+        e.mu.Unlock()
+
+        n, err = Poll(pollfds, msec)
+        if err != nil {
+                return n, err
+        }
+
+        i := 0
+        for _, pFd := range pollfds {
+                if pFd.Revents != 0 {
+                        events[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)}
+                        i++
+                }
+
+                if i == n {
+                        break
+                }
+        }
+
+        return n, nil
+}
+
+func EpollCreate(size int) (fd int, err error) {
+        return impl.epollcreate(size)
+}
+
+func EpollCreate1(flag int) (fd int, err error) {
+        return impl.epollcreate1(flag)
+}
+
+func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
+        return impl.epollctl(epfd, op, fd, event)
+}
+
+// Because EpollWait mutates events, the caller is expected to coordinate
+// concurrent access if calling with the same epfd from multiple goroutines.
+func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
+        return impl.epollwait(epfd, events, msec)
+}