Delete vendor directory

1 files changed, 0 insertions, 220 deletions

diff --git a/vendor/golang.org/x/sys/unix/epoll_zos.go b/vendor/golang.org/x/sys/unix/epoll_zos.go
deleted file mode 100644
index 7753fdd..0000000
--- a/vendor/golang.org/x/sys/unix/epoll_zos.go
+++ /dev/null
@@ -1,220 +0,0 @@
-// 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)
-}