github.com/mtsmfm/go/src@v0.0.0-20221020090648-44bdcb9f8fde/runtime/netpoll_windows.go (about) 1 // Copyright 2013 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 package runtime 6 7 import ( 8 "runtime/internal/atomic" 9 "unsafe" 10 ) 11 12 const _DWORD_MAX = 0xffffffff 13 14 const _INVALID_HANDLE_VALUE = ^uintptr(0) 15 16 // net_op must be the same as beginning of internal/poll.operation. 17 // Keep these in sync. 18 type net_op struct { 19 // used by windows 20 o overlapped 21 // used by netpoll 22 pd *pollDesc 23 mode int32 24 errno int32 25 qty uint32 26 } 27 28 type overlappedEntry struct { 29 key uintptr 30 op *net_op // In reality it's *overlapped, but we cast it to *net_op anyway. 31 internal uintptr 32 qty uint32 33 } 34 35 var ( 36 iocphandle uintptr = _INVALID_HANDLE_VALUE // completion port io handle 37 38 netpollWakeSig atomic.Uint32 // used to avoid duplicate calls of netpollBreak 39 ) 40 41 func netpollinit() { 42 iocphandle = stdcall4(_CreateIoCompletionPort, _INVALID_HANDLE_VALUE, 0, 0, _DWORD_MAX) 43 if iocphandle == 0 { 44 println("runtime: CreateIoCompletionPort failed (errno=", getlasterror(), ")") 45 throw("runtime: netpollinit failed") 46 } 47 } 48 49 func netpollIsPollDescriptor(fd uintptr) bool { 50 return fd == iocphandle 51 } 52 53 func netpollopen(fd uintptr, pd *pollDesc) int32 { 54 if stdcall4(_CreateIoCompletionPort, fd, iocphandle, 0, 0) == 0 { 55 return int32(getlasterror()) 56 } 57 return 0 58 } 59 60 func netpollclose(fd uintptr) int32 { 61 // nothing to do 62 return 0 63 } 64 65 func netpollarm(pd *pollDesc, mode int) { 66 throw("runtime: unused") 67 } 68 69 func netpollBreak() { 70 // Failing to cas indicates there is an in-flight wakeup, so we're done here. 71 if !netpollWakeSig.CompareAndSwap(0, 1) { 72 return 73 } 74 75 if stdcall4(_PostQueuedCompletionStatus, iocphandle, 0, 0, 0) == 0 { 76 println("runtime: netpoll: PostQueuedCompletionStatus failed (errno=", getlasterror(), ")") 77 throw("runtime: netpoll: PostQueuedCompletionStatus failed") 78 } 79 } 80 81 // netpoll checks for ready network connections. 82 // Returns list of goroutines that become runnable. 83 // delay < 0: blocks indefinitely 84 // delay == 0: does not block, just polls 85 // delay > 0: block for up to that many nanoseconds 86 func netpoll(delay int64) gList { 87 var entries [64]overlappedEntry 88 var wait, qty, flags, n, i uint32 89 var errno int32 90 var op *net_op 91 var toRun gList 92 93 mp := getg().m 94 95 if iocphandle == _INVALID_HANDLE_VALUE { 96 return gList{} 97 } 98 if delay < 0 { 99 wait = _INFINITE 100 } else if delay == 0 { 101 wait = 0 102 } else if delay < 1e6 { 103 wait = 1 104 } else if delay < 1e15 { 105 wait = uint32(delay / 1e6) 106 } else { 107 // An arbitrary cap on how long to wait for a timer. 108 // 1e9 ms == ~11.5 days. 109 wait = 1e9 110 } 111 112 n = uint32(len(entries) / int(gomaxprocs)) 113 if n < 8 { 114 n = 8 115 } 116 if delay != 0 { 117 mp.blocked = true 118 } 119 if stdcall6(_GetQueuedCompletionStatusEx, iocphandle, uintptr(unsafe.Pointer(&entries[0])), uintptr(n), uintptr(unsafe.Pointer(&n)), uintptr(wait), 0) == 0 { 120 mp.blocked = false 121 errno = int32(getlasterror()) 122 if errno == _WAIT_TIMEOUT { 123 return gList{} 124 } 125 println("runtime: GetQueuedCompletionStatusEx failed (errno=", errno, ")") 126 throw("runtime: netpoll failed") 127 } 128 mp.blocked = false 129 for i = 0; i < n; i++ { 130 op = entries[i].op 131 if op != nil { 132 errno = 0 133 qty = 0 134 if stdcall5(_WSAGetOverlappedResult, op.pd.fd, uintptr(unsafe.Pointer(op)), uintptr(unsafe.Pointer(&qty)), 0, uintptr(unsafe.Pointer(&flags))) == 0 { 135 errno = int32(getlasterror()) 136 } 137 handlecompletion(&toRun, op, errno, qty) 138 } else { 139 netpollWakeSig.Store(0) 140 if delay == 0 { 141 // Forward the notification to the 142 // blocked poller. 143 netpollBreak() 144 } 145 } 146 } 147 return toRun 148 } 149 150 func handlecompletion(toRun *gList, op *net_op, errno int32, qty uint32) { 151 mode := op.mode 152 if mode != 'r' && mode != 'w' { 153 println("runtime: GetQueuedCompletionStatusEx returned invalid mode=", mode) 154 throw("runtime: netpoll failed") 155 } 156 op.errno = errno 157 op.qty = qty 158 netpollready(toRun, op.pd, mode) 159 }