epoll_zos.go

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