grpc 1.51.0 → 1.52.0.pre2

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -38,6 +38,7 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -52,64 +53,66 @@
 
 using ::grpc_event_engine::experimental::EndpointConfig;
 
-/* one listening port */
+// one listening port
 typedef struct grpc_tcp_listener grpc_tcp_listener;
 struct grpc_tcp_listener {
-  /* This seemingly magic number comes from AcceptEx's documentation. each
-     address buffer needs to have at least 16 more bytes at their end. */
+  // This seemingly magic number comes from AcceptEx's documentation. each
+  // address buffer needs to have at least 16 more bytes at their end.
   uint8_t addresses[(sizeof(grpc_sockaddr_in6) + 16) * 2];
-  /* This will hold the socket for the next accept. */
+  // This will hold the socket for the next accept.
   SOCKET new_socket;
-  /* The listener winsocket. */
+  // The listener winsocket.
   grpc_winsocket* socket;
-  /* The actual TCP port number. */
+  // The actual TCP port number.
   int port;
   unsigned port_index;
   grpc_tcp_server* server;
-  /* The cached AcceptEx for that port. */
+  // The cached AcceptEx for that port.
   LPFN_ACCEPTEX AcceptEx;
   int shutting_down;
   int outstanding_calls;
-  /* closure for socket notification of accept being ready */
+  // closure for socket notification of accept being ready
   grpc_closure on_accept;
-  /* linked list */
+  // linked list
   struct grpc_tcp_listener* next;
 };
 
-/* the overall server */
+// the overall server
 struct grpc_tcp_server {
   gpr_refcount refs;
-  /* Called whenever accept() succeeds on a server port. */
+  // Called whenever accept() succeeds on a server port.
   grpc_tcp_server_cb on_accept_cb;
   void* on_accept_cb_arg;
 
   gpr_mu mu;
 
-  /* active port count: how many ports are actually still listening */
+  // active port count: how many ports are actually still listening
   int active_ports;
 
-  /* linked list of server ports */
+  // linked list of server ports
   grpc_tcp_listener* head;
   grpc_tcp_listener* tail;
 
-  /* List of closures passed to shutdown_starting_add(). */
+  // List of closures passed to shutdown_starting_add().
   grpc_closure_list shutdown_starting;
 
-  /* shutdown callback */
+  // shutdown callback
   grpc_closure* shutdown_complete;
 };
 
-/* Public function. Allocates the proper data structures to hold a
-   grpc_tcp_server. */
+// Public function. Allocates the proper data structures to hold a
+// grpc_tcp_server.
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
                                            const EndpointConfig& config,
+                                           grpc_tcp_server_cb on_accept_cb,
+                                           void* on_accept_cb_arg,
                                            grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   gpr_ref_init(&s->refs, 1);
   gpr_mu_init(&s->mu);
   s->active_ports = 0;
-  s->on_accept_cb = NULL;
-  s->on_accept_cb_arg = NULL;
+  s->on_accept_cb = on_accept_cb;
+  s->on_accept_cb_arg = on_accept_cb_arg;
   s->head = NULL;
   s->tail = NULL;
   s->shutdown_starting.head = NULL;
@@ -122,9 +125,9 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
 static void destroy_server(void* arg, grpc_error_handle error) {
   grpc_tcp_server* s = (grpc_tcp_server*)arg;
 
-  /* Now that the accepts have been aborted, we can destroy the sockets.
-     The IOCP won't get notified on these, so we can flag them as already
-     closed by the system. */
+  // Now that the accepts have been aborted, we can destroy the sockets.
+  // The IOCP won't get notified on these, so we can flag them as already
+  // closed by the system.
   while (s->head) {
     grpc_tcp_listener* sp = s->head;
     s->head = sp->next;
@@ -164,8 +167,8 @@ static void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
 static void tcp_server_destroy(grpc_tcp_server* s) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  /* First, shutdown all fd's. This will queue abortion calls for all
-     of the pending accepts due to the normal operation mechanism. */
+  // First, shutdown all fd's. This will queue abortion calls for all
+  // of the pending accepts due to the normal operation mechanism.
   if (s->active_ports == 0) {
     finish_shutdown_locked(s);
   } else {
@@ -187,7 +190,7 @@ static void tcp_server_unref(grpc_tcp_server* s) {
   }
 }
 
-/* Prepare (bind) a recently-created socket for listening. */
+// Prepare (bind) a recently-created socket for listening.
 static grpc_error_handle prepare_socket(SOCKET sock,
                                         const grpc_resolved_address* addr,
                                         int* port) {
@@ -244,8 +247,8 @@ static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
   }
 }
 
-/* In order to do an async accept, we need to create a socket first which
-   will be the one assigned to the new incoming connection. */
+// In order to do an async accept, we need to create a socket first which
+// will be the one assigned to the new incoming connection.
 static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
@@ -267,13 +270,13 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   error = grpc_tcp_prepare_socket(sock);
   if (!error.ok()) goto failure;
 
-  /* Start the "accept" asynchronously. */
+  // Start the "accept" asynchronously.
   success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
                            addrlen, addrlen, &bytes_received,
                            &port->socket->read_info.overlapped);
 
