grpc 1.24.0 → 1.25.0.pre1

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

@@ -124,13 +124,15 @@ bool grpc_resource_user_safe_alloc(grpc_resource_user* resource_user,
  * If optional_on_done is NULL, then allocate immediately. This may push the
  * quota over-limit, at which point reclamation will kick in. The caller is
  * always responsible to free the memory eventually.
- * If optional_on_done is non-NULL, it will be scheduled without error when the
- * allocation has been granted by the quota, and the caller is responsible to
- * free the memory eventually. Or it may be scheduled with an error, in which
- * case the caller fails to allocate the memory and shouldn't free the memory.
+ * Returns true if the allocation was successful. Otherwise, if optional_on_done
+ * is non-NULL, it will be scheduled without error when the allocation has been
+ * granted by the quota, and the caller is responsible to free the memory
+ * eventually. Or it may be scheduled with an error, in which case the caller
+ * fails to allocate the memory and shouldn't free the memory.
  */
-void grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
-                              grpc_closure* optional_on_done);
+bool grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
+                              grpc_closure* optional_on_done)
+    GRPC_MUST_USE_RESULT;
 /* Release memory back to the quota */
 void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size);
 /* Post a memory reclaimer to the resource user. Only one benign and one
@@ -165,9 +167,11 @@ void grpc_resource_user_slice_allocator_init(
     grpc_resource_user* resource_user, grpc_iomgr_cb_func cb, void* p);
 
 /* Allocate \a count slices of length \a length into \a dest. Only one request
-   can be outstanding at a time. */
-void grpc_resource_user_alloc_slices(
+   can be outstanding at a time.
+   Returns whether the slice was allocated inline in the function. If true,
+   the \a slice_allocator->on_allocated callback will not be called. */
+bool grpc_resource_user_alloc_slices(
     grpc_resource_user_slice_allocator* slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer* dest);
+    size_t count, grpc_slice_buffer* dest) GRPC_MUST_USE_RESULT;
 
 #endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */

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

@@ -330,6 +330,19 @@ grpc_error* grpc_set_socket_with_mutator(int fd, grpc_socket_mutator* mutator) {
   return GRPC_ERROR_NONE;
 }
 
+grpc_error* grpc_apply_socket_mutator_in_args(int fd,
+                                              const grpc_channel_args* args) {
+  const grpc_arg* socket_mutator_arg =
+      grpc_channel_args_find(args, GRPC_ARG_SOCKET_MUTATOR);
+  if (socket_mutator_arg == nullptr) {
+    return GRPC_ERROR_NONE;
+  }
+  GPR_DEBUG_ASSERT(socket_mutator_arg->type == GRPC_ARG_POINTER);
+  grpc_socket_mutator* mutator =
+      static_cast<grpc_socket_mutator*>(socket_mutator_arg->value.pointer.p);
+  return grpc_set_socket_with_mutator(fd, mutator);
+}
+
 static gpr_once g_probe_ipv6_once = GPR_ONCE_INIT;
 static int g_ipv6_loopback_available;
 

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

@@ -91,6 +91,10 @@ grpc_error* grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes);
 /* Tries to set the socket using a grpc_socket_mutator */
 grpc_error* grpc_set_socket_with_mutator(int fd, grpc_socket_mutator* mutator);
 
