root/src/pkg/runtime/netpoll_windows.c

DEFINITIONS

1. runtime·netpollinit
2. runtime·netpollopen
3. runtime·netpollclose
4. runtime·netpollarm
5. runtime·netpoll
6. handlecompletion

// 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);
}