| // Copyright 2014 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. |
| |
| package runtime |
| |
| import ( |
| "runtime/internal/atomic" |
| "unsafe" |
| ) |
| |
| // Solaris runtime-integrated network poller. |
| // |
| // Solaris uses event ports for scalable network I/O. Event |
| // ports are level-triggered, unlike epoll and kqueue which |
| // can be configured in both level-triggered and edge-triggered |
| // mode. Level triggering means we have to keep track of a few things |
| // ourselves. After we receive an event for a file descriptor, |
| // it's our responsibility to ask again to be notified for future |
| // events for that descriptor. When doing this we must keep track of |
| // what kind of events the goroutines are currently interested in, |
| // for example a fd may be open both for reading and writing. |
| // |
| // A description of the high level operation of this code |
| // follows. Networking code will get a file descriptor by some means |
| // and will register it with the netpolling mechanism by a code path |
| // that eventually calls runtime·netpollopen. runtime·netpollopen |
| // calls port_associate with an empty event set. That means that we |
| // will not receive any events at this point. The association needs |
| // to be done at this early point because we need to process the I/O |
| // readiness notification at some point in the future. If I/O becomes |
| // ready when nobody is listening, when we finally care about it, |
| // nobody will tell us anymore. |
| // |
| // Beside calling runtime·netpollopen, the networking code paths |
| // will call runtime·netpollarm each time goroutines are interested |
| // in doing network I/O. Because now we know what kind of I/O we |
| // are interested in (reading/writing), we can call port_associate |
| // passing the correct type of event set (POLLIN/POLLOUT). As we made |
| // sure to have already associated the file descriptor with the port, |
| // when we now call port_associate, we will unblock the main poller |
| // loop (in runtime·netpoll) right away if the socket is actually |
| // ready for I/O. |
| // |
| // The main poller loop runs in its own thread waiting for events |
| // using port_getn. When an event happens, it will tell the scheduler |
| // about it using runtime·netpollready. Besides doing this, it must |
| // also re-associate the events that were not part of this current |
| // notification with the file descriptor. Failing to do this would |
| // mean each notification will prevent concurrent code using the |
| // same file descriptor in parallel. |
| // |
| // The logic dealing with re-associations is encapsulated in |
| // runtime·netpollupdate. This function takes care to associate the |
| // descriptor only with the subset of events that were previously |
| // part of the association, except the one that just happened. We |
| // can't re-associate with that right away, because event ports |
| // are level triggered so it would cause a busy loop. Instead, that |
| // association is effected only by the runtime·netpollarm code path, |
| // when Go code actually asks for I/O. |
| // |
| // The open and arming mechanisms are serialized using the lock |
| // inside PollDesc. This is required because the netpoll loop runs |
| // asynchronously in respect to other Go code and by the time we get |
| // to call port_associate to update the association in the loop, the |
| // file descriptor might have been closed and reopened already. The |
| // lock allows runtime·netpollupdate to be called synchronously from |
| // the loop thread while preventing other threads operating to the |
| // same PollDesc, so once we unblock in the main loop, until we loop |
| // again we know for sure we are always talking about the same file |
| // descriptor and can safely access the data we want (the event set). |
| |
| //extern port_create |
| func port_create() int32 |
| |
| //extern port_associate |
| func port_associate(port, source int32, object uintptr, events uint32, user uintptr) int32 |
| |
| //extern port_dissociate |
| func port_dissociate(port, source int32, object uintptr) int32 |
| |
| //go:noescape |
| //extern port_getn |
| func port_getn(port int32, evs *portevent, max uint32, nget *uint32, timeout *timespec) int32 |
| |
| //extern port_alert |
| func port_alert(port int32, flags, events uint32, user uintptr) int32 |
| |
| var ( |
| netpollWakeSig uint32 // used to avoid duplicate calls of netpollBreak |
| ) |
| |
| var portfd int32 = -1 |
| |
| func netpollinit() { |
| portfd = port_create() |
| if portfd >= 0 { |
| closeonexec(portfd) |
| return |
| } |
| |
| print("runtime: port_create failed (errno=", errno(), ")\n") |
| throw("runtime: netpollinit failed") |
| } |
| |
| func netpollIsPollDescriptor(fd uintptr) bool { |
| return fd == uintptr(portfd) |
| } |
| |
| func netpollopen(fd uintptr, pd *pollDesc) int32 { |
| lock(&pd.lock) |
| // We don't register for any specific type of events yet, that's |
| // netpollarm's job. We merely ensure we call port_associate before |
| // asynchronous connect/accept completes, so when we actually want |
| // to do any I/O, the call to port_associate (from netpollarm, |
| // with the interested event set) will unblock port_getn right away |
| // because of the I/O readiness notification. |
| pd.user = 0 |
| r := port_associate(portfd, _PORT_SOURCE_FD, fd, 0, uintptr(unsafe.Pointer(pd))) |
| unlock(&pd.lock) |
| if r < 0 { |
| return int32(errno()) |
| } |
| return 0 |
| } |
| |
| func netpollclose(fd uintptr) int32 { |
| if port_dissociate(portfd, _PORT_SOURCE_FD, fd) < 0 { |
| return int32(errno()) |
| } |
| return 0 |
| } |
| |
| // Updates the association with a new set of interested events. After |
| // this call, port_getn will return one and only one event for that |
| // particular descriptor, so this function needs to be called again. |
| func netpollupdate(pd *pollDesc, set, clear uint32) { |
| if pd.closing { |
| return |
| } |
| |
| old := pd.user |
| events := (old & ^clear) | set |
| if old == events { |
| return |
| } |
| |
| if events != 0 && port_associate(portfd, _PORT_SOURCE_FD, pd.fd, events, uintptr(unsafe.Pointer(pd))) != 0 { |
| print("runtime: port_associate failed (errno=", errno(), ")\n") |
| throw("runtime: netpollupdate failed") |
| } |
| pd.user = events |
| } |
| |
| // subscribe the fd to the port such that port_getn will return one event. |
| func netpollarm(pd *pollDesc, mode int) { |
| lock(&pd.lock) |
| switch mode { |
| case 'r': |
| netpollupdate(pd, _POLLIN, 0) |
| case 'w': |
| netpollupdate(pd, _POLLOUT, 0) |
| default: |
| throw("runtime: bad mode") |
| } |
| unlock(&pd.lock) |
| } |
| |
| // netpollBreak interrupts a port_getn wait. |
| func netpollBreak() { |
| if atomic.Cas(&netpollWakeSig, 0, 1) { |
| // Use port_alert to put portfd into alert mode. |
| // This will wake up all threads sleeping in port_getn on portfd, |
| // and cause their calls to port_getn to return immediately. |
| // Further, until portfd is taken out of alert mode, |
| // all calls to port_getn will return immediately. |
| if port_alert(portfd, _PORT_ALERT_UPDATE, _POLLHUP, uintptr(unsafe.Pointer(&portfd))) < 0 { |
| if e := errno(); e != _EBUSY { |
| println("runtime: port_alert failed with", e) |
| throw("runtime: netpoll: port_alert failed") |
| } |
| } |
| } |
| } |
| |
| // netpoll checks for ready network connections. |
| // Returns list of goroutines that become runnable. |
| // delay < 0: blocks indefinitely |
| // delay == 0: does not block, just polls |
| // delay > 0: block for up to that many nanoseconds |
| func netpoll(delay int64) gList { |
| if portfd == -1 { |
| return gList{} |
| } |
| |
| var wait *timespec |
| var ts timespec |
| if delay < 0 { |
| wait = nil |
| } else if delay == 0 { |
| wait = &ts |
| } else { |
| ts.setNsec(delay) |
| if ts.tv_sec > 1e6 { |
| // An arbitrary cap on how long to wait for a timer. |
| // 1e6 s == ~11.5 days. |
| ts.tv_sec = 1e6 |
| } |
| wait = &ts |
| } |
| |
| var events [128]portevent |
| retry: |
| var n uint32 = 1 |
| r := port_getn(portfd, &events[0], uint32(len(events)), &n, wait) |
| e := errno() |
| if r < 0 && e == _ETIME && n > 0 { |
| // As per port_getn(3C), an ETIME failure does not preclude the |
| // delivery of some number of events. Treat a timeout failure |
| // with delivered events as a success. |
| r = 0 |
| } |
| if r < 0 { |
| if e != _EINTR && e != _ETIME { |
| print("runtime: port_getn on fd ", portfd, " failed (errno=", e, ")\n") |
| throw("runtime: netpoll failed") |
| } |
| // If a timed sleep was interrupted and there are no events, |
| // just return to recalculate how long we should sleep now. |
| if delay > 0 { |
| return gList{} |
| } |
| goto retry |
| } |
| |
| var toRun gList |
| for i := 0; i < int(n); i++ { |
| ev := &events[i] |
| |
| if ev.portev_source == _PORT_SOURCE_ALERT { |
| if ev.portev_events != _POLLHUP || unsafe.Pointer(ev.portev_user) != unsafe.Pointer(&portfd) { |
| throw("runtime: netpoll: bad port_alert wakeup") |
| } |
| if delay != 0 { |
| // Now that a blocking call to netpoll |
| // has seen the alert, take portfd |
| // back out of alert mode. |
| // See the comment in netpollBreak. |
| if port_alert(portfd, 0, 0, 0) < 0 { |
| e := errno() |
| println("runtime: port_alert failed with", e) |
| throw("runtime: netpoll: port_alert failed") |
| } |
| atomic.Store(&netpollWakeSig, 0) |
| } |
| continue |
| } |
| |
| if ev.portev_events == 0 { |
| continue |
| } |
| pd := (*pollDesc)(unsafe.Pointer(ev.portev_user)) |
| |
| var mode, clear int32 |
| if (ev.portev_events & (_POLLIN | _POLLHUP | _POLLERR)) != 0 { |
| mode += 'r' |
| clear |= _POLLIN |
| } |
| if (ev.portev_events & (_POLLOUT | _POLLHUP | _POLLERR)) != 0 { |
| mode += 'w' |
| clear |= _POLLOUT |
| } |
| // To effect edge-triggered events, we need to be sure to |
| // update our association with whatever events were not |
| // set with the event. For example if we are registered |
| // for POLLIN|POLLOUT, and we get POLLIN, besides waking |
| // the goroutine interested in POLLIN we have to not forget |
| // about the one interested in POLLOUT. |
| if clear != 0 { |
| lock(&pd.lock) |
| netpollupdate(pd, 0, uint32(clear)) |
| unlock(&pd.lock) |
| } |
| |
| if mode != 0 { |
| // TODO(mikio): Consider implementing event |
| // scanning error reporting once we are sure |
| // about the event port on SmartOS. |
| // |
| // See golang.org/x/issue/30840. |
| netpollready(&toRun, pd, mode) |
| } |
| } |
| |
| return toRun |
| } |