+/* Extracts the first socket mutator from args if any and applies on the fd. */
+grpc_error* grpc_apply_socket_mutator_in_args(int fd,
+                                              const grpc_channel_args* args);
+
 /* An enum to keep track of IPv4/IPv6 socket modes.
 
    Currently, this information is only used when a socket is first created, but

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

@@ -84,17 +84,10 @@ static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (err != GRPC_ERROR_NONE) goto error;
-  if (channel_args) {
-    for (size_t i = 0; i < channel_args->num_args; i++) {
-      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) {
-        GPR_ASSERT(channel_args->args[i].type == GRPC_ARG_POINTER);
-        grpc_socket_mutator* mutator = static_cast<grpc_socket_mutator*>(
-            channel_args->args[i].value.pointer.p);
-        err = grpc_set_socket_with_mutator(fd, mutator);
-        if (err != GRPC_ERROR_NONE) goto error;
-      }
-    }
-  }
+
+  err = grpc_apply_socket_mutator_in_args(fd, channel_args);
+  if (err != GRPC_ERROR_NONE) goto error;
+
   goto done;
 
 error:

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

@@ -193,7 +193,7 @@ static void tcp_read_allocation_done(void* tcpp, grpc_error* error) {
 }
 
 static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
-                          grpc_closure* cb, bool urgent) {
+                          grpc_closure* cb, bool /*urgent*/) {
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   GPR_ASSERT(tcp->read_cb == nullptr);
@@ -201,9 +201,11 @@ static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   tcp->read_slices = read_slices;
   grpc_slice_buffer_reset_and_unref_internal(read_slices);
   TCP_REF(tcp, "read");
-  grpc_resource_user_alloc_slices(&tcp->slice_allocator,
-                                  GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
-                                  tcp->read_slices);
+  if (grpc_resource_user_alloc_slices(&tcp->slice_allocator,
+                                      GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
+                                      tcp->read_slices)) {
+    tcp_read_allocation_done(tcp, GRPC_ERROR_NONE);
+  }
 }
 
 static void custom_write_callback(grpc_custom_socket* socket,
@@ -222,7 +224,7 @@ static void custom_write_callback(grpc_custom_socket* socket,
 }
 
 static void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* write_slices,
-                           grpc_closure* cb, void* arg) {
+                           grpc_closure* cb, void* /*arg*/) {
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
@@ -325,9 +327,9 @@ static grpc_resource_user* endpoint_get_resource_user(grpc_endpoint* ep) {
   return tcp->resource_user;
 }
 
-static int endpoint_get_fd(grpc_endpoint* ep) { return -1; }
+static int endpoint_get_fd(grpc_endpoint* /*ep*/) { return -1; }
 
-static bool endpoint_can_track_err(grpc_endpoint* ep) { return false; }
+static bool endpoint_can_track_err(grpc_endpoint* /*ep*/) { return false; }
 
 static grpc_endpoint_vtable vtable = {endpoint_read,
                                       endpoint_write,

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

@@ -161,7 +161,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */, grpc_error* error);
 static void tcp_drop_uncovered_then_handle_write(void* arg /* grpc_tcp */,
                                                  grpc_error* error);
 
-static void done_poller(void* bp, grpc_error* error_ignored) {
+static void done_poller(void* bp, grpc_error* /*error_ignored*/) {
   backup_poller* p = static_cast<backup_poller*>(bp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "BACKUP_POLLER:%p destroy", p);
@@ -170,7 +170,7 @@ static void done_poller(void* bp, grpc_error* error_ignored) {
   gpr_free(p);
 }
 
-static void run_poller(void* bp, grpc_error* error_ignored) {
+static void run_poller(void* bp, grpc_error* /*error_ignored*/) {
   backup_poller* p = static_cast<backup_poller*>(bp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "BACKUP_POLLER:%p run", p);
@@ -206,7 +206,7 @@ static void run_poller(void* bp, grpc_error* error_ignored) {
   }
 }
 
-static void drop_uncovered(grpc_tcp* tcp) {
+static void drop_uncovered(grpc_tcp* /*tcp*/) {
   backup_poller* p = (backup_poller*)gpr_atm_acq_load(&g_backup_poller);
   gpr_atm old_count =
       gpr_atm_full_fetch_add(&g_uncovered_notifications_pending, -1);
@@ -571,7 +571,7 @@ static void tcp_read_allocation_done(void* tcpp, grpc_error* error) {
     gpr_log(GPR_INFO, "TCP:%p read_allocation_done: %s", tcp,
             grpc_error_string(error));
   }
-  if (error != GRPC_ERROR_NONE) {
+  if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
     grpc_slice_buffer_reset_and_unref_internal(tcp->incoming_buffer);
     grpc_slice_buffer_reset_and_unref_internal(&tcp->last_read_buffer);
     call_read_cb(tcp, GRPC_ERROR_REF(error));
@@ -589,14 +589,17 @@ static void tcp_continue_read(grpc_tcp* tcp) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       gpr_log(GPR_INFO, "TCP:%p alloc_slices", tcp);
     }
-    grpc_resource_user_alloc_slices(&tcp->slice_allocator, target_read_size, 1,
-                                    tcp->incoming_buffer);
-  } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-      gpr_log(GPR_INFO, "TCP:%p do_read", tcp);
+    if (GPR_UNLIKELY(!grpc_resource_user_alloc_slices(&tcp->slice_allocator,
+                                                      target_read_size, 1,
+                                                      tcp->incoming_buffer))) {
+      // Wait for allocation.
+      return;
     }
-    tcp_do_read(tcp);
   }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+    gpr_log(GPR_INFO, "TCP:%p do_read", tcp);
+  }
+  tcp_do_read(tcp);
 }
 
 static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error* error) {
@@ -605,7 +608,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error* error) {
     gpr_log(GPR_INFO, "TCP:%p got_read: %s", tcp, grpc_error_string(error));
   }
 
-  if (error != GRPC_ERROR_NONE) {
+  if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
     grpc_slice_buffer_reset_and_unref_internal(tcp->incoming_buffer);
     grpc_slice_buffer_reset_and_unref_internal(&tcp->last_read_buffer);
     call_read_cb(tcp, GRPC_ERROR_REF(error));
@@ -873,15 +876,16 @@ static void tcp_handle_error(void* arg /* grpc_tcp */, grpc_error* error) {
 }
 
 #else  /* GRPC_LINUX_ERRQUEUE */
-static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
-                                      size_t sending_length,
-                                      ssize_t* sent_length) {
+static bool tcp_write_with_timestamps(grpc_tcp* /*tcp*/, struct msghdr* /*msg*/,
+                                      size_t /*sending_length*/,
+                                      ssize_t* /*sent_length*/) {
   gpr_log(GPR_ERROR, "Write with timestamps not supported for this platform");
   GPR_ASSERT(0);
   return false;
 }
 
-static void tcp_handle_error(void* arg /* grpc_tcp */, grpc_error* error) {
+static void tcp_handle_error(void* /*arg*/ /* grpc_tcp */,
+                             grpc_error* /*error*/) {
   gpr_log(GPR_ERROR, "Error handling is not supported for this platform");
   GPR_ASSERT(0);
 }
@@ -1040,7 +1044,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */, grpc_error* error) {
       gpr_log(GPR_INFO, "write: %s", str);
     }
     // No need to take a ref on error since tcp_flush provides a ref.
-    GRPC_CLOSURE_SCHED(cb, error);
+    GRPC_CLOSURE_RUN(cb, error);
     TCP_UNREF(tcp, "write");
   }
 }

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

