grpc 1.65.2 → 1.66.0.pre3

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -84,7 +84,6 @@
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/uri/uri_parser.h"
@@ -107,6 +106,13 @@ const char kUnixUriPrefix[] = "unix:";
 const char kUnixAbstractUriPrefix[] = "unix-abstract:";
 const char kVSockUriPrefix[] = "vsock:";
 
+struct AcceptorDeleter {
+  void operator()(grpc_tcp_server_acceptor* acceptor) const {
+    gpr_free(acceptor);
+  }
+};
+using AcceptorPtr = std::unique_ptr<grpc_tcp_server_acceptor, AcceptorDeleter>;
+
 class Chttp2ServerListener : public Server::ListenerInterface {
  public:
   static grpc_error_handle Create(Server* server, grpc_resolved_address* addr,
@@ -167,15 +173,15 @@ class Chttp2ServerListener : public Server::ListenerInterface {
     class HandshakingState : public InternallyRefCounted<HandshakingState> {
      public:
       HandshakingState(RefCountedPtr<ActiveConnection> connection_ref,
-                       grpc_pollset* accepting_pollset,
-                       grpc_tcp_server_acceptor* acceptor,
+                       grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
                        const ChannelArgs& args);
 
       ~HandshakingState() override;
 
       void Orphan() override;
 
-      void Start(grpc_endpoint* endpoint, const ChannelArgs& args);
+      void Start(OrphanablePtr<grpc_endpoint> endpoint,
+                 const ChannelArgs& args);
 
       // Needed to be able to grab an external ref in
       // ActiveConnection::Start()
@@ -184,10 +190,10 @@ class Chttp2ServerListener : public Server::ListenerInterface {
      private:
       void OnTimeout() ABSL_LOCKS_EXCLUDED(&connection_->mu_);
       static void OnReceiveSettings(void* arg, grpc_error_handle /* error */);
-      static void OnHandshakeDone(void* arg, grpc_error_handle error);
+      void OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result);
       RefCountedPtr<ActiveConnection> const connection_;
       grpc_pollset* const accepting_pollset_;
-      grpc_tcp_server_acceptor* acceptor_;
+      AcceptorPtr acceptor_;
       RefCountedPtr<HandshakeManager> handshake_mgr_
           ABSL_GUARDED_BY(&connection_->mu_);
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
@@ -198,8 +204,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       grpc_pollset_set* const interested_parties_;
     };
 
-    ActiveConnection(grpc_pollset* accepting_pollset,
-                     grpc_tcp_server_acceptor* acceptor,
+    ActiveConnection(grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
                      EventEngine* event_engine, const ChannelArgs& args,
                      MemoryOwner memory_owner);
     ~ActiveConnection() override;
@@ -209,7 +214,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
     void SendGoAway();
 
     void Start(RefCountedPtr<Chttp2ServerListener> listener,
-               grpc_endpoint* endpoint, const ChannelArgs& args);
+               OrphanablePtr<grpc_endpoint> endpoint, const ChannelArgs& args);
 
     // Needed to be able to grab an external ref in
     // Chttp2ServerListener::OnAccept()
@@ -367,11 +372,11 @@ Timestamp GetConnectionDeadline(const ChannelArgs& args) {
 
 Chttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
     RefCountedPtr<ActiveConnection> connection_ref,
-    grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
+    grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
     const ChannelArgs& args)
     : connection_(std::move(connection_ref)),
       accepting_pollset_(accepting_pollset),
-      acceptor_(acceptor),
+      acceptor_(std::move(acceptor)),
       handshake_mgr_(MakeRefCounted<HandshakeManager>()),
       deadline_(GetConnectionDeadline(args)),
       interested_parties_(grpc_pollset_set_create()) {
@@ -387,7 +392,6 @@ Chttp2ServerListener::ActiveConnection::HandshakingState::~HandshakingState() {
     grpc_pollset_set_del_pollset(interested_parties_, accepting_pollset_);
   }
   grpc_pollset_set_destroy(interested_parties_);
-  gpr_free(acceptor_);
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::Orphan() {
@@ -401,16 +405,18 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::Orphan() {
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::Start(
-    grpc_endpoint* endpoint, const ChannelArgs& channel_args) {
-  Ref().release();  // Held by OnHandshakeDone
+    OrphanablePtr<grpc_endpoint> endpoint, const ChannelArgs& channel_args) {
   RefCountedPtr<HandshakeManager> handshake_mgr;
   {
     MutexLock lock(&connection_->mu_);
     if (handshake_mgr_ == nullptr) return;
     handshake_mgr = handshake_mgr_;
   }
-  handshake_mgr->DoHandshake(endpoint, channel_args, deadline_, acceptor_,
-                             OnHandshakeDone, this);
+  handshake_mgr->DoHandshake(
+      std::move(endpoint), channel_args, deadline_, acceptor_.get(),
+      [self = Ref()](absl::StatusOr<HandshakerArgs*> result) {
+        self->OnHandshakeDone(std::move(result));
+      });
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::OnTimeout() {
@@ -444,61 +450,50 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
-    void* arg, grpc_error_handle error) {
-  auto* args = static_cast<HandshakerArgs*>(arg);
-  HandshakingState* self = static_cast<HandshakingState*>(args->user_data);
+    absl::StatusOr<HandshakerArgs*> result) {
   OrphanablePtr<HandshakingState> handshaking_state_ref;
   RefCountedPtr<HandshakeManager> handshake_mgr;
   bool cleanup_connection = false;
   bool release_connection = false;
   {
-    MutexLock connection_lock(&self->connection_->mu_);
-    if (!error.ok() || self->connection_->shutdown_) {
-      std::string error_str = StatusToString(error);
+    MutexLock connection_lock(&connection_->mu_);
+    if (!result.ok() || connection_->shutdown_) {
       cleanup_connection = true;
       release_connection = true;
-      if (error.ok() && args->endpoint != nullptr) {
-        // We were shut down or stopped serving after handshaking completed
-        // successfully, so destroy the endpoint here.
-        grpc_endpoint_destroy(args->endpoint);
-        grpc_slice_buffer_destroy(args->read_buffer);
-        gpr_free(args->read_buffer);
-      }
     } else {
       // If the handshaking succeeded but there is no endpoint, then the
       // handshaker may have handed off the connection to some external
       // code, so we can just clean up here without creating a transport.
-      if (args->endpoint != nullptr) {
+      if ((*result)->endpoint != nullptr) {
         RefCountedPtr<Transport> transport =
-            grpc_create_chttp2_transport(args->args, args->endpoint, false)
+            grpc_create_chttp2_transport((*result)->args,
+                                         std::move((*result)->endpoint), false)
                 ->Ref();
         grpc_error_handle channel_init_err =
-            self->connection_->listener_->server_->SetupTransport(
-                transport.get(), self->accepting_pollset_, args->args,
+            connection_->listener_->server_->SetupTransport(
+                transport.get(), accepting_pollset_, (*result)->args,
                 grpc_chttp2_transport_get_socket_node(transport.get()));
         if (channel_init_err.ok()) {
           // Use notify_on_receive_settings callback to enforce the
           // handshake deadline.
-          self->connection_->transport_ =
+          connection_->transport_ =
               DownCast<grpc_chttp2_transport*>(transport.get())->Ref();
-          self->Ref().release();  // Held by OnReceiveSettings().
-          GRPC_CLOSURE_INIT(&self->on_receive_settings_, OnReceiveSettings,
-                            self, grpc_schedule_on_exec_ctx);
+          Ref().release();  // Held by OnReceiveSettings().
+          GRPC_CLOSURE_INIT(&on_receive_settings_, OnReceiveSettings, this,
+                            grpc_schedule_on_exec_ctx);
           // If the listener has been configured with a config fetcher, we
           // need to watch on the transport being closed so that we can an
           // updated list of active connections.
           grpc_closure* on_close = nullptr;
-          if (self->connection_->listener_->config_fetcher_watcher_ !=
-              nullptr) {
+          if (connection_->listener_->config_fetcher_watcher_ != nullptr) {
             // Refs helds by OnClose()
-            self->connection_->Ref().release();
-            on_close = &self->connection_->on_close_;
+            connection_->Ref().release();
+            on_close = &connection_->on_close_;
           } else {
             // Remove the connection from the connections_ map since OnClose()
             // will not be invoked when a config fetcher is set.
             auto connection_quota =
-                self->connection_->listener_->connection_quota_->Ref()
-                    .release();
+                connection_->listener_->connection_quota_->Ref().release();
             auto on_close_transport = [](void* arg,
                                          grpc_error_handle /*handle*/) {
               ConnectionQuota* connection_quota =
@@ -511,11 +506,10 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
             cleanup_connection = true;
           }
           grpc_chttp2_transport_start_reading(
-              transport.get(), args->read_buffer, &self->on_receive_settings_,
-              nullptr, on_close);
-          self->timer_handle_ = self->connection_->event_engine_->RunAfter(
-              self->deadline_ - Timestamp::Now(),
-              [self = self->Ref()]() mutable {
+              transport.get(), (*result)->read_buffer.c_slice_buffer(),
+              &on_receive_settings_, nullptr, on_close);
+          timer_handle_ = connection_->event_engine_->RunAfter(
+              deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
                 ApplicationCallbackExecCtx callback_exec_ctx;
                 ExecCtx exec_ctx;
                 self->OnTimeout();
@@ -527,8 +521,6 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           LOG(ERROR) << "Failed to create channel: "
                      << StatusToString(channel_init_err);
           transport->Orphan();
-          grpc_slice_buffer_destroy(args->read_buffer);
-          gpr_free(args->read_buffer);
           cleanup_connection = true;
           release_connection = true;
         }
@@ -541,25 +533,21 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
     // shutdown the handshake when the listener needs to stop serving.
     // Avoid calling the destructor of HandshakeManager and HandshakingState
     // from within the critical region.
-    handshake_mgr = std::move(self->handshake_mgr_);
-    handshaking_state_ref = std::move(self->connection_->handshaking_state_);
+    handshake_mgr = std::move(handshake_mgr_);
+    handshaking_state_ref = std::move(connection_->handshaking_state_);
   }
-  gpr_free(self->acceptor_);
-  self->acceptor_ = nullptr;
   OrphanablePtr<ActiveConnection> connection;
   if (cleanup_connection) {
-    MutexLock listener_lock(&self->connection_->listener_->mu_);
+    MutexLock listener_lock(&connection_->listener_->mu_);
     if (release_connection) {
-      self->connection_->listener_->connection_quota_->ReleaseConnections(1);
+      connection_->listener_->connection_quota_->ReleaseConnections(1);
     }
-    auto it = self->connection_->listener_->connections_.find(
-        self->connection_.get());
-    if (it != self->connection_->listener_->connections_.end()) {
+    auto it = connection_->listener_->connections_.find(connection_.get());
+    if (it != connection_->listener_->connections_.end()) {
       connection = std::move(it->second);
-      self->connection_->listener_->connections_.erase(it);
+      connection_->listener_->connections_.erase(it);
     }
   }
-  self->Unref();
 }
 
 //
@@ -567,11 +555,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
 //
 
 Chttp2ServerListener::ActiveConnection::ActiveConnection(
-    grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
+    grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
     EventEngine* event_engine, const ChannelArgs& args,
     MemoryOwner memory_owner)
     : handshaking_state_(memory_owner.MakeOrphanable<HandshakingState>(
-          Ref(), accepting_pollset, acceptor, args)),
+          Ref(), accepting_pollset, std::move(acceptor), args)),
       event_engine_(event_engine) {
   GRPC_CLOSURE_INIT(&on_close_, ActiveConnection::OnClose, this,
                     grpc_schedule_on_exec_ctx);
@@ -625,29 +613,21 @@ void Chttp2ServerListener::ActiveConnection::SendGoAway() {
 }
 
 void Chttp2ServerListener::ActiveConnection::Start(
-    RefCountedPtr<Chttp2ServerListener> listener, grpc_endpoint* endpoint,
-    const ChannelArgs& args) {
-  RefCountedPtr<HandshakingState> handshaking_state_ref;
+    RefCountedPtr<Chttp2ServerListener> listener,
+    OrphanablePtr<grpc_endpoint> endpoint, const ChannelArgs& args) {
   listener_ = std::move(listener);
-  if (listener_->tcp_server_ != nullptr) {
-    grpc_tcp_server_ref(listener_->tcp_server_);
-  }
+  RefCountedPtr<HandshakingState> handshaking_state_ref;
   {
-    ReleasableMutexLock lock(&mu_);
-    if (shutdown_) {
-      lock.Release();
-      // If the Connection is already shutdown at this point, it implies the
-      // owning Chttp2ServerListener and all associated ActiveConnections have
-      // been orphaned. The generated endpoints need to be shutdown here to
-      // ensure the tcp connections are closed appropriately.
-      grpc_endpoint_destroy(endpoint);
-      return;
-    }
+    MutexLock lock(&mu_);
+    // If the Connection is already shutdown at this point, it implies the
+    // owning Chttp2ServerListener and all associated ActiveConnections have
+    // been orphaned.
+    if (shutdown_) return;
     // Hold a ref to HandshakingState to allow starting the handshake outside
     // the critical region.
     handshaking_state_ref = handshaking_state_->Ref();
   }
-  handshaking_state_ref->Start(endpoint, args);
+  handshaking_state_ref->Start(std::move(endpoint), args);
 }
 
 void Chttp2ServerListener::ActiveConnection::OnClose(
@@ -841,48 +821,41 @@ void Chttp2ServerListener::AcceptConnectedEndpoint(
 
 void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
                                     grpc_pollset* accepting_pollset,
-                                    grpc_tcp_server_acceptor* acceptor) {
+                                    grpc_tcp_server_acceptor* server_acceptor) {
   Chttp2ServerListener* self = static_cast<Chttp2ServerListener*>(arg);
   ChannelArgs args = self->args_;
+  OrphanablePtr<grpc_endpoint> endpoint(tcp);
+  AcceptorPtr acceptor(server_acceptor);
   RefCountedPtr<grpc_server_config_fetcher::ConnectionManager>
       connection_manager;
   {
     MutexLock lock(&self->mu_);
     connection_manager = self->connection_manager_;
   }
-  auto endpoint_cleanup = [&]() {
-    grpc_endpoint_destroy(tcp);
-    gpr_free(acceptor);
-  };
   if (!self->connection_quota_->AllowIncomingConnection(
-          self->memory_quota_, grpc_endpoint_get_peer(tcp))) {
-    endpoint_cleanup();
+          self->memory_quota_, grpc_endpoint_get_peer(endpoint.get()))) {
     return;
   }
   if (self->config_fetcher_ != nullptr) {
     if (connection_manager == nullptr) {
-      endpoint_cleanup();
       return;
     }
     absl::StatusOr<ChannelArgs> args_result =
         connection_manager->UpdateChannelArgsForConnection(args, tcp);
     if (!args_result.ok()) {
-      endpoint_cleanup();
       return;
     }
     grpc_error_handle error;
     args = self->args_modifier_(*args_result, &error);
     if (!error.ok()) {
-      endpoint_cleanup();
       return;
     }
   }
   auto memory_owner = self->memory_quota_->CreateMemoryOwner();
   EventEngine* const event_engine = self->args_.GetObject<EventEngine>();
   auto connection = memory_owner.MakeOrphanable<ActiveConnection>(
-      accepting_pollset, acceptor, event_engine, args, std::move(memory_owner));
-  // We no longer own acceptor
-  acceptor = nullptr;
+      accepting_pollset, std::move(acceptor), event_engine, args,
+      std::move(memory_owner));
   // Hold a ref to connection to allow starting handshake outside the
   // critical region
   RefCountedPtr<ActiveConnection> connection_ref = connection->Ref();
@@ -893,19 +866,21 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     // connection manager has changed.
     if (!self->shutdown_ && self->is_serving_ &&
         connection_manager == self->connection_manager_) {
-      // This ref needs to be taken in the critical region after having made
-      // sure that the listener has not been Orphaned, so as to avoid
-      // heap-use-after-free issues where `Ref()` is invoked when the ref of
-      // tcp_server_ has already reached 0. (Ref() implementation of
-      // Chttp2ServerListener is grpc_tcp_server_ref().)
+      // The ref for both the listener and tcp_server need to be taken in the
+      // critical region after having made sure that the listener has not been
+      // Orphaned, so as to avoid heap-use-after-free issues where `Ref()` is
+      // invoked when the listener is already shutdown. Note that the listener
+      // holds a ref to the tcp_server but this ref is given away when the
+      // listener is orphaned (shutdown).
+      if (self->tcp_server_ != nullptr) {
+        grpc_tcp_server_ref(self->tcp_server_);
+      }
       listener_ref = self->RefAsSubclass<Chttp2ServerListener>();
       self->connections_.emplace(connection.get(), std::move(connection));
     }
   }
-  if (connection != nullptr) {
-    endpoint_cleanup();
-  } else {
-    connection_ref->Start(std::move(listener_ref), tcp, args);
+  if (connection == nullptr && listener_ref != nullptr) {
+    connection_ref->Start(std::move(listener_ref), std::move(endpoint), args);
   }
 }
 
@@ -1103,8 +1078,8 @@ int grpc_server_add_http2_port(grpc_server* server, const char* addr,
   int port_num = 0;
   grpc_core::Server* core_server = grpc_core::Server::FromC(server);
   grpc_core::ChannelArgs args = core_server->channel_args();
-  GRPC_API_TRACE("grpc_server_add_http2_port(server=%p, addr=%s, creds=%p)", 3,
-                 (server, addr, creds));
+  GRPC_TRACE_LOG(api, INFO) << "grpc_server_add_http2_port(server=" << server
+                            << ", addr=" << addr << ", creds=" << creds << ")";
   // Create security context.
   if (creds == nullptr) {
     err = GRPC_ERROR_CREATE(
@@ -1161,15 +1136,17 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
   std::string name = absl::StrCat("fd:", fd);
   auto memory_quota =
       server_args.GetObject<grpc_core::ResourceQuota>()->memory_quota();
-  grpc_endpoint* server_endpoint = grpc_tcp_create_from_fd(
-      grpc_fd_create(fd, name.c_str(), true),
-      grpc_event_engine::experimental::ChannelArgsEndpointConfig(server_args),
-      name);
+  grpc_core::OrphanablePtr<grpc_endpoint> server_endpoint(
+      grpc_tcp_create_from_fd(
+          grpc_fd_create(fd, name.c_str(), true),
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(
+              server_args),
+          name));
   for (grpc_pollset* pollset : core_server->pollsets()) {
-    grpc_endpoint_add_to_pollset(server_endpoint, pollset);
+    grpc_endpoint_add_to_pollset(server_endpoint.get(), pollset);
   }
   grpc_core::Transport* transport = grpc_create_chttp2_transport(
-      server_args, server_endpoint, false  // is_client
+      server_args, std::move(server_endpoint), false  // is_client
   );
   grpc_error_handle error =
       core_server->SetupTransport(transport, nullptr, server_args, nullptr);
@@ -1197,8 +1174,9 @@ absl::Status grpc_server_add_passive_listener(
     std::shared_ptr<grpc_core::experimental::PassiveListenerImpl>
         passive_listener) {
   grpc_core::ExecCtx exec_ctx;
-  GRPC_API_TRACE("grpc_server_add_passive_listener(server=%p, credentials=%p)",
-                 2, (server, credentials));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_server_add_passive_listener(server=" << server
+      << ", credentials=" << credentials << ")";
   // Create security context.
   if (credentials == nullptr) {
     return absl::UnavailableError(

data/src/core/ext/transport/chttp2/transport/bin_decoder.cc

@@ -20,9 +20,9 @@
 
 #include "absl/base/attributes.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice.h"
@@ -58,10 +58,8 @@ static bool input_is_valid(const uint8_t* input_ptr, size_t length) {
 
   for (i = 0; i < length; ++i) {
     if (GPR_UNLIKELY((decode_table[input_ptr[i]] & 0xC0) != 0)) {
-      gpr_log(GPR_ERROR,
-              "Base64 decoding failed, invalid character '%c' in base64 "
-              "input.\n",
-              static_cast<char>(*input_ptr));
+      LOG(ERROR) << "Base64 decoding failed, invalid character '"
+                 << static_cast<char>(*input_ptr) << "' in base64 input.\n";
       return false;
     }
   }
@@ -89,17 +87,14 @@ size_t grpc_chttp2_base64_infer_length_after_decode(const grpc_slice& slice) {
     len--;
   }
   if (GPR_UNLIKELY(GRPC_SLICE_LENGTH(slice) - len > 2)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed. Input has more than 2 paddings.");
+    LOG(ERROR) << "Base64 decoding failed. Input has more than 2 paddings.";
     return 0;
   }
   size_t tuples = len / 4;
   size_t tail_case = len % 4;
   if (GPR_UNLIKELY(tail_case == 1)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed. Input has a length of %zu (without"
-            " padding), which is invalid.\n",
-            len);
+    LOG(ERROR) << "Base64 decoding failed. Input has a length of " << len
+               << " (without padding), which is invalid.\n";
     return 0;
   }
   return tuples * 3 + tail_xtra[tail_case];
@@ -167,11 +162,9 @@ grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input) {
   grpc_slice output;
 
   if (GPR_UNLIKELY(input_length % 4 != 0)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed, input of "
-            "grpc_chttp2_base64_decode has a length of %d, which is not a "
-            "multiple of 4.\n",
-            static_cast<int>(input_length));
+    LOG(ERROR) << "Base64 decoding failed, input of "
+                  "grpc_chttp2_base64_decode has a length of "
+               << input_length << ", which is not a multiple of 4.\n";
     return grpc_empty_slice();
   }
 
@@ -194,7 +187,7 @@ grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input) {
 
   if (GPR_UNLIKELY(!grpc_base64_decode_partial(&ctx))) {
     char* s = grpc_slice_to_c_string(input);
-    gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s);
+    LOG(ERROR) << "Base64 decoding failed, input string:\n" << s << "\n";
     gpr_free(s);
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();
@@ -212,23 +205,18 @@ grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
 
   // The length of a base64 string cannot be 4 * n + 1
   if (GPR_UNLIKELY(input_length % 4 == 1)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed, input of "
-            "grpc_chttp2_base64_decode_with_length has a length of %d, which "
-            "has a tail of 1 byte.\n",
-            static_cast<int>(input_length));
+    LOG(ERROR) << "Base64 decoding failed, input of "
+                  "grpc_chttp2_base64_decode_with_length has a length of "
+               << input_length << ", which has a tail of 1 byte.\n";
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();
   }
 
   if (GPR_UNLIKELY(output_length >
                    input_length / 4 * 3 + tail_xtra[input_length % 4])) {
-    gpr_log(
-        GPR_ERROR,
-        "Base64 decoding failed, output_length %d is longer "
-        "than the max possible output length %d.\n",
-        static_cast<int>(output_length),
-        static_cast<int>(input_length / 4 * 3 + tail_xtra[input_length % 4]));
+    LOG(ERROR) << "Base64 decoding failed, output_length " << output_length
+               << " is longer than the max possible output length "
+               << (input_length / 4 * 3 + tail_xtra[input_length % 4]) << ".\n";
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();
   }
@@ -241,7 +229,7 @@ grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
 
   if (GPR_UNLIKELY(!grpc_base64_decode_partial(&ctx))) {
     char* s = grpc_slice_to_c_string(input);
-    gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s);
+    LOG(ERROR) << "Base64 decoding failed, input string:\n" << s << "\n";
     gpr_free(s);
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();