github.com/gidoBOSSftw5731/go/src@v0.0.0-20210226122457-d24b0edbf019/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 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 if atomic.Cas(&netpollWakeSig, 0, 1) { 71 if stdcall4(_PostQueuedCompletionStatus, iocphandle, 0, 0, 0) == 0 { 72 println("runtime: netpoll: PostQueuedCompletionStatus failed (errno=", getlasterror(), ")") 73 throw("runtime: netpoll: PostQueuedCompletionStatus failed") 74 } 75 } 76 } 77 78 // netpoll checks for ready network connections. 79 // Returns list of goroutines that become runnable. 80 // delay < 0: blocks indefinitely 81 // delay == 0: does not block, just polls 82 // delay > 0: block for up to that many nanoseconds 83 func netpoll(delay int64) gList { 84 var entries [64]overlappedEntry 85 var wait, qty, flags, n, i uint32 86 var errno int32 87 var op *net_op 88 var toRun gList 89 90 mp := getg().m 91 92 if iocphandle == _INVALID_HANDLE_VALUE { 93 return gList{} 94 } 95 if delay < 0 { 96 wait = _INFINITE 97 } else if delay == 0 { 98 wait = 0 99 } else if delay < 1e6 { 100 wait = 1 101 } else if delay < 1e15 { 102 wait = uint32(delay / 1e6) 103 } else { 104 // An arbitrary cap on how long to wait for a timer. 105 // 1e9 ms == ~11.5 days. 106 wait = 1e9 107 } 108 109 n = uint32(len(entries) / int(gomaxprocs)) 110 if n < 8 { 111 n = 8 112 } 113 if delay != 0 { 114 mp.blocked = true 115 } 116 if stdcall6(_GetQueuedCompletionStatusEx, iocphandle, uintptr(unsafe.Pointer(&entries[0])), uintptr(n), uintptr(unsafe.Pointer(&n)), uintptr(wait), 0) == 0 { 117 mp.blocked = false 118 errno = int32(getlasterror()) 119 if errno == _WAIT_TIMEOUT { 120 return gList{} 121 } 122 println("runtime: GetQueuedCompletionStatusEx failed (errno=", errno, ")") 123 throw("runtime: netpoll failed") 124 } 125 mp.blocked = false 126 for i = 0; i < n; i++ { 127 op = entries[i].op 128 if op != nil { 129 errno = 0 130 qty = 0 131 if stdcall5(_WSAGetOverlappedResult, op.pd.fd, uintptr(unsafe.Pointer(op)), uintptr(unsafe.Pointer(&qty)), 0, uintptr(unsafe.Pointer(&flags))) == 0 { 132 errno = int32(getlasterror()) 133 } 134 handlecompletion(&toRun, op, errno, qty) 135 } else { 136 atomic.Store(&netpollWakeSig, 0) 137 if delay == 0 { 138 // Forward the notification to the 139 // blocked poller. 140 netpollBreak() 141 } 142 } 143 } 144 return toRun 145 } 146 147 func handlecompletion(toRun *gList, op *net_op, errno int32, qty uint32) { 148 mode := op.mode 149 if mode != 'r' && mode != 'w' { 150 println("runtime: GetQueuedCompletionStatusEx returned invalid mode=", mode) 151 throw("runtime: netpoll failed") 152 } 153 op.errno = errno 154 op.qty = qty 155 netpollready(toRun, op.pd, mode) 156 }