grpc 1.50.0 → 1.51.0

data/src/core/lib/event_engine/thread_pool.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <atomic>
 #include <memory>
 #include <queue>
@@ -28,19 +30,28 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/functional/any_invocable.h"
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/event_engine/executor/executor.h"
 #include "src/core/lib/event_engine/forkable.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-class ThreadPool final : public grpc_event_engine::experimental::Forkable {
+class ThreadPool final : public Forkable, public Executor {
  public:
-  explicit ThreadPool(int reserve_threads);
-  // Ensures the thread pool is empty before destroying it.
+  ThreadPool();
+  // Asserts Quiesce was called.
   ~ThreadPool() override;
 
-  void Add(absl::AnyInvocable<void()> callback);
+  void Quiesce();
+
+  // Run must not be called after Quiesce completes
+  void Run(absl::AnyInvocable<void()> callback) override;
+  void Run(EventEngine::Closure* closure) override;
 
   // Forkable
   // Ensures that the thread pool is empty before forking.
@@ -51,7 +62,8 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
  private:
   class Queue {
    public:
-    explicit Queue(int reserve_threads) : reserve_threads_(reserve_threads) {}
+    explicit Queue(unsigned reserve_threads)
+        : reserve_threads_(reserve_threads) {}
     bool Step();
     void SetShutdown() { SetState(State::kShutdown); }
     void SetForking() { SetState(State::kForking); }
@@ -59,6 +71,8 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
     // Return true if we should also spin up a new thread.
     bool Add(absl::AnyInvocable<void()> callback);
     void Reset() { SetState(State::kRunning); }
+    bool IsBacklogged();
+    void SleepIfRunning();
 
    private:
     enum class State { kRunning, kShutdown, kForking };
@@ -68,8 +82,8 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
     grpc_core::Mutex mu_;
     grpc_core::CondVar cv_;
     std::queue<absl::AnyInvocable<void()>> callbacks_ ABSL_GUARDED_BY(mu_);
-    int threads_waiting_ ABSL_GUARDED_BY(mu_) = 0;
-    const int reserve_threads_;
+    unsigned threads_waiting_ ABSL_GUARDED_BY(mu_) = 0;
+    const unsigned reserve_threads_;
     State state_ ABSL_GUARDED_BY(mu_) = State::kRunning;
   };
 
@@ -92,20 +106,29 @@ class ThreadPool final : public grpc_event_engine::experimental::Forkable {
     // After pool creation we use this to rate limit creation of threads to one
     // at a time.
     std::atomic<bool> currently_starting_one_thread{false};
+    std::atomic<uint64_t> last_started_thread{0};
   };
 
   using StatePtr = std::shared_ptr<State>;
 
+  enum class StartThreadReason {
+    kInitialPool,
+    kNoWaitersWhenScheduling,
+    kNoWaitersWhenFinishedStarting,
+  };
+
   static void ThreadFunc(StatePtr state);
   // Start a new thread; throttled indicates whether the State::starting_thread
   // variable is being used to throttle this threads creation against others or
   // not: at thread pool startup we start several threads concurrently, but
   // after that we only start one at a time.
-  static void StartThread(StatePtr state, bool throttled);
+  static void StartThread(StatePtr state, StartThreadReason reason);
   void Postfork();
 
-  const int reserve_threads_;
+  const unsigned reserve_threads_ =
+      grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 32u);
   const StatePtr state_ = std::make_shared<State>(reserve_threads_);
+  std::atomic<bool> quiesced_{false};
 };
 
 }  // namespace experimental

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -151,7 +151,7 @@ grpc_error_handle grpc_tcp_set_non_block(SOCKET sock) {
   status = WSAIoctl(sock, GRPC_FIONBIO, &param, sizeof(param), NULL, 0, &ret,
                     NULL, NULL);
   return status == 0
-             ? GRPC_ERROR_NONE
+             ? absl::OkStatus()
              : GRPC_WSA_ERROR(WSAGetLastError(), "WSAIoctl(GRPC_FIONBIO)");
 }
 