-  /* It is possible to get an accept immediately without delay. However, we
-     will still get an IOCP notification for it. So let's just ignore it. */
+  // It is possible to get an accept immediately without delay. However, we
+  // will still get an IOCP notification for it. So let's just ignore it.
   if (!success) {
     int last_error = WSAGetLastError();
     if (last_error != ERROR_IO_PENDING) {
@@ -282,8 +285,8 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
     }
   }
 
-  /* We're ready to do the accept. Calling grpc_socket_notify_on_read may
-     immediately process an accept that happened in the meantime. */
+  // We're ready to do the accept. Calling grpc_socket_notify_on_read may
+  // immediately process an accept that happened in the meantime.
   port->new_socket = sock;
   grpc_socket_notify_on_read(port->socket, &port->on_accept);
   port->outstanding_calls++;
@@ -295,7 +298,7 @@ failure:
   return error;
 }
 
-/* Event manager callback when reads are ready. */
+// Event manager callback when reads are ready.
 static void on_accept(void* arg, grpc_error_handle error) {
   grpc_tcp_listener* sp = (grpc_tcp_listener*)arg;
   SOCKET sock = sp->new_socket;
@@ -311,9 +314,9 @@ static void on_accept(void* arg, grpc_error_handle error) {
 
   peer_name.len = sizeof(struct sockaddr_storage);
 
-  /* The general mechanism for shutting down is to queue abortion calls. While
-     this is necessary in the read/write case, it's useless for the accept
-     case. We only need to adjust the pending callback count */
+  // The general mechanism for shutting down is to queue abortion calls. While
+  // this is necessary in the read/write case, it's useless for the accept
+  // case. We only need to adjust the pending callback count
   if (!error.ok()) {
     gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
             grpc_core::StatusToString(error).c_str());
@@ -321,8 +324,8 @@ static void on_accept(void* arg, grpc_error_handle error) {
     gpr_mu_unlock(&sp->server->mu);
     return;
   }
-  /* The IOCP notified us of a completed operation. Let's grab the results,
-     and act accordingly. */
+  // The IOCP notified us of a completed operation. Let's grab the results,
+  // and act accordingly.
   transfered_bytes = 0;
   wsa_success = WSAGetOverlappedResult(sock, &info->overlapped,
                                        &transfered_bytes, FALSE, &flags);
@@ -367,8 +370,8 @@ static void on_accept(void* arg, grpc_error_handle error) {
     }
   }
 
-  /* The only time we should call our callback, is where we successfully
-     managed to accept a connection, and created an endpoint. */
+  // The only time we should call our callback, is where we successfully
+  // managed to accept a connection, and created an endpoint.
   if (ep) {
     // Create acceptor.
     grpc_tcp_server_acceptor* acceptor =
@@ -379,10 +382,10 @@ static void on_accept(void* arg, grpc_error_handle error) {
     acceptor->external_connection = false;
     sp->server->on_accept_cb(sp->server->on_accept_cb_arg, ep, NULL, acceptor);
   }
-  /* As we were notified from the IOCP of one and exactly one accept,
-     the former socked we created has now either been destroy or assigned
-     to the new connection. We need to create a new one for the next
-     connection. */
+  // As we were notified from the IOCP of one and exactly one accept,
+  // the former socked we created has now either been destroy or assigned
+  // to the new connection. We need to create a new one for the next
+  // connection.
   GPR_ASSERT(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
   if (0 == --sp->outstanding_calls) {
     decrement_active_ports_and_notify_locked(sp);
@@ -402,8 +405,8 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   LPFN_ACCEPTEX AcceptEx;
   grpc_error_handle error;
 
-  /* We need to grab the AcceptEx pointer for that port, as it may be
-     interface-dependent. We'll cache it to avoid doing that again. */
+  // We need to grab the AcceptEx pointer for that port, as it may be
+  // interface-dependent. We'll cache it to avoid doing that again.
   status =
       WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid),
                &AcceptEx, sizeof(AcceptEx), &ioctl_num_bytes, NULL, NULL);
@@ -423,7 +426,6 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
 
   GPR_ASSERT(port >= 0);
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
   sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
   sp->next = NULL;
   if (s->head == NULL) {
@@ -464,8 +466,8 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     port_index = s->tail->port_index + 1;
   }
 
-  /* Check if this is a wildcard port, and if so, try to keep the port the same
-     as some previously created listener. */
+  // Check if this is a wildcard port, and if so, try to keep the port the same
+  // as some previously created listener.
   if (grpc_sockaddr_get_port(addr) == 0) {
     for (sp = s->head; sp; sp = sp->next) {
       int sockname_temp_len = sizeof(struct sockaddr_storage);
@@ -490,7 +492,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     addr = &addr6_v4mapped;
   }
 
-  /* Treat :: or 0.0.0.0 as a family-agnostic wildcard. */
+  // Treat :: or 0.0.0.0 as a family-agnostic wildcard.
   if (grpc_sockaddr_is_wildcard(addr, port)) {
     grpc_sockaddr_make_wildcard6(*port, &wildcard);
 
@@ -522,16 +524,10 @@ done:
 }
 
 static void tcp_server_start(grpc_tcp_server* s,
-                             const std::vector<grpc_pollset*>* /*pollsets*/,
-                             grpc_tcp_server_cb on_accept_cb,
-                             void* on_accept_cb_arg) {
+                             const std::vector<grpc_pollset*>* /*pollsets*/) {
   grpc_tcp_listener* sp;
-  GPR_ASSERT(on_accept_cb);
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(!s->on_accept_cb);
   GPR_ASSERT(s->active_ports == 0);
-  s->on_accept_cb = on_accept_cb;
-  s->on_accept_cb_arg = on_accept_cb_arg;
   for (sp = s->head; sp; sp = sp->next) {
     GPR_ASSERT(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
     s->active_ports++;
@@ -562,4 +558,4 @@ grpc_tcp_server_vtable grpc_windows_tcp_server_vtable = {
     tcp_server_port_fd_count, tcp_server_port_fd,
     tcp_server_ref,           tcp_server_shutdown_starting_add,
     tcp_server_unref,         tcp_server_shutdown_listeners};
-#endif /* GRPC_WINSOCK_SOCKET */
+#endif  // GRPC_WINSOCK_SOCKET

data/src/core/lib/iomgr/tcp_windows.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -33,6 +33,7 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
@@ -44,8 +45,8 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
-/* Nasty workaround for nasty bug when using the 64 bits msys compiler
-   in conjunction with Microsoft Windows headers. */
+// Nasty workaround for nasty bug when using the 64 bits msys compiler
+// in conjunction with Microsoft Windows headers.
 #define GRPC_FIONBIO _IOW('f', 126, uint32_t)
 #else
 #define GRPC_FIONBIO FIONBIO
@@ -98,11 +99,11 @@ grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock) {
 }
 
 typedef struct grpc_tcp {
-  /* This is our C++ class derivation emulation. */
+  // This is our C++ class derivation emulation.
   grpc_endpoint base;
-  /* The one socket this endpoint is using. */
+  // The one socket this endpoint is using.
   grpc_winsocket* socket;
-  /* Refcounting how many operations are in progress. */
+  // Refcounting how many operations are in progress.
   gpr_refcount refcount;
 
   grpc_closure on_read;
@@ -111,14 +112,14 @@ typedef struct grpc_tcp {
   grpc_closure* read_cb;
   grpc_closure* write_cb;
 
-  /* garbage after the last read */
+  // garbage after the last read
   grpc_slice_buffer last_read_buffer;
 
   grpc_slice_buffer* write_slices;
   grpc_slice_buffer* read_slices;
 
-  /* The IO Completion Port runs from another thread. We need some mechanism
-     to protect ourselves when requesting a shutdown. */
+  // The IO Completion Port runs from another thread. We need some mechanism
+  // to protect ourselves when requesting a shutdown.
   gpr_mu mu;
   int shutting_down;
   grpc_error_handle shutdown_error;
@@ -172,7 +173,7 @@ static void tcp_unref(grpc_tcp* tcp) {
 static void tcp_ref(grpc_tcp* tcp) { gpr_ref(&tcp->refcount); }
 #endif
 
-/* Asynchronous callback from the IOCP, or the background thread. */
+// Asynchronous callback from the IOCP, or the background thread.
 static void on_read(void* tcpp, grpc_error_handle error) {
   grpc_tcp* tcp = (grpc_tcp*)tcpp;
   grpc_closure* cb = tcp->read_cb;
@@ -280,19 +281,19 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
 
   TCP_REF(tcp, "read");
 
-  /* First let's try a synchronous, non-blocking read. */
+  // First let's try a synchronous, non-blocking read.
   status = WSARecv(tcp->socket->socket, buffers, (DWORD)tcp->read_slices->count,
                    &bytes_read, &flags, NULL, NULL);
   info->wsa_error = status == 0 ? 0 : WSAGetLastError();
 
-  /* Did we get data immediately ? Yay. */
+  // Did we get data immediately ? Yay.
   if (info->wsa_error != WSAEWOULDBLOCK) {
     info->bytes_transferred = bytes_read;
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, &tcp->on_read, absl::OkStatus());
     return;
   }
 
-  /* Otherwise, let's retry, by queuing a read. */
+  // Otherwise, let's retry, by queuing a read.
   memset(&tcp->socket->read_info.overlapped, 0, sizeof(OVERLAPPED));
   status = WSARecv(tcp->socket->socket, buffers, (DWORD)tcp->read_slices->count,
                    &bytes_read, &flags, &info->overlapped, NULL);
@@ -310,7 +311,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   grpc_socket_notify_on_read(tcp->socket, &tcp->on_read);
 }
 
-/* Asynchronous callback from the IOCP, or the background thread. */
+// Asynchronous callback from the IOCP, or the background thread.
 static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_tcp* tcp = (grpc_tcp*)tcpp;
   grpc_winsocket* handle = tcp->socket;
@@ -330,7 +331,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
-      GPR_ASSERT(info->bytes_transferred == tcp->write_slices->length);
+      GPR_ASSERT(info->bytes_transferred <= tcp->write_slices->length);
     }
   }
 
@@ -338,7 +339,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, error);
 }
 
-/* Initiates a write. */
+// Initiates a write.
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
                       grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
@@ -350,7 +351,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   WSABUF local_buffers[MAX_WSABUF_COUNT];
   WSABUF* allocated = NULL;
   WSABUF* buffers = local_buffers;
-  size_t len;
+  size_t len, async_buffers_offset = 0;
 
   if (grpc_tcp_trace.enabled()) {
     size_t i;
@@ -388,30 +389,52 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
     buffers[i].buf = (char*)GRPC_SLICE_START_PTR(tcp->write_slices->slices[i]);
   }
 
-  /* First, let's try a synchronous, non-blocking write. */
+  // First, let's try a synchronous, non-blocking write.
   status = WSASend(socket->socket, buffers, (DWORD)tcp->write_slices->count,
                    &bytes_sent, 0, NULL, NULL);
-  info->wsa_error = status == 0 ? 0 : WSAGetLastError();
 
-  /* We would kind of expect to get a WSAEWOULDBLOCK here, especially on a busy
-     connection that has its send queue filled up. But if we don't, then we can
-     avoid doing an async write operation at all. */
-  if (info->wsa_error != WSAEWOULDBLOCK) {
-    grpc_error_handle error = status == 0
-                                  ? absl::OkStatus()
-                                  : GRPC_WSA_ERROR(info->wsa_error, "WSASend");
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, error);
-    if (allocated) gpr_free(allocated);
-    return;
+  if (status == 0) {
+    if (bytes_sent == tcp->write_slices->length) {
+      info->wsa_error = 0;
+      grpc_error_handle error = absl::OkStatus();
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, error);
+      if (allocated) gpr_free(allocated);
+      return;
+    }
+
+    // The data was not completely delivered, we should send the rest of
+    // them by doing an async write operation.
+    for (i = 0; i < tcp->write_slices->count; i++) {
+      if (buffers[i].len > bytes_sent) {
+        buffers[i].buf += bytes_sent;
+        buffers[i].len -= bytes_sent;
+        break;
+      }
+      bytes_sent -= buffers[i].len;
+      async_buffers_offset++;
+    }
+  } else {
+    info->wsa_error = WSAGetLastError();
+
+    // We would kind of expect to get a WSAEWOULDBLOCK here, especially on a
+    // busy connection that has its send queue filled up. But if we don't, then
+    // we can avoid doing an async write operation at all.
+    if (info->wsa_error != WSAEWOULDBLOCK) {
+      grpc_error_handle error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, error);
+      if (allocated) gpr_free(allocated);
+      return;
+    }
   }
 
   TCP_REF(tcp, "write");
 
-  /* If we got a WSAEWOULDBLOCK earlier, then we need to re-do the same
-     operation, this time asynchronously. */
+  // If we got a WSAEWOULDBLOCK earlier, then we need to re-do the same
+  // operation, this time asynchronously.
   memset(&socket->write_info.overlapped, 0, sizeof(OVERLAPPED));
-  status = WSASend(socket->socket, buffers, (DWORD)tcp->write_slices->count,
-                   &bytes_sent, 0, &socket->write_info.overlapped, NULL);
+  status = WSASend(socket->socket, buffers + async_buffers_offset,
+                   (DWORD)(tcp->write_slices->count - async_buffers_offset),
+                   NULL, 0, &socket->write_info.overlapped, NULL);
   if (allocated) gpr_free(allocated);
 
   if (status != 0) {
@@ -424,8 +447,8 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
     }
   }
 