@@ -24,7 +24,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
 
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -57,9 +56,7 @@ class TcpServerFdHandler {
  public:
   virtual ~TcpServerFdHandler() = default;
   virtual void Handle(int listener_fd, int fd,
-                      grpc_byte_buffer* pending_read) GRPC_ABSTRACT;
-
-  GRPC_ABSTRACT_BASE_CLASS;
+                      grpc_byte_buffer* pending_read) = 0;
 };
 }  // namespace grpc_core
 

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

@@ -439,13 +439,13 @@ static void tcp_server_start(grpc_tcp_server* server, grpc_pollset** pollsets,
   }
 }
 
-static unsigned tcp_server_port_fd_count(grpc_tcp_server* s,
-                                         unsigned port_index) {
+static unsigned tcp_server_port_fd_count(grpc_tcp_server* /*s*/,
+                                         unsigned /*port_index*/) {
   return 0;
 }
 
-static int tcp_server_port_fd(grpc_tcp_server* s, unsigned port_index,
-                              unsigned fd_index) {
+static int tcp_server_port_fd(grpc_tcp_server* /*s*/, unsigned /*port_index*/,
+                              unsigned /*fd_index*/) {
   return -1;
 }
 
@@ -459,7 +459,7 @@ static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {
 }
 
 static grpc_core::TcpServerFdHandler* tcp_server_create_fd_handler(
-    grpc_tcp_server* s) {
+    grpc_tcp_server* /*s*/) {
   return nullptr;
 }
 

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

@@ -124,7 +124,7 @@ static void finish_shutdown(grpc_tcp_server* s) {
   gpr_free(s);
 }
 
-static void destroyed_port(void* server, grpc_error* error) {
+static void destroyed_port(void* server, grpc_error* /*error*/) {
   grpc_tcp_server* s = static_cast<grpc_tcp_server*>(server);
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;

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

@@ -173,17 +173,8 @@ grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (err != GRPC_ERROR_NONE) goto error;
 
-  if (s->channel_args) {
-    for (size_t i = 0; i < s->channel_args->num_args; i++) {
-      if (0 == strcmp(s->channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) {
-        GPR_ASSERT(s->channel_args->args[i].type == GRPC_ARG_POINTER);
-        grpc_socket_mutator* mutator = static_cast<grpc_socket_mutator*>(
-            s->channel_args->args[i].value.pointer.p);
-        err = grpc_set_socket_with_mutator(fd, mutator);
-        if (err != GRPC_ERROR_NONE) goto error;
-      }
-    }
-  }
+  err = grpc_apply_socket_mutator_in_args(fd, s->channel_args);
+  if (err != GRPC_ERROR_NONE) goto error;
 
   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
            addr->len) < 0) {

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

@@ -30,7 +30,7 @@
 
 static grpc_custom_timer_vtable* custom_timer_impl;
 
-void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* error) {
+void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* /*error*/) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
@@ -75,7 +75,7 @@ static void timer_cancel(grpc_timer* timer) {
   }
 }
 
-static grpc_timer_check_result timer_check(grpc_millis* next) {
+static grpc_timer_check_result timer_check(grpc_millis* /*next*/) {
   return GRPC_TIMERS_NOT_CHECKED;
 }
 

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

@@ -260,7 +260,7 @@ static void finish_shutdown(grpc_udp_server* s) {
   grpc_core::Delete(s);
 }
 
-static void destroyed_port(void* server, grpc_error* error) {
+static void destroyed_port(void* server, grpc_error* /*error*/) {
   grpc_udp_server* s = static_cast<grpc_udp_server*>(server);
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;
@@ -495,7 +495,8 @@ void GrpcUdpListener::OnRead(grpc_error* error, void* do_read_arg) {
 
 // static
 // Wrapper of grpc_fd_notify_on_write() with a grpc_closure callback interface.
-void GrpcUdpListener::fd_notify_on_write_wrapper(void* arg, grpc_error* error) {
+void GrpcUdpListener::fd_notify_on_write_wrapper(void* arg,
+                                                 grpc_error* /*error*/) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   gpr_mu_lock(sp->mutex());
   if (!sp->notify_on_write_armed_) {

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

@@ -21,7 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -39,7 +38,7 @@ typedef struct grpc_udp_server grpc_udp_server;
  * Its implementation should do the real IO work, e.g. read packet and write. */
 class GrpcUdpHandler {
  public:
-  GrpcUdpHandler(grpc_fd* emfd, void* user_data) {}
+  GrpcUdpHandler(grpc_fd* /* emfd */, void* /* user_data */) {}
   virtual ~GrpcUdpHandler() {}
 
   // Interfaces to be implemented by subclasses to do the actual setup/tear down
@@ -47,18 +46,16 @@ class GrpcUdpHandler {
 
   // Called when data is available to read from the socket. Returns true if
   // there is more data to read after this call.
-  virtual bool Read() GRPC_ABSTRACT;
+  virtual bool Read() = 0;
   // Called when socket becomes write unblocked. The given closure should be
   // scheduled when the socket becomes blocked next time.
   virtual void OnCanWrite(void* user_data,
-                          grpc_closure* notify_on_write_closure) GRPC_ABSTRACT;
+                          grpc_closure* notify_on_write_closure) = 0;
   // Called before the gRPC FD is orphaned. Notify udp server to continue
   // orphaning fd by scheduling the given closure, afterwards the associated fd
   // will be closed.
   virtual void OnFdAboutToOrphan(grpc_closure* orphan_fd_closure,
-                                 void* user_data) GRPC_ABSTRACT;
-
-  GRPC_ABSTRACT_BASE_CLASS
+                                 void* user_data) = 0;
 };
 
 class GrpcUdpHandlerFactory {
@@ -67,11 +64,8 @@ class GrpcUdpHandlerFactory {
   /* Called when start to listen on a socket.
    * Return an instance of the implementation of GrpcUdpHandler interface which
    * will process I/O events for this socket from now on. */
-  virtual GrpcUdpHandler* CreateUdpHandler(grpc_fd* emfd,
-                                           void* user_data) GRPC_ABSTRACT;
-  virtual void DestroyUdpHandler(GrpcUdpHandler* handler) GRPC_ABSTRACT;
-
-  GRPC_ABSTRACT_BASE_CLASS
+  virtual GrpcUdpHandler* CreateUdpHandler(grpc_fd* emfd, void* user_data) = 0;
+  virtual void DestroyUdpHandler(GrpcUdpHandler* handler) = 0;
 };
 
 /* Create a server, initially not bound to any ports */

data/src/core/lib/json/json.h

@@ -67,7 +67,7 @@ grpc_json* grpc_json_parse_string(char* input);
  * If indent is 0, then newlines will be suppressed as well, and the
  * output will be condensed at its maximum.
  */
-char* grpc_json_dump_to_string(grpc_json* json, int indent);
+char* grpc_json_dump_to_string(const grpc_json* json, int indent);
 
 /* Use these to create or delete a grpc_json object.
  * Deletion is recursive. We will not attempt to free any of the strings

data/src/core/lib/json/json_string.cc

@@ -311,7 +311,7 @@ grpc_json* grpc_json_parse_string(char* input) {
   return grpc_json_parse_string_with_len(input, UNBOUND_JSON_STRING_LENGTH);
 }
 
-static void json_dump_recursive(grpc_json_writer* writer, grpc_json* json,
+static void json_dump_recursive(grpc_json_writer* writer, const grpc_json* json,
                                 int in_object) {
   while (json) {
     if (in_object) grpc_json_writer_object_key(writer, json->key);
@@ -351,7 +351,7 @@ static grpc_json_writer_vtable writer_vtable = {
     json_writer_output_char, json_writer_output_string,
     json_writer_output_string_with_len};
 
-char* grpc_json_dump_to_string(grpc_json* json, int indent) {
+char* grpc_json_dump_to_string(const grpc_json* json, int indent) {
   grpc_json_writer writer;
   json_writer_userdata state;
 

data/src/core/lib/profiling/basic_timers.cc

@@ -287,7 +287,7 @@ void gpr_timers_global_init(void) {}
 
 void gpr_timers_global_destroy(void) {}
 
-void gpr_timers_set_log_filename(const char* filename) {}
+void gpr_timers_set_log_filename(const char* /*filename*/) {}
 
-void gpr_timer_set_enabled(int enabled) {}
+void gpr_timer_set_enabled(int /*enabled*/) {}
 #endif /* GRPC_BASIC_PROFILER */

data/src/core/lib/security/credentials/alts/alts_credentials.cc

@@ -50,8 +50,8 @@ grpc_alts_credentials::~grpc_alts_credentials() {
 grpc_core::RefCountedPtr<grpc_channel_security_connector>
 grpc_alts_credentials::create_security_connector(
     grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-    const char* target_name, const grpc_channel_args* args,
-    grpc_channel_args** new_args) {
+    const char* target_name, const grpc_channel_args* /*args*/,
+    grpc_channel_args** /*new_args*/) {
   return grpc_alts_channel_security_connector_create(
       this->Ref(), std::move(call_creds), target_name);
 }