mirror of
https://gitea.com/Sirherobrine23/tea.git
synced 2024-08-21 14:27:25 +00:00
* update & migrate gitea sdk (Fix Delete Tag Issue) * upgraded github.com/AlecAivazis/survey v2.2.7 => v2.2.8 * upgraded github.com/adrg/xdg v0.2.3 => v0.3.1 * upgraded github.com/araddon/dateparse * upgraded github.com/olekukonko/tablewriter v0.0.4 => v0.0.5 * upgraded gopkg.in/yaml.v2 v2.3.0 => v2.4.0 Reviewed-on: https://gitea.com/gitea/tea/pulls/337 Reviewed-by: Norwin <noerw@noreply.gitea.io> Reviewed-by: khmarbaise <khmarbaise@noreply.gitea.io> Co-authored-by: 6543 <6543@obermui.de> Co-committed-by: 6543 <6543@obermui.de>
222 lines
5.0 KiB
Go
222 lines
5.0 KiB
Go
// 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
|
|
// +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)
|
|
}
|