-  /* As all is now setup, we can now ask for the IOCP notification. It may
-     trigger the callback immediately however, but no matter. */
+  // As all is now setup, we can now ask for the IOCP notification. It may
+  // trigger the callback immediately however, but no matter.
   grpc_socket_notify_on_write(socket, &tcp->on_write);
 }
 
@@ -446,17 +469,17 @@ static void win_add_to_pollset_set(grpc_endpoint* ep, grpc_pollset_set* pss) {
 static void win_delete_from_pollset_set(grpc_endpoint* ep,
                                         grpc_pollset_set* pss) {}
 
-/* Initiates a shutdown of the TCP endpoint. This will queue abort callbacks
-   for the potential read and write operations. It is up to the caller to
-   guarantee this isn't called in parallel to a read or write request, so
-   we're not going to protect against these. However the IO Completion Port
-   callback will happen from another thread, so we need to protect against
-   concurrent access of the data structure in that regard. */
+// Initiates a shutdown of the TCP endpoint. This will queue abort callbacks
+// for the potential read and write operations. It is up to the caller to
+// guarantee this isn't called in parallel to a read or write request, so
+// we're not going to protect against these. However the IO Completion Port
+// callback will happen from another thread, so we need to protect against
+// concurrent access of the data structure in that regard.
 static void win_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   gpr_mu_lock(&tcp->mu);
-  /* At that point, what may happen is that we're already inside the IOCP
-     callback. See the comments in on_read and on_write. */
+  // At that point, what may happen is that we're already inside the IOCP
+  // callback. See the comments in on_read and on_write.
   if (!tcp->shutting_down) {
     tcp->shutting_down = 1;
     tcp->shutdown_error = why;
@@ -524,4 +547,4 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   return &tcp->base;
 }
 
-#endif /* GRPC_WINSOCK_SOCKET */
+#endif  // GRPC_WINSOCK_SOCKET

data/src/core/lib/iomgr/tcp_windows.h

@@ -1,33 +1,33 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H
 #define GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H
-/*
-   Low level TCP "bottom half" implementation, for use by transports built on
-   top of a TCP connection.
+//
+// Low level TCP "bottom half" implementation, for use by transports built on
+// top of a TCP connection.
 
-   Note that this file does not (yet) include APIs for creating the socket in
-   the first place.
+// Note that this file does not (yet) include APIs for creating the socket in
+// the first place.
 
-   All calls passing slice transfer ownership of a slice refcount unless
-   otherwise specified.
-*/
+// All calls passing slice transfer ownership of a slice refcount unless
+// otherwise specified.
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -37,9 +37,9 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 
-/* Create a tcp endpoint given a winsock handle.
- * Takes ownership of the handle.
- */
+// Create a tcp endpoint given a winsock handle.
+// Takes ownership of the handle.
+//
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                absl::string_view peer_string);
 
@@ -49,4 +49,4 @@ grpc_error_handle grpc_tcp_set_non_block(SOCKET sock);
 
 #endif
 
-#endif /* GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H */
+#endif  // GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H