@@ -161,7 +161,7 @@ static grpc_error_handle set_dualstack(SOCKET sock) {
   status = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&param,
                       sizeof(param));
   return status == 0
-             ? GRPC_ERROR_NONE
+             ? absl::OkStatus()
              : GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt(IPV6_V6ONLY)");
 }
 
@@ -173,7 +173,7 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
   if (status == SOCKET_ERROR) {
     status = WSAGetLastError();
   }
-  return status == 0 ? GRPC_ERROR_NONE
+  return status == 0 ? absl::OkStatus()
                      : GRPC_WSA_ERROR(status, "setsockopt(TCP_NODELAY)");
 }
 
@@ -182,12 +182,12 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 absl::Status PrepareSocket(SOCKET sock) {
   absl::Status err;
   err = grpc_tcp_set_non_block(sock);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   err = enable_socket_low_latency(sock);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   err = set_dualstack(sock);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
-  return GRPC_ERROR_NONE;
+  if (!err.ok()) return err;
+  return absl::OkStatus();
 }
 
 }  // namespace experimental

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -26,7 +26,6 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
-#include "src/core/lib/event_engine/executor/threaded_executor.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/trace.h"
@@ -61,23 +60,30 @@ struct WindowsEventEngine::Closure final : public EventEngine::Closure {
   }
 };
 
-WindowsEventEngine::WindowsEventEngine() : iocp_(&executor_) {
+WindowsEventEngine::WindowsEventEngine()
+    : executor_(std::make_shared<ThreadPool>()),
+      iocp_(executor_.get()),
+      timer_manager_(executor_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
   GPR_ASSERT(status == 0);
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
-  grpc_core::MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    for (auto handle : known_handles_) {
-      gpr_log(GPR_ERROR,
-              "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s", this,
-              HandleToString(handle).c_str());
+  {
+    grpc_core::MutexLock lock(&mu_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      for (auto handle : known_handles_) {
+        gpr_log(GPR_ERROR,
+                "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
+                this, HandleToString(handle).c_str());
+      }
     }
+    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    GPR_ASSERT(WSACleanup() == 0);
+    timer_manager_.Shutdown();
   }
-  GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
-  GPR_ASSERT(WSACleanup() == 0);
+  executor_->Quiesce();
 }
 
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
@@ -101,11 +107,11 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfter(
 }
 
 void WindowsEventEngine::Run(absl::AnyInvocable<void()> closure) {
-  executor_.Run(std::move(closure));
+  executor_->Run(std::move(closure));
 }
 
 void WindowsEventEngine::Run(EventEngine::Closure* closure) {
-  executor_.Run(closure);
+  executor_->Run(closure);
 }
 
 EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(

data/src/core/lib/event_engine/windows/windows_engine.h

@@ -28,17 +28,21 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
-#include "src/core/lib/event_engine/executor/threaded_executor.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/surface/init_internally.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-class WindowsEventEngine : public EventEngine {
+// TODO(ctiller): KeepsGrpcInitialized is an interim measure to ensure that
+// event engine is shut down before we shut down iomgr.
+class WindowsEventEngine : public EventEngine,
+                           public grpc_core::KeepsGrpcInitialized {
  public:
   class WindowsEndpoint : public EventEngine::Endpoint {
    public:
@@ -107,9 +111,9 @@ class WindowsEventEngine : public EventEngine {
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
 
-  posix_engine::TimerManager timer_manager_;
-  ThreadedExecutor executor_{2};
+  std::shared_ptr<ThreadPool> executor_;
   IOCP iocp_;
+  posix_engine::TimerManager timer_manager_;
 };
 
 }  // namespace experimental

data/src/core/lib/experiments/config.cc

@@ -20,7 +20,6 @@
 
 #include <algorithm>
 #include <atomic>
-#include <memory>
 #include <string>
 
 #include "absl/strings/ascii.h"
@@ -32,6 +31,7 @@
 
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 
 GPR_GLOBAL_CONFIG_DEFINE_STRING(

data/src/core/lib/experiments/experiments.cc

@@ -46,6 +46,13 @@ const char* const description_new_hpack_huffman_decoder =
     "implementation.";
 const char* const description_event_engine_client =
     "Use EventEngine clients instead of iomgr's grpc_tcp_client";
+const char* const description_monitoring_experiment =
+    "Placeholder experiment to prove/disprove our monitoring is working";
+const char* const description_promise_based_client_call =
+    "If set, use the new gRPC promise based call code when it's appropriate "
+    "(ie when all filters in a stack are promise based)";
+const char* const description_posix_event_engine_enable_polling =
+    "If set, enables polling on the default posix event engine.";
 #ifdef NDEBUG
 const bool kDefaultForDebugOnly = false;
 #else
@@ -57,19 +64,23 @@ namespace grpc_core {
 
 const ExperimentMetadata g_experiment_metadata[] = {
     {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false},
-    {"tcp_read_chunks", description_tcp_read_chunks, false},
+    {"tcp_read_chunks", description_tcp_read_chunks, true},
     {"tcp_rcv_lowat", description_tcp_rcv_lowat, false},
     {"peer_state_based_framing", description_peer_state_based_framing, false},
     {"flow_control_fixes", description_flow_control_fixes, false},
     {"memory_pressure_controller", description_memory_pressure_controller,
      false},
     {"periodic_resource_quota_reclamation",
-     description_periodic_resource_quota_reclamation, false},
+     description_periodic_resource_quota_reclamation, true},
     {"unconstrained_max_quota_buffer_size",
      description_unconstrained_max_quota_buffer_size, false},
     {"new_hpack_huffman_decoder", description_new_hpack_huffman_decoder,
      kDefaultForDebugOnly},
     {"event_engine_client", description_event_engine_client, false},
+    {"monitoring_experiment", description_monitoring_experiment, true},
+    {"promise_based_client_call", description_promise_based_client_call, false},
+    {"posix_event_engine_enable_polling",
+     description_posix_event_engine_enable_polling, kDefaultForDebugOnly},
 };
 
 }  // namespace grpc_core

data/src/core/lib/experiments/experiments.h

@@ -41,6 +41,13 @@ inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() {
 }
 inline bool IsNewHpackHuffmanDecoderEnabled() { return IsExperimentEnabled(8); }
 inline bool IsEventEngineClientEnabled() { return IsExperimentEnabled(9); }
+inline bool IsMonitoringExperimentEnabled() { return IsExperimentEnabled(10); }
+inline bool IsPromiseBasedClientCallEnabled() {
+  return IsExperimentEnabled(11);
+}
+inline bool IsPosixEventEngineEnablePollingEnabled() {
+  return IsExperimentEnabled(12);
+}
 
 struct ExperimentMetadata {
   const char* name;
@@ -48,7 +55,7 @@ struct ExperimentMetadata {
   bool default_value;
 };
 
-constexpr const size_t kNumExperiments = 10;
+constexpr const size_t kNumExperiments = 13;
 extern const ExperimentMetadata g_experiment_metadata[kNumExperiments];
 
 }  // namespace grpc_core

data/src/core/lib/gpr/cpu_linux.cc

@@ -33,12 +33,15 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/gprpp/strerror.h"
+
 static int ncpus = 0;
 
 static void init_num_cpus() {
 #ifndef GPR_MUSL_LIBC_COMPAT
   if (sched_getcpu() < 0) {
-    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n", strerror(errno));
+    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n",
+            grpc_core::StrError(errno).c_str());
     ncpus = 1;
     return;
   }
@@ -68,7 +71,8 @@ unsigned gpr_cpu_current_cpu(void) {
   }
   int cpu = sched_getcpu();
   if (cpu < 0) {
-    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n", strerror(errno));
+    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n",
+            grpc_core::StrError(errno).c_str());
     return 0;
   }
   if (static_cast<unsigned>(cpu) >= gpr_cpu_num_cores()) {

data/src/core/lib/gpr/log_linux.cc

@@ -44,7 +44,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/examine_stack.h"
 
 int gpr_should_log_stacktrace(gpr_log_severity severity);
@@ -77,7 +76,7 @@ void gpr_default_log(gpr_log_func_args* args) {
   time_t timer;
   gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
   struct tm tm;
-  static GPR_THREAD_LOCAL(long) tid(0);
+  static thread_local long tid(0);
   if (tid == 0) tid = sys_gettid();
 
   timer = static_cast<time_t>(now.tv_sec);
@@ -104,10 +103,10 @@ void gpr_default_log(gpr_log_func_args* args) {
           ? grpc_core::GetCurrentStackTrace()
           : absl::nullopt;
   if (stack_trace) {
-    fprintf(stderr, "%-60s %s\n%s\n", prefix.c_str(), args->message,
+    fprintf(stderr, "%-70s %s\n%s\n", prefix.c_str(), args->message,
             stack_trace->c_str());
   } else {
-    fprintf(stderr, "%-60s %s\n", prefix.c_str(), args->message);
+    fprintf(stderr, "%-70s %s\n", prefix.c_str(), args->message);
   }
 }
 

data/src/core/lib/gpr/string.h

@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #include <string>
 

data/src/core/lib/gpr/tmpfile_posix.cc

@@ -31,6 +31,7 @@
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/tmpfile.h"
+#include "src/core/lib/gprpp/strerror.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   FILE* result = nullptr;
@@ -45,13 +46,13 @@ FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   fd = mkstemp(filename_template);
   if (fd == -1) {
     gpr_log(GPR_ERROR, "mkstemp failed for filename_template %s with error %s.",
-            filename_template, strerror(errno));
+            filename_template, grpc_core::StrError(errno).c_str());
     goto end;
   }
   result = fdopen(fd, "w+");
   if (result == nullptr) {
     gpr_log(GPR_ERROR, "Could not open file %s from fd %d (error = %s).",
-            filename_template, fd, strerror(errno));
+            filename_template, fd, grpc_core::StrError(errno).c_str());
     unlink(filename_template);
     close(fd);
     goto end;

data/src/core/lib/gprpp/load_file.cc

@@ -0,0 +1,75 @@
+// Copyright 2022 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>
+
+#include "src/core/lib/gprpp/load_file.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "absl/cleanup/cleanup.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+
+#include <grpc/slice.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+// Loads the content of a file into a slice. add_null_terminator will add a NULL
+// terminator if true.
+absl::StatusOr<Slice> LoadFile(std::string filename, bool add_null_terminator) {
+  unsigned char* contents = nullptr;
+  size_t contents_size = 0;
+  FILE* file;
+  size_t bytes_read = 0;
+  absl::Status error = absl::OkStatus();
+  auto sock_cleanup = absl::MakeCleanup([&file]() -> void {
+    if (file != nullptr) {
+      fclose(file);
+    }
+  });
+
+  file = fopen(filename.c_str(), "rb");
+  if (file == nullptr) {
+    error = absl::InternalError(
+        absl::StrCat("Failed to load file: ", filename,
+                     " due to error(fdopen): ", strerror(errno)));
+    return error;
+  }
+  fseek(file, 0, SEEK_END);
+  // Converting to size_t on the assumption that it will not fail.
+  contents_size = static_cast<size_t>(ftell(file));
+  fseek(file, 0, SEEK_SET);
+  contents = static_cast<unsigned char*>(
+      gpr_malloc(contents_size + (add_null_terminator ? 1 : 0)));
+  bytes_read = fread(contents, 1, contents_size, file);
+  if (bytes_read < contents_size) {
+    gpr_free(contents);
+    GPR_ASSERT(ferror(file));
+    error = absl::InternalError(
+        absl::StrCat("Failed to load file: ", filename,
+                     " due to error(fread): ", strerror(errno)));
+    return error;
+  }
+  if (add_null_terminator) {
+    contents[contents_size++] = 0;
+  }
+  return Slice(grpc_slice_new(contents, contents_size, gpr_free));
+}
+
+}  // namespace grpc_core

data/src/core/lib/gprpp/load_file.h

@@ -0,0 +1,33 @@
+// Copyright 2022 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_GPRPP_LOAD_FILE_H
+#define GRPC_CORE_LIB_GPRPP_LOAD_FILE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+// Loads the content of a file into a slice. add_null_terminator will add a NULL
+// terminator if true.
+absl::StatusOr<Slice> LoadFile(std::string filename, bool add_null_terminator);
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_LOAD_FILE_H

data/src/core/lib/gprpp/per_cpu.h

@@ -0,0 +1,46 @@
+// Copyright 2022 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_GPRPP_PER_CPU_H
+#define GRPC_CORE_LIB_GPRPP_PER_CPU_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+#include <memory>
+
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+namespace grpc_core {
+
+template <typename T>
+class PerCpu {
+ public:
+  T& this_cpu() { return data_[ExecCtx::Get()->starting_cpu()]; }
+
+  T* begin() { return data_.get(); }
+  T* end() { return data_.get() + cpus_; }
+  const T* begin() const { return data_.get(); }
+  const T* end() const { return data_.get() + cpus_; }
+
+ private:
+  const size_t cpus_ = gpr_cpu_num_cores();
+  std::unique_ptr<T[]> data_{new T[cpus_]};
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_PER_CPU_H

data/src/core/lib/gprpp/stat_posix.cc

@@ -16,9 +16,9 @@
 
 #include <grpc/support/port_platform.h>
 
-// IWYU pragma: no_include <bits/struct_stat.h>
+#include <string>
 
-#include <string.h>
+// IWYU pragma: no_include <bits/struct_stat.h>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -31,6 +31,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/stat.h"
+#include "src/core/lib/gprpp/strerror.h"
 
 namespace grpc_core {
 
@@ -39,9 +40,9 @@ absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
   GPR_ASSERT(timestamp != nullptr);
   struct stat buf;
   if (stat(filename, &buf) != 0) {
-    const char* error_msg = strerror(errno);
+    std::string error_msg = StrError(errno);
     gpr_log(GPR_ERROR, "stat failed for filename %s with error %s.", filename,
-            error_msg);
+            error_msg.c_str());
     return absl::Status(absl::StatusCode::kInternal, error_msg);
   }
   // Last file/directory modification time.

data/src/core/lib/gprpp/stat_windows.cc

@@ -25,6 +25,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/stat.h"
+#include "src/core/lib/gprpp/strerror.h"
 
 namespace grpc_core {
 
@@ -33,9 +34,9 @@ absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
   GPR_ASSERT(timestamp != nullptr);
   struct _stat buf;
   if (_stat(filename, &buf) != 0) {
-    const char* error_msg = strerror(errno);
+    std::string error_msg = StrError(errno);
     gpr_log(GPR_ERROR, "_stat failed for filename %s with error %s.", filename,
-            error_msg);
+            error_msg.c_str());
     return absl::Status(absl::StatusCode::kInternal, error_msg);
   }
   // Last file/directory modification time.

data/src/core/lib/gprpp/status_helper.h

@@ -38,7 +38,7 @@ struct google_rpc_Status;
 struct upb_Arena;
 }
 
-#define RETURN_IF_ERROR(expr)           \
+#define GRPC_RETURN_IF_ERROR(expr)      \
   do {                                  \
     const absl::Status status = (expr); \
     if (!status.ok()) return status;    \
@@ -47,7 +47,6 @@ struct upb_Arena;
 namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints
-// TODO(veblush): Use camel-case names once migration to absl::Status is done.
 enum class StatusIntProperty {
   /// 'errno' from the operating system
   kErrorNo,
@@ -85,7 +84,6 @@ enum class StatusIntProperty {
 };
 
 /// This enum should have the same value of grpc_error_strs
-// TODO(veblush): Use camel-case names once migration to absl::Status is done.
 enum class StatusStrProperty {
   /// top-level textual description of this error
   kDescription,