libgo/go/runtime/netpoll_windows.go

   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         "unsafe"
   9 )
  10
  11 const _DWORD_MAX = 0xffffffff
  12
  13 const _INVALID_HANDLE_VALUE = ^uintptr(0)
  14
  15 // net_op must be the same as beginning of net.operation. Keep these in sync.
  16 type net_op struct {
  17         // used by windows
  18         o overlapped
  19         // used by netpoll
  20         pd    *pollDesc
  21         mode  int32
  22         errno int32
  23         qty   uint32
  24 }
  25
  26 type overlappedEntry struct {
  27         key      uintptr
  28         op       *net_op // In reality it's *overlapped, but we cast it to *net_op anyway.
  29         internal uintptr
  30         qty      uint32
  31 }
  32
  33 var iocphandle uintptr = _INVALID_HANDLE_VALUE // completion port io handle
  34
  35 func netpollinit() {
  36         iocphandle = stdcall4(_CreateIoCompletionPort, _INVALID_HANDLE_VALUE, 0, 0, _DWORD_MAX)
  37         if iocphandle == 0 {
  38                 println("netpoll: failed to create iocp handle (errno=", getlasterror(), ")")
  39                 throw("netpoll: failed to create iocp handle")
  40         }
  41 }
  42
  43 func netpollopen(fd uintptr, pd *pollDesc) int32 {
  44         if stdcall4(_CreateIoCompletionPort, fd, iocphandle, 0, 0) == 0 {
  45                 return -int32(getlasterror())
  46         }
  47         return 0
  48 }
  49
  50 func netpollclose(fd uintptr) int32 {
  51         // nothing to do
  52         return 0
  53 }
  54
  55 func netpollarm(pd *pollDesc, mode int) {
  56         throw("unused")
  57 }
  58
  59 // Polls for completed network IO.
  60 // Returns list of goroutines that become runnable.
  61 func netpoll(block bool) *g {
  62         var entries [64]overlappedEntry
  63         var wait, qty, key, flags, n, i uint32
  64         var errno int32
  65         var op *net_op
  66         var gp guintptr
  67
  68         mp := getg().m
  69
  70         if iocphandle == _INVALID_HANDLE_VALUE {
  71                 return nil
  72         }
  73         wait = 0
  74         if block {
  75                 wait = _INFINITE
  76         }
  77 retry:
  78         if _GetQueuedCompletionStatusEx != nil {
  79                 n = uint32(len(entries) / int(gomaxprocs))
  80                 if n < 8 {
  81                         n = 8
  82                 }
  83                 if block {
  84                         mp.blocked = true
  85                 }
  86                 if stdcall6(_GetQueuedCompletionStatusEx, iocphandle, uintptr(unsafe.Pointer(&entries[0])), uintptr(n), uintptr(unsafe.Pointer(&n)), uintptr(wait), 0) == 0 {
  87                         mp.blocked = false
  88                         errno = int32(getlasterror())
  89                         if !block && errno == _WAIT_TIMEOUT {
  90                                 return nil
  91                         }
  92                         println("netpoll: GetQueuedCompletionStatusEx failed (errno=", errno, ")")
  93                         throw("netpoll: GetQueuedCompletionStatusEx failed")
  94                 }
  95                 mp.blocked = false
  96                 for i = 0; i < n; i++ {
  97                         op = entries[i].op
  98                         errno = 0
  99                         qty = 0
 100                         if stdcall5(_WSAGetOverlappedResult, op.pd.fd, uintptr(unsafe.Pointer(op)), uintptr(unsafe.Pointer(&qty)), 0, uintptr(unsafe.Pointer(&flags))) == 0 {
 101                                 errno = int32(getlasterror())
 102                         }
 103                         handlecompletion(&gp, op, errno, qty)
 104                 }
 105         } else {
 106                 op = nil
 107                 errno = 0
 108                 qty = 0
 109                 if block {
 110                         mp.blocked = true
 111                 }
 112                 if stdcall5(_GetQueuedCompletionStatus, iocphandle, uintptr(unsafe.Pointer(&qty)), uintptr(unsafe.Pointer(&key)), uintptr(unsafe.Pointer(&op)), uintptr(wait)) == 0 {
 113                         mp.blocked = false
 114                         errno = int32(getlasterror())
 115                         if !block && errno == _WAIT_TIMEOUT {
 116                                 return nil
 117                         }
 118                         if op == nil {
 119                                 println("netpoll: GetQueuedCompletionStatus failed (errno=", errno, ")")
 120                                 throw("netpoll: GetQueuedCompletionStatus failed")
 121                         }
 122                         // dequeued failed IO packet, so report that
 123                 }
 124                 mp.blocked = false
 125                 handlecompletion(&gp, op, errno, qty)
 126         }
 127         if block && gp == 0 {
 128                 goto retry
 129         }
 130         return gp.ptr()
 131 }
 132
 133 func handlecompletion(gpp *guintptr, op *net_op, errno int32, qty uint32) {
 134         if op == nil {
 135                 throw("netpoll: GetQueuedCompletionStatus returned op == nil")
 136         }
 137         mode := op.mode
 138         if mode != 'r' && mode != 'w' {
 139                 println("netpoll: GetQueuedCompletionStatus returned invalid mode=", mode)
 140                 throw("netpoll: GetQueuedCompletionStatus returned invalid mode")
 141         }
 142         op.errno = errno
 143         op.qty = qty
 144         netpollready(gpp, op.pd, mode)
 145 }