grpc 1.41.0 → 1.43.1

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

@@ -59,13 +59,12 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/resource_quota/api.h"
 
-static grpc_error_handle tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
-  grpc_tcp_server* s =
-      static_cast<grpc_tcp_server*>(gpr_zalloc(sizeof(grpc_tcp_server)));
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
+  grpc_tcp_server* s = new grpc_tcp_server;
   s->so_reuseport = grpc_is_socket_reuse_port_supported();
   s->expand_wildcard_addrs = false;
   for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) {
@@ -75,7 +74,6 @@ static grpc_error_handle tcp_server_create(
                           (args->args[i].value.integer != 0);
       } else {
         gpr_free(s);
-        grpc_slice_allocator_factory_destroy(slice_allocator_factory);
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(GRPC_ARG_ALLOW_REUSEPORT
                                                     " must be an integer");
       }
@@ -84,7 +82,6 @@ static grpc_error_handle tcp_server_create(
         s->expand_wildcard_addrs = (args->args[i].value.integer != 0);
       } else {
         gpr_free(s);
-        grpc_slice_allocator_factory_destroy(slice_allocator_factory);
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             GRPC_ARG_EXPAND_WILDCARD_ADDRS " must be an integer");
       }
@@ -105,7 +102,8 @@ static grpc_error_handle tcp_server_create(
   s->nports = 0;
   s->channel_args = grpc_channel_args_copy(args);
   s->fd_handler = nullptr;
-  s->slice_allocator_factory = slice_allocator_factory;
+  s->memory_quota =
+      grpc_core::ResourceQuotaFromChannelArgs(args)->memory_quota();
   gpr_atm_no_barrier_store(&s->next_pollset_to_assign, 0);
   *server = s;
   return GRPC_ERROR_NONE;
@@ -125,10 +123,9 @@ static void finish_shutdown(grpc_tcp_server* s) {
     s->head = sp->next;
     gpr_free(sp);
   }
-  grpc_slice_allocator_factory_destroy(s->slice_allocator_factory);
   grpc_channel_args_destroy(s->channel_args);
   delete s->fd_handler;
-  gpr_free(s);
+  delete s;
 }
 
 static void destroyed_port(void* server, grpc_error_handle /*error*/) {
@@ -223,6 +220,12 @@ static void on_read(void* arg, grpc_error_handle err) {
       }
     }
 
+    if (sp->server->memory_quota->IsMemoryPressureHigh()) {
+      gpr_log(GPR_INFO, "Drop incoming connection: high memory pressure");
+      close(fd);
+      continue;
+    }
+
     /* For UNIX sockets, the accept call might not fill up the member sun_path
      * of sockaddr_un, so explicitly call getsockname to get it. */
     if (grpc_is_unix_socket(&addr)) {
@@ -236,7 +239,7 @@ static void on_read(void* arg, grpc_error_handle err) {
       }
     }
 
-    grpc_set_socket_no_sigpipe_if_possible(fd);
+    (void)grpc_set_socket_no_sigpipe_if_possible(fd);
 
     err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_CONNECTION_USAGE,
                                             sp->server->channel_args);
@@ -269,11 +272,7 @@ static void on_read(void* arg, grpc_error_handle err) {
     acceptor->external_connection = false;
     sp->server->on_accept_cb(
         sp->server->on_accept_cb_arg,
-        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str.c_str(),
-                        grpc_slice_allocator_factory_create_slice_allocator(
-                            sp->server->slice_allocator_factory,
-                            absl::StrCat("tcp_server_posix:", addr_str),
-                            sp->server->channel_args)),
+        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str),
         read_notifier_pollset, acceptor);
   }
 
@@ -595,7 +594,7 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
       close(fd);
       return;
     }
-    grpc_set_socket_no_sigpipe_if_possible(fd);
+    (void)grpc_set_socket_no_sigpipe_if_possible(fd);
     std::string addr_str = grpc_sockaddr_to_uri(&addr);
     if (grpc_tcp_trace.enabled()) {
       gpr_log(GPR_INFO, "SERVER_CONNECT: incoming external connection: %s",
@@ -616,13 +615,9 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
     acceptor->external_connection = true;
     acceptor->listener_fd = listener_fd;
     acceptor->pending_data = buf;
-    s_->on_accept_cb(
-        s_->on_accept_cb_arg,
-        grpc_tcp_create(
-            fdobj, s_->channel_args, addr_str.c_str(),
-            grpc_slice_allocator_factory_create_slice_allocator(
-                s_->slice_allocator_factory, addr_str, s_->channel_args)),
-        read_notifier_pollset, acceptor);
+    s_->on_accept_cb(s_->on_accept_cb_arg,
+                     grpc_tcp_create(fdobj, s_->channel_args, addr_str),
+                     read_notifier_pollset, acceptor);
   }
 
  private:

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

@@ -25,6 +25,7 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 
 /* one listening port */
 typedef struct grpc_tcp_listener {
@@ -52,51 +53,51 @@ typedef struct grpc_tcp_listener {
 struct grpc_tcp_server {
   gpr_refcount refs;
   /* Called whenever accept() succeeds on a server port. */
-  grpc_tcp_server_cb on_accept_cb;
-  void* on_accept_cb_arg;
+  grpc_tcp_server_cb on_accept_cb = nullptr;
+  void* on_accept_cb_arg = nullptr;
 
   gpr_mu mu;
 
   /* active port count: how many ports are actually still listening */
-  size_t active_ports;
+  size_t active_ports = 0;
   /* destroyed port count: how many ports are completely destroyed */
-  size_t destroyed_ports;
+  size_t destroyed_ports = 0;
 
   /* is this server shutting down? */
-  bool shutdown;
+  bool shutdown = false;
   /* have listeners been shutdown? */
-  bool shutdown_listeners;
+  bool shutdown_listeners = false;
   /* use SO_REUSEPORT */
-  bool so_reuseport;
+  bool so_reuseport = false;
   /* expand wildcard addresses to a list of all local addresses */
-  bool expand_wildcard_addrs;
+  bool expand_wildcard_addrs = false;
 
   /* linked list of server ports */
-  grpc_tcp_listener* head;
-  grpc_tcp_listener* tail;
-  unsigned nports;
+  grpc_tcp_listener* head = nullptr;
+  grpc_tcp_listener* tail = nullptr;
+  unsigned nports = 0;
 
   /* List of closures passed to shutdown_starting_add(). */
-  grpc_closure_list shutdown_starting;
+  grpc_closure_list shutdown_starting{nullptr, nullptr};
 
   /* shutdown callback */
-  grpc_closure* shutdown_complete;
+  grpc_closure* shutdown_complete = nullptr;
 
   /* all pollsets interested in new connections. The object pointed at is not
    * owned by this struct */
-  const std::vector<grpc_pollset*>* pollsets;
+  const std::vector<grpc_pollset*>* pollsets = nullptr;
 
   /* next pollset to assign a channel to */
-  gpr_atm next_pollset_to_assign;
+  gpr_atm next_pollset_to_assign = 0;
 
   /* channel args for this server */
-  grpc_channel_args* channel_args;
+  grpc_channel_args* channel_args = nullptr;
 
   /* a handler for external connections, owned */
-  grpc_core::TcpServerFdHandler* fd_handler;
+  grpc_core::TcpServerFdHandler* fd_handler = nullptr;
 
   /* used to create slice allocators for endpoints, owned */
-  grpc_slice_allocator_factory* slice_allocator_factory;
+  grpc_core::MemoryQuotaRefPtr memory_quota;
 };
 
 /* If successful, add a listener to \a s for \a addr, set \a dsmode for the

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

@@ -96,15 +96,13 @@ struct grpc_tcp_server {
   grpc_closure* shutdown_complete;
 
   grpc_channel_args* channel_args;
-  grpc_slice_allocator_factory* slice_allocator_factory;
 };
 
 /* 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 grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   s->channel_args = grpc_channel_args_copy(args);
   gpr_ref_init(&s->refs, 1);
@@ -117,7 +115,6 @@ static grpc_error_handle tcp_server_create(
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
   s->shutdown_complete = shutdown_complete;
-  s->slice_allocator_factory = slice_allocator_factory;
   *server = s;
   return GRPC_ERROR_NONE;
 }
@@ -168,7 +165,6 @@ 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);
-  grpc_slice_allocator_factory_destroy(s->slice_allocator_factory);
   /* 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) {
@@ -230,11 +226,10 @@ static grpc_error_handle prepare_socket(SOCKET sock,
 failure:
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   grpc_error_set_int(
-      grpc_error_set_str(
-          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-              "Failed to prepare server socket", &error, 1),
-          GRPC_ERROR_STR_TARGET_ADDRESS,
-          grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr))),
+      grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                             "Failed to prepare server socket", &error, 1),
+                         GRPC_ERROR_STR_TARGET_ADDRESS,
+                         grpc_sockaddr_to_uri(addr)),
       GRPC_ERROR_INT_FD, (intptr_t)sock);
   GRPC_ERROR_UNREF(error);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -359,11 +354,8 @@ static void on_accept(void* arg, grpc_error_handle error) {
         gpr_free(utf8_message);
       }
       std::string fd_name = absl::StrCat("tcp_server:", peer_name_string);
-      ep = grpc_tcp_create(
-          grpc_winsocket_create(sock, fd_name.c_str()),
-          sp->server->channel_args, peer_name_string.c_str(),
-          grpc_slice_allocator_factory_create_slice_allocator(
-              sp->server->slice_allocator_factory, peer_name_string));
+      ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name.c_str()),
+                           sp->server->channel_args, peer_name_string);
     } else {
       closesocket(sock);
     }

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

@@ -116,8 +116,6 @@ typedef struct grpc_tcp {
   grpc_slice_buffer* write_slices;
   grpc_slice_buffer* read_slices;
 
-  grpc_slice_allocator* slice_allocator;
-
   /* The IO Completion Port runs from another thread. We need some mechanism
      to protect ourselves when requesting a shutdown. */
   gpr_mu mu;
@@ -132,7 +130,6 @@ static void tcp_free(grpc_tcp* tcp) {
   grpc_winsocket_destroy(tcp->socket);
   gpr_mu_destroy(&tcp->mu);
   grpc_slice_buffer_destroy_internal(&tcp->last_read_buffer);
-  grpc_slice_allocator_destroy(tcp->slice_allocator);
   if (tcp->shutting_down) GRPC_ERROR_UNREF(tcp->shutdown_error);
   delete tcp;
 }
@@ -186,7 +183,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
     gpr_log(GPR_INFO, "TCP:%p on_read", tcp);
   }
 
-  GRPC_ERROR_REF(error);
+  (void)GRPC_ERROR_REF(error);
 
   if (error == GRPC_ERROR_NONE) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
@@ -322,7 +319,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     gpr_log(GPR_INFO, "TCP:%p on_write", tcp);
   }
 
-  GRPC_ERROR_REF(error);
+  (void)GRPC_ERROR_REF(error);
 
   gpr_mu_lock(&tcp->mu);
   cb = tcp->write_cb;
@@ -502,8 +499,7 @@ static grpc_endpoint_vtable vtable = {win_read,
 
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                grpc_channel_args* channel_args,
-                               const char* peer_string,
-                               grpc_slice_allocator* slice_allocator) {
+                               absl::string_view peer_string) {
   grpc_tcp* tcp = new grpc_tcp;
   memset(tcp, 0, sizeof(grpc_tcp));
   tcp->base.vtable = &vtable;
@@ -521,9 +517,8 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   } else {
     tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
   }
-  tcp->peer_string = peer_string;
+  tcp->peer_string = std::string(peer_string);
   grpc_slice_buffer_init(&tcp->last_read_buffer);
-  tcp->slice_allocator = slice_allocator;
   return &tcp->base;
 }
 

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

@@ -42,8 +42,7 @@
  */
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                grpc_channel_args* channel_args,
-                               const char* peer_string,
-                               grpc_slice_allocator* slice_allocator);
+                               absl::string_view peer_string);
 
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock);
 

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

@@ -43,7 +43,7 @@
 
 #define ADD_DEADLINE_SCALE 0.33
 #define MIN_QUEUE_WINDOW_DURATION 0.01
-#define MAX_QUEUE_WINDOW_DURATION 1
+#define MAX_QUEUE_WINDOW_DURATION 1.0
 
 grpc_core::TraceFlag grpc_timer_trace(false, "timer");
 grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
@@ -105,7 +105,7 @@ static void destroy_timer_ht() {
 }
 
 static bool is_in_ht(grpc_timer* t) {
-  size_t i = GPR_HASH_POINTER(t, NUM_HASH_BUCKETS);
+  size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
 
   gpr_mu_lock(&g_hash_mu[i]);
   grpc_timer* p = g_timer_ht[i];
@@ -119,7 +119,7 @@ static bool is_in_ht(grpc_timer* t) {
 
 static void add_to_ht(grpc_timer* t) {
   GPR_ASSERT(!t->hash_table_next);
-  size_t i = GPR_HASH_POINTER(t, NUM_HASH_BUCKETS);
+  size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
 
   gpr_mu_lock(&g_hash_mu[i]);
   grpc_timer* p = g_timer_ht[i];
@@ -144,7 +144,7 @@ static void add_to_ht(grpc_timer* t) {
 }
 
 static void remove_from_ht(grpc_timer* t) {
-  size_t i = GPR_HASH_POINTER(t, NUM_HASH_BUCKETS);
+  size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
   bool removed = false;
 
   gpr_mu_lock(&g_hash_mu[i]);
@@ -248,7 +248,7 @@ static grpc_millis compute_min_deadline(timer_shard* shard) {
 static void timer_list_init() {
   uint32_t i;
 
-  g_num_shards = GPR_CLAMP(2 * gpr_cpu_num_cores(), 1, 32);
+  g_num_shards = grpc_core::Clamp(2 * gpr_cpu_num_cores(), 1u, 32u);
   g_shards =
       static_cast<timer_shard*>(gpr_zalloc(g_num_shards * sizeof(*g_shards)));
   g_shard_queue = static_cast<timer_shard**>(
@@ -337,7 +337,7 @@ void grpc_timer_init_unset(grpc_timer* timer) { timer->pending = false; }
 static void timer_init(grpc_timer* timer, grpc_millis deadline,
                        grpc_closure* closure) {
   int is_first_timer = 0;
-  timer_shard* shard = &g_shards[GPR_HASH_POINTER(timer, g_num_shards)];
+  timer_shard* shard = &g_shards[grpc_core::HashPointer(timer, g_num_shards)];
   timer->closure = closure;
   timer->deadline = deadline;
 
@@ -444,7 +444,7 @@ static void timer_cancel(grpc_timer* timer) {
     return;
   }
 
-  timer_shard* shard = &g_shards[GPR_HASH_POINTER(timer, g_num_shards)];
+  timer_shard* shard = &g_shards[grpc_core::HashPointer(timer, g_num_shards)];
   gpr_mu_lock(&shard->mu);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
     gpr_log(GPR_INFO, "TIMER %p: CANCEL pending=%s", timer,
@@ -479,13 +479,13 @@ static bool refill_heap(timer_shard* shard, grpc_millis now) {
       grpc_time_averaged_stats_update_average(&shard->stats) *
       ADD_DEADLINE_SCALE;
   double deadline_delta =
-      GPR_CLAMP(computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION,
-                MAX_QUEUE_WINDOW_DURATION);
+      grpc_core::Clamp(computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION,
+                       MAX_QUEUE_WINDOW_DURATION);
   grpc_timer *timer, *next;
 
   /* Compute the new cap and put all timers under it into the queue: */
   shard->queue_deadline_cap =
-      saturating_add(GPR_MAX(now, shard->queue_deadline_cap),
+      saturating_add(std::max(now, shard->queue_deadline_cap),
                      static_cast<grpc_millis>(deadline_delta * 1000.0));
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
@@ -583,7 +583,7 @@ static grpc_timer_check_result run_some_expired_timers(
   g_last_seen_min_timer = min_timer;
 
   if (now < min_timer) {
-    if (next != nullptr) *next = GPR_MIN(*next, min_timer);
+    if (next != nullptr) *next = std::min(*next, min_timer);
     return GRPC_TIMERS_CHECKED_AND_EMPTY;
   }
 
@@ -628,7 +628,7 @@ static grpc_timer_check_result run_some_expired_timers(
     }
 
     if (next) {
-      *next = GPR_MIN(*next, g_shard_queue[0]->min_deadline);
+      *next = std::min(*next, g_shard_queue[0]->min_deadline);
     }
 
 #if GPR_ARCH_64
@@ -663,7 +663,7 @@ static grpc_timer_check_result timer_check(grpc_millis* next) {
 
   if (now < min_timer) {
     if (next != nullptr) {
-      *next = GPR_MIN(*next, min_timer);
+      *next = std::min(*next, min_timer);
     }
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
       gpr_log(GPR_INFO, "TIMER CHECK SKIP: now=%" PRId64 " min_timer=%" PRId64,

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

@@ -97,7 +97,7 @@ void grpc_timer_heap_destroy(grpc_timer_heap* heap) { gpr_free(heap->timers); }
 bool grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer) {
   if (heap->timer_count == heap->timer_capacity) {
     heap->timer_capacity =
-        GPR_MAX(heap->timer_capacity + 1, heap->timer_capacity * 3 / 2);
+        std::max(heap->timer_capacity + 1, heap->timer_capacity * 3 / 2);
     heap->timers = static_cast<grpc_timer**>(
         gpr_realloc(heap->timers, heap->timer_capacity * sizeof(grpc_timer*)));
   }

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

@@ -41,7 +41,7 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
 }
 
 grpc_error_handle grpc_resolve_unix_domain_address(
-    const char* name, grpc_resolved_addresses** addresses) {
+    absl::string_view name, grpc_resolved_addresses** addresses) {
   *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
   (*addresses)->naddrs = 1;

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

@@ -33,7 +33,7 @@
 void grpc_create_socketpair_if_unix(int sv[2]);
 
 grpc_error_handle grpc_resolve_unix_domain_address(
-    const char* name, grpc_resolved_addresses** addresses);
+    absl::string_view name, grpc_resolved_addresses** addresses);
 
 grpc_error_handle grpc_resolve_unix_abstract_domain_address(
     absl::string_view name, grpc_resolved_addresses** addresses);

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

@@ -34,7 +34,7 @@ void grpc_create_socketpair_if_unix(int /* sv */[2]) {
 }
 
 grpc_error_handle grpc_resolve_unix_domain_address(
-    const char* /* name */, grpc_resolved_addresses** addresses) {
+    absl::string_view /* name */, grpc_resolved_addresses** addresses) {
   *addresses = NULL;
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Unix domain sockets are not supported on Windows");