grpc 1.28.0.pre2 → 1.31.0.pre1

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

@@ -93,6 +93,20 @@ bool grpc_is_epollexclusive_available(void) {
     close(evfd);
     return false;
   }
+  // Check that EPOLLEXCLUSIVE is supported at all.
+  ev.events = static_cast<uint32_t>(EPOLLET | EPOLLIN | EPOLLEXCLUSIVE);
+  if (epoll_ctl(fd, EPOLL_CTL_ADD, evfd, &ev) != 0) {
+    if (!logged_why_not) {
+      gpr_log(GPR_DEBUG,
+              "epoll_ctl with EPOLLEXCLUSIVE failed with error: "
+              "%d. Not using epollex polling engine.",
+              errno);
+      logged_why_not = true;
+    }
+    close(fd);
+    close(evfd);
+    return false;
+  }
   close(evfd);
   close(fd);
   return true;

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

@@ -22,23 +22,23 @@
 
 #include "src/core/lib/iomgr/pollset_set.h"
 
-grpc_pollset_set* pollset_set_create(void) {
+static grpc_pollset_set* pollset_set_create(void) {
   return (grpc_pollset_set*)((intptr_t)0xdeafbeef);
 }
 
-void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
+static void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
 
-void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
-                             grpc_pollset* /*pollset*/) {}
+static void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
+                                    grpc_pollset* /*pollset*/) {}
 
-void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
-                             grpc_pollset* /*pollset*/) {}
+static void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
+                                    grpc_pollset* /*pollset*/) {}
 
-void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
-                                 grpc_pollset_set* /*item*/) {}
+static void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
+                                        grpc_pollset_set* /*item*/) {}
 
-void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
-                                 grpc_pollset_set* /*item*/) {}
+static void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
+                                        grpc_pollset_set* /*item*/) {}
 
 static grpc_pollset_set_vtable vtable = {
     pollset_set_create,          pollset_set_destroy,

data/src/core/lib/{gprpp/optional.h → iomgr/pollset_uv.h}

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2019 gRPC authors.
+ * Copyright 2016 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,18 +16,17 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_GPRPP_OPTIONAL_H
-#define GRPC_CORE_LIB_GPRPP_OPTIONAL_H
+#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_UV_H
+#define GRPC_CORE_LIB_IOMGR_POLLSET_UV_H
 
-#include <grpc/support/port_platform.h>
+extern int grpc_pollset_work_run_loop;
 
-#include "absl/types/optional.h"
+typedef struct grpc_custom_poller_vtable {
+  void (*init)(void);
+  void (*run_loop)(int blocking);
+} grpc_custom_poller_vtable;
 
-namespace grpc_core {
+void grpc_custom_pollset_global_init(grpc_custom_poller_vtable* vtable);
+void grpc_custom_pollset_global_shutdown(void);
 
-template <typename T>
-using Optional = absl::optional<T>;
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_OPTIONAL_H */
+#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_UV_H */

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

@@ -33,19 +33,6 @@
 #endif
 #if defined(GRPC_CUSTOM_SOCKET)
 // Do Nothing
-#elif defined(GPR_MANYLINUX1)
-#define GRPC_HAVE_ARPA_NAMESER 1
-#define GRPC_HAVE_IFADDRS 1
-#define GRPC_HAVE_IPV6_RECVPKTINFO 1
-#define GRPC_HAVE_IP_PKTINFO 1
-#define GRPC_HAVE_MSG_NOSIGNAL 1
-#define GRPC_HAVE_UNIX_SOCKET 1
-#define GRPC_POSIX_FORK 1
-#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
-#define GRPC_POSIX_SOCKET 1
-#define GRPC_POSIX_SOCKETUTILS 1
-#define GRPC_POSIX_WAKEUP_FD 1
-#define GRPC_LINUX_EPOLL 1
 #elif defined(GPR_WINDOWS)
 #define GRPC_WINSOCK_SOCKET 1
 #define GRPC_WINDOWS_SOCKETUTILS 1
@@ -90,11 +77,6 @@
 #if __GLIBC_PREREQ(2, 10)
 #define GRPC_LINUX_SOCKETUTILS 1
 #endif
-#endif
-#ifdef LINUX_VERSION_CODE
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
-#define GRPC_HAVE_TCP_USER_TIMEOUT
-#ifdef __GLIBC_PREREQ
 #if !(__GLIBC_PREREQ(2, 17))
 /*
  * TCP_USER_TIMEOUT wasn't imported to glibc until 2.17. Use Linux system
@@ -102,9 +84,7 @@
  */
 #define GRPC_LINUX_TCP_H 1
 #endif /* __GLIBC_PREREQ(2, 17) */
-#endif /* ifdef __GLIBC_PREREQ */
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37) */
-#endif /* LINUX_VERSION_CODE */
+#endif
 #ifndef __GLIBC__
 #define GRPC_LINUX_EPOLL 1
 #define GRPC_LINUX_EPOLL_CREATE1 1
@@ -129,6 +109,7 @@
 #define GRPC_CFSTREAM_IOMGR 1
 #define GRPC_CFSTREAM_CLIENT 1
 #define GRPC_CFSTREAM_ENDPOINT 1
+#define GRPC_APPLE_EV 1
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1

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

@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2018 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_PYTHON_UTIL_H
+#define GRPC_CORE_LIB_IOMGR_PYTHON_UTIL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/slice.h>
+#include <grpc/status.h>
+#include "src/core/lib/iomgr/error.h"
+
+// These are only used by the gRPC Python extensions.
+// They are easier to define here (rather than in Cython)
+// because Cython doesn't handle #defines well.
+
+grpc_error* grpc_socket_error(char* error) {
+  return grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error),
+                            GRPC_ERROR_INT_GRPC_STATUS,
+                            GRPC_STATUS_UNAVAILABLE);
+}
+
+char* grpc_slice_buffer_start(grpc_slice_buffer* buffer, int i) {
+  return (char*)GRPC_SLICE_START_PTR(buffer->slices[i]);
+}
+
+int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
+  return GRPC_SLICE_LENGTH(buffer->slices[i]);
+}
+
+#endif

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

@@ -41,16 +41,14 @@
 
 #define GRPC_MAX_SOCKADDR_SIZE 128
 
-typedef struct {
+struct grpc_resolved_address {
   char addr[GRPC_MAX_SOCKADDR_SIZE];
   socklen_t len;
-} grpc_resolved_address;
-
-typedef struct {
+};
+struct grpc_resolved_addresses {
   size_t naddrs;
   grpc_resolved_address* addrs;
-} grpc_resolved_addresses;
-
+};
 typedef struct grpc_address_resolver_vtable {
   void (*resolve_address)(const char* addr, const char* default_port,
                           grpc_pollset_set* interested_parties,

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

@@ -18,28 +18,30 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address_custom.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <string.h>
+
+#include <string>
 
+#include "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
-
 #include "src/core/lib/iomgr/iomgr_custom.h"
-#include "src/core/lib/iomgr/resolve_address_custom.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
-#include <string.h>
-
-typedef struct grpc_custom_resolver {
-  grpc_closure* on_done;
-  grpc_resolved_addresses** addresses;
-  char* host;
-  char* port;
-} grpc_custom_resolver;
+struct grpc_custom_resolver {
+  grpc_closure* on_done = nullptr;
+  grpc_resolved_addresses** addresses = nullptr;
+  std::string host;
+  std::string port;
+};
 
 static grpc_custom_resolver_vtable* resolve_address_vtable = nullptr;
 
@@ -48,18 +50,18 @@ static int retry_named_port_failure(grpc_custom_resolver* r,
   // This loop is copied from resolve_address_posix.c
   const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
   for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-    if (strcmp(r->port, svc[i][0]) == 0) {
-      gpr_free(r->port);
-      r->port = gpr_strdup(svc[i][1]);
+    if (r->port == svc[i][0]) {
+      r->port = svc[i][1];
       if (res) {
-        grpc_error* error =
-            resolve_address_vtable->resolve(r->host, r->port, res);
+        grpc_error* error = resolve_address_vtable->resolve(
+            r->host.c_str(), r->port.c_str(), res);
         if (error != GRPC_ERROR_NONE) {
           GRPC_ERROR_UNREF(error);
           return 0;
         }
       } else {
-        resolve_address_vtable->resolve_async(r, r->host, r->port);
+        resolve_address_vtable->resolve_async(r, r->host.c_str(),
+                                              r->port.c_str());
       }
       return 1;
     }
@@ -81,35 +83,25 @@ void grpc_custom_resolve_callback(grpc_custom_resolver* r,
   if (r->on_done) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
   }
-  gpr_free(r->host);
-  gpr_free(r->port);
-  gpr_free(r);
+  delete r;
 }
 
 static grpc_error* try_split_host_port(const char* name,
                                        const char* default_port,
-                                       grpc_core::UniquePtr<char>* host,
-                                       grpc_core::UniquePtr<char>* port) {
+                                       std::string* host, std::string* port) {
   /* parse name, splitting it into host and port parts */
-  grpc_error* error;
   grpc_core::SplitHostPort(name, host, port);
-  if (*host == nullptr) {
-    char* msg;
-    gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
-    return error;
+  if (host->empty()) {
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrFormat("unparseable host:port: '%s'", name).c_str());
   }
-  if (*port == nullptr) {
+  if (port->empty()) {
     // TODO(murgatroid99): add tests for this case
     if (default_port == nullptr) {
-      char* msg;
-      gpr_asprintf(&msg, "no port in name '%s'", name);
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
-      return error;
+      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrFormat("no port in name '%s'", name).c_str());
     }
-    port->reset(gpr_strdup(default_port));
+    *port = default_port;
   }
   return GRPC_ERROR_NONE;
 }
@@ -117,26 +109,21 @@ static grpc_error* try_split_host_port(const char* name,
 static grpc_error* blocking_resolve_address_impl(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
-  grpc_error* err;
-
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
-  err = try_split_host_port(name, default_port, &host, &port);
+  grpc_custom_resolver resolver;
+  grpc_error* err =
+      try_split_host_port(name, default_port, &resolver.host, &resolver.port);
   if (err != GRPC_ERROR_NONE) {
     return err;
   }
 
   /* Call getaddrinfo */
-  grpc_custom_resolver resolver;
-  resolver.host = host.get();
-  resolver.port = port.get();
-
   grpc_resolved_addresses* addrs;
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  err = resolve_address_vtable->resolve(host.get(), port.get(), &addrs);
+  err = resolve_address_vtable->resolve(resolver.host.c_str(),
+                                        resolver.port.c_str(), &addrs);
   if (err != GRPC_ERROR_NONE) {
     if (retry_named_port_failure(&resolver, &addrs)) {
       GRPC_ERROR_UNREF(err);
@@ -154,24 +141,22 @@ static void resolve_address_impl(const char* name, const char* default_port,
                                  grpc_pollset_set* /*interested_parties*/,
                                  grpc_closure* on_done,
                                  grpc_resolved_addresses** addrs) {
-  grpc_custom_resolver* r = nullptr;
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
-  grpc_error* err;
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  err = try_split_host_port(name, default_port, &host, &port);
+  std::string host;
+  std::string port;
+  grpc_error* err = try_split_host_port(name, default_port, &host, &port);
   if (err != GRPC_ERROR_NONE) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, err);
     return;
   }
-  r = (grpc_custom_resolver*)gpr_malloc(sizeof(grpc_custom_resolver));
+  grpc_custom_resolver* r = new grpc_custom_resolver();
   r->on_done = on_done;
   r->addresses = addrs;
-  r->host = host.release();
-  r->port = port.release();
+  r->host = std::move(host);
+  r->port = std::move(port);
 
   /* Call getaddrinfo */
-  resolve_address_vtable->resolve_async(r, r->host, r->port);
+  resolve_address_vtable->resolve_async(r, r->host.c_str(), r->port.c_str());
 }
 
 static grpc_address_resolver_vtable custom_resolver_vtable = {

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

@@ -29,8 +29,10 @@
 typedef struct grpc_custom_resolver grpc_custom_resolver;
 
 typedef struct grpc_custom_resolver_vtable {
-  grpc_error* (*resolve)(char* host, char* port, grpc_resolved_addresses** res);
-  void (*resolve_async)(grpc_custom_resolver* resolver, char* host, char* port);
+  grpc_error* (*resolve)(const char* host, const char* port,
+                         grpc_resolved_addresses** res);
+  void (*resolve_async)(grpc_custom_resolver* resolver, const char* host,
+                        const char* port);
 } grpc_custom_resolver_vtable;
 
 void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,

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

@@ -57,24 +57,24 @@ static grpc_error* posix_blocking_resolve_address(
     return grpc_resolve_unix_domain_address(name + 5, addresses);
   }
 
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
+  std::string host;
+  std::string port;
   /* parse name, splitting it into host and port parts */
   grpc_core::SplitHostPort(name, &host, &port);
-  if (host == nullptr) {
+  if (host.empty()) {
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
         GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
     goto done;
   }
-  if (port == nullptr) {
+  if (port.empty()) {
     if (default_port == nullptr) {
       err = grpc_error_set_str(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
           GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
       goto done;
     }
-    port.reset(gpr_strdup(default_port));
+    port = default_port;
   }
 
   /* Call getaddrinfo */
@@ -84,16 +84,16 @@ static grpc_error* posix_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.get(), port.get(), &hints, &result);
+  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
   GRPC_SCHEDULING_END_BLOCKING_REGION;
 
   if (s != 0) {
     /* Retry if well-known service name is recognized */
     const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
     for (i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-      if (strcmp(port.get(), svc[i][0]) == 0) {
+      if (port == svc[i][0]) {
         GRPC_SCHEDULING_START_BLOCKING_REGION;
-        s = getaddrinfo(host.get(), svc[i][1], &hints, &result);
+        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result);
         GRPC_SCHEDULING_END_BLOCKING_REGION;
         break;
       }
@@ -139,15 +139,14 @@ done:
   return err;
 }
 
-typedef struct {
+struct request {
   char* name;
   char* default_port;
   grpc_closure* on_done;
   grpc_resolved_addresses** addrs_out;
   grpc_closure request_closure;
   void* arg;
-} request;
-
+};
 /* Callback to be passed to grpc Executor to asynch-ify
  * grpc_blocking_resolve_address */
 static void do_request_thread(void* rp, grpc_error* /*error*/) {