| // Copyright 2013 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. |
| |
| #include "runtime.h" |
| #include "defs_GOOS_GOARCH.h" |
| #include "os_GOOS.h" |
| |
| #define DWORD_MAX 0xffffffff |
| |
| #pragma dynimport runtime·CreateIoCompletionPort CreateIoCompletionPort "kernel32.dll" |
| #pragma dynimport runtime·GetQueuedCompletionStatus GetQueuedCompletionStatus "kernel32.dll" |
| #pragma dynimport runtime·WSAGetOverlappedResult WSAGetOverlappedResult "ws2_32.dll" |
| |
| extern void *runtime·CreateIoCompletionPort; |
| extern void *runtime·GetQueuedCompletionStatus; |
| extern void *runtime·WSAGetOverlappedResult; |
| |
| #define INVALID_HANDLE_VALUE ((uintptr)-1) |
| |
| // net_op must be the same as beginning of net.operation. Keep these in sync. |
| typedef struct net_op net_op; |
| struct net_op |
| { |
| // used by windows |
| Overlapped o; |
| // used by netpoll |
| PollDesc* pd; |
| int32 mode; |
| int32 errno; |
| uint32 qty; |
| }; |
| |
| typedef struct OverlappedEntry OverlappedEntry; |
| struct OverlappedEntry |
| { |
| uintptr key; |
| net_op* op; // In reality it's Overlapped*, but we cast it to net_op* anyway. |
| uintptr internal; |
| uint32 qty; |
| }; |
| |
| static void handlecompletion(G **gpp, net_op *o, int32 errno, uint32 qty); |
| |
| static uintptr iocphandle = INVALID_HANDLE_VALUE; // completion port io handle |
| |
| void |
| runtime·netpollinit(void) |
| { |
| iocphandle = (uintptr)runtime·stdcall(runtime·CreateIoCompletionPort, 4, INVALID_HANDLE_VALUE, (uintptr)0, (uintptr)0, (uintptr)DWORD_MAX); |
| if(iocphandle == 0) { |
| runtime·printf("netpoll: failed to create iocp handle (errno=%d)\n", runtime·getlasterror()); |
| runtime·throw("netpoll: failed to create iocp handle"); |
| } |
| return; |
| } |
| |
| int32 |
| runtime·netpollopen(uintptr fd, PollDesc *pd) |
| { |
| USED(pd); |
| if(runtime·stdcall(runtime·CreateIoCompletionPort, 4, fd, iocphandle, (uintptr)0, (uintptr)0) == 0) |
| return -runtime·getlasterror(); |
| return 0; |
| } |
| |
| int32 |
| runtime·netpollclose(uintptr fd) |
| { |
| // nothing to do |
| USED(fd); |
| return 0; |
| } |
| |
| void |
| runtime·netpollarm(PollDesc* pd, int32 mode) |
| { |
| USED(pd, mode); |
| runtime·throw("unused"); |
| } |
| |
| // Polls for completed network IO. |
| // Returns list of goroutines that become runnable. |
| G* |
| runtime·netpoll(bool block) |
| { |
| OverlappedEntry entries[64]; |
| uint32 wait, qty, key, flags, n, i; |
| int32 errno; |
| net_op *op; |
| G *gp; |
| |
| if(iocphandle == INVALID_HANDLE_VALUE) |
| return nil; |
| gp = nil; |
| wait = 0; |
| if(block) |
| wait = INFINITE; |
| retry: |
| if(runtime·GetQueuedCompletionStatusEx != nil) { |
| n = nelem(entries) / runtime·gomaxprocs; |
| if(n < 8) |
| n = 8; |
| if(block) |
| m->blocked = true; |
| if(runtime·stdcall(runtime·GetQueuedCompletionStatusEx, 6, iocphandle, entries, (uintptr)n, &n, (uintptr)wait, (uintptr)0) == 0) { |
| m->blocked = false; |
| errno = runtime·getlasterror(); |
| if(!block && errno == WAIT_TIMEOUT) |
| return nil; |
| runtime·printf("netpoll: GetQueuedCompletionStatusEx failed (errno=%d)\n", errno); |
| runtime·throw("netpoll: GetQueuedCompletionStatusEx failed"); |
| } |
| m->blocked = false; |
| for(i = 0; i < n; i++) { |
| op = entries[i].op; |
| errno = 0; |
| qty = 0; |
| if(runtime·stdcall(runtime·WSAGetOverlappedResult, 5, runtime·netpollfd(op->pd), op, &qty, (uintptr)0, (uintptr)&flags) == 0) |
| errno = runtime·getlasterror(); |
| handlecompletion(&gp, op, errno, qty); |
| } |
| } else { |
| op = nil; |
| errno = 0; |
| qty = 0; |
| if(block) |
| m->blocked = true; |
| if(runtime·stdcall(runtime·GetQueuedCompletionStatus, 5, iocphandle, &qty, &key, &op, (uintptr)wait) == 0) { |
| m->blocked = false; |
| errno = runtime·getlasterror(); |
| if(!block && errno == WAIT_TIMEOUT) |
| return nil; |
| if(op == nil) { |
| runtime·printf("netpoll: GetQueuedCompletionStatus failed (errno=%d)\n", errno); |
| runtime·throw("netpoll: GetQueuedCompletionStatus failed"); |
| } |
| // dequeued failed IO packet, so report that |
| } |
| m->blocked = false; |
| handlecompletion(&gp, op, errno, qty); |
| } |
| if(block && gp == nil) |
| goto retry; |
| return gp; |
| } |
| |
| static void |
| handlecompletion(G **gpp, net_op *op, int32 errno, uint32 qty) |
| { |
| int32 mode; |
| |
| if(op == nil) |
| runtime·throw("netpoll: GetQueuedCompletionStatus returned op == nil"); |
| mode = op->mode; |
| if(mode != 'r' && mode != 'w') { |
| runtime·printf("netpoll: GetQueuedCompletionStatus returned invalid mode=%d\n", mode); |
| runtime·throw("netpoll: GetQueuedCompletionStatus returned invalid mode"); |
| } |
| op->errno = errno; |
| op->qty = qty; |
| runtime·netpollready(gpp, op->pd, mode); |
| } |