grpc 1.41.0 → 1.42.0.pre1

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

@@ -110,8 +110,7 @@ static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error,
   return grpc_error_set_str(
       grpc_error_set_int(src_error, GRPC_ERROR_INT_GRPC_STATUS,
                          GRPC_STATUS_UNAVAILABLE),
-      GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(ep->peer_string.c_str()));
+      GRPC_ERROR_STR_TARGET_ADDRESS, ep->peer_string);
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
@@ -150,7 +149,7 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 static void ReadAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->read_cb != nullptr);
-  if (error) {
+  if (error != GRPC_ERROR_NONE) {
     grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
     CallReadCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "read");
@@ -192,7 +191,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
 static void WriteAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->write_cb != nullptr);
-  if (error) {
+  if (error != GRPC_ERROR_NONE) {
     grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
     CallWriteCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "write");
@@ -287,13 +286,15 @@ static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
 void CFStreamShutdown(grpc_endpoint* ep, grpc_error_handle why) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%p)", ep_impl, why);
+    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%s)", ep_impl,
+            grpc_error_std_string(why).c_str());
   }
   CFReadStreamClose(ep_impl->read_stream);
   CFWriteStreamClose(ep_impl->write_stream);
   ep_impl->stream_sync->Shutdown(why);
   if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%p)", ep_impl, why);
+    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%s)", ep_impl,
+            grpc_error_std_string(why).c_str());
   }
 }
 

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

@@ -22,7 +22,7 @@
 #include <inttypes.h>
 #include <string.h>
 
-#include <grpc/status.h>
+#include <grpc/impl/codegen/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -34,8 +34,8 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error_internal.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_utils.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_error_refcount(false,
                                                         "error_refcount");
@@ -65,7 +65,7 @@ absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
   return s;
 }
 
-std::string grpc_error_std_string(const absl::Status& error) {
+std::string grpc_error_std_string(absl::Status error) {
   return grpc_core::StatusToString(error);
 }
 
@@ -87,14 +87,20 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
   char* utf8_message = gpr_format_message(err);
   absl::Status s =
       StatusCreate(absl::StatusCode::kUnknown, "WSA Error", location, {});
-  StatusSetInt(&s, StatusIntProperty::WSA_ERROR, err);
-  StatusSetStr(&s, StatusStrProperty::OS_ERROR, utf8_message);
-  StatusSetStr(&s, StatusStrProperty::SYSCALL, call_name);
+  StatusSetInt(&s, grpc_core::StatusIntProperty::kWsaError, err);
+  StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError, utf8_message);
+  StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall, call_name);
+  return s;
 }
 #endif
 
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
                                      grpc_error_ints which, intptr_t value) {
+  if (src == GRPC_ERROR_NONE) {
+    src = absl::UnknownError("");
+    StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
+                 GRPC_STATUS_OK);
+  }
   grpc_core::StatusSetInt(
       &src, static_cast<grpc_core::StatusIntProperty>(which), value);
   return src;
@@ -108,36 +114,100 @@ bool grpc_error_get_int(grpc_error_handle error, grpc_error_ints which,
     *p = *value;
     return true;
   } else {
+    // TODO(veblush): Remove this once absl::Status migration is done
+    if (which == GRPC_ERROR_INT_GRPC_STATUS) {
+      switch (error.code()) {
+        case absl::StatusCode::kOk:
+          *p = GRPC_STATUS_OK;
+          return true;
+        case absl::StatusCode::kResourceExhausted:
+          *p = GRPC_STATUS_RESOURCE_EXHAUSTED;
+          return true;
+        case absl::StatusCode::kCancelled:
+          *p = GRPC_STATUS_CANCELLED;
+          return true;
+        default:
+          break;
+      }
+    }
     return false;
   }
 }
 
 grpc_error_handle grpc_error_set_str(grpc_error_handle src,
                                      grpc_error_strs which,
-                                     const grpc_slice& str) {
-  grpc_core::StatusSetStr(
-      &src, static_cast<grpc_core::StatusStrProperty>(which),
-      std::string(reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(str)),
-                  GRPC_SLICE_LENGTH(str)));
+                                     absl::string_view str) {
+  if (src == GRPC_ERROR_NONE) {
+    src = absl::UnknownError("");
+    StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
+                 GRPC_STATUS_OK);
+  }
+  if (which == GRPC_ERROR_STR_DESCRIPTION) {
+    // To change the message of absl::Status, a new instance should be created
+    // with a code and payload because it doesn't have a setter for it.
+    absl::Status s = absl::Status(src.code(), str);
+    src.ForEachPayload(
+        [&](absl::string_view type_url, const absl::Cord& payload) {
+          s.SetPayload(type_url, payload);
+        });
+    return s;
+  } else {
+    grpc_core::StatusSetStr(
+        &src, static_cast<grpc_core::StatusStrProperty>(which), str);
+  }
   return src;
 }
 
 bool grpc_error_get_str(grpc_error_handle error, grpc_error_strs which,
-                        grpc_slice* s) {
-  absl::optional<std::string> value = grpc_core::StatusGetStr(
-      error, static_cast<grpc_core::StatusStrProperty>(which));
-  if (value.has_value()) {
-    *s = grpc_slice_from_copied_buffer(value->c_str(), value->size());
-    return true;
+                        std::string* s) {
+  if (which == GRPC_ERROR_STR_DESCRIPTION) {
+    // absl::Status uses the message field for GRPC_ERROR_STR_DESCRIPTION
+    // instead of using payload.
+    absl::string_view msg = error.message();
+    if (msg.empty()) {
+      return false;
+    } else {
+      *s = std::string(msg);
+      return true;
+    }
   } else {
-    return false;
+    absl::optional<std::string> value = grpc_core::StatusGetStr(
+        error, static_cast<grpc_core::StatusStrProperty>(which));
+    if (value.has_value()) {
+      *s = std::move(*value);
+      return true;
+    } else {
+      // TODO(veblush): Remove this once absl::Status migration is done
+      if (which == GRPC_ERROR_STR_GRPC_MESSAGE) {
+        switch (error.code()) {
+          case absl::StatusCode::kOk:
+            *s = "";
+            return true;
+          case absl::StatusCode::kResourceExhausted:
+            *s = "RESOURCE_EXHAUSTED";
+            return true;
+          case absl::StatusCode::kCancelled:
+            *s = "CANCELLED";
+            return true;
+          default:
+            break;
+        }
+      }
+      return false;
+    }
   }
 }
 
 grpc_error_handle grpc_error_add_child(grpc_error_handle src,
                                        grpc_error_handle child) {
-  grpc_core::StatusAddChild(&src, child);
-  return src;
+  if (src.ok()) {
+    return child;
+  } else {
+    if (!child.ok()) {
+      grpc_core::StatusAddChild(&src, child);
+    }
+    return src;
+  }
 }
 
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
@@ -300,8 +370,8 @@ static uint8_t get_placement(grpc_error_handle* err, size_t size) {
   GPR_ASSERT(*err);
   uint8_t slots = static_cast<uint8_t>(size / sizeof(intptr_t));
   if ((*err)->arena_size + slots > (*err)->arena_capacity) {
-    (*err)->arena_capacity = static_cast<uint8_t> GPR_MIN(
-        UINT8_MAX - 1, (3 * (*err)->arena_capacity / 2));
+    (*err)->arena_capacity = static_cast<uint8_t>(std::min(
+        size_t(UINT8_MAX - 1), size_t(3 * (*err)->arena_capacity / 2)));
     if ((*err)->arena_size + slots > (*err)->arena_capacity) {
       return UINT8_MAX;
     }
@@ -417,7 +487,6 @@ grpc_error_handle grpc_error_create(const char* file, int line,
                                     const grpc_slice& desc,
                                     grpc_error_handle* referencing,
                                     size_t num_referencing) {
-  GPR_TIMER_SCOPE("grpc_error_create", 0);
   uint8_t initial_arena_capacity = static_cast<uint8_t>(
       DEFAULT_ERROR_CAPACITY +
       static_cast<uint8_t>(num_referencing * SLOTS_PER_LINKED_ERROR) +
@@ -483,13 +552,12 @@ static void ref_errs(grpc_error_handle err) {
   while (slot != UINT8_MAX) {
     grpc_linked_error* lerr =
         reinterpret_cast<grpc_linked_error*>(err->arena + slot);
-    GRPC_ERROR_REF(lerr->err);
+    (void)GRPC_ERROR_REF(lerr->err);
     slot = lerr->next;
   }
 }
 
 static grpc_error_handle copy_error_and_unref(grpc_error_handle in) {
-  GPR_TIMER_SCOPE("copy_error_and_unref", 0);
   grpc_error_handle out;
   if (grpc_error_is_special(in)) {
     out = GRPC_ERROR_CREATE_FROM_STATIC_STRING("unknown");
@@ -541,7 +609,6 @@ static grpc_error_handle copy_error_and_unref(grpc_error_handle in) {
 
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
                                      grpc_error_ints which, intptr_t value) {
-  GPR_TIMER_SCOPE("grpc_error_set_int", 0);
   grpc_error_handle new_err = copy_error_and_unref(src);
   internal_set_int(&new_err, which, value);
   return new_err;
@@ -555,16 +622,15 @@ struct special_error_status_map {
 const special_error_status_map error_status_map[] = {
     {GRPC_STATUS_OK, "", 0},                // GRPC_ERROR_NONE
     {GRPC_STATUS_INVALID_ARGUMENT, "", 0},  // GRPC_ERROR_RESERVED_1
-    {GRPC_STATUS_RESOURCE_EXHAUSTED, "Out of memory",
-     strlen("Out of memory")},              // GRPC_ERROR_OOM
+    {GRPC_STATUS_RESOURCE_EXHAUSTED, "RESOURCE_EXHAUSTED",
+     strlen("RESOURCE_EXHAUSTED")},         // GRPC_ERROR_OOM
     {GRPC_STATUS_INVALID_ARGUMENT, "", 0},  // GRPC_ERROR_RESERVED_2
-    {GRPC_STATUS_CANCELLED, "Cancelled",
-     strlen("Cancelled")},  // GRPC_ERROR_CANCELLED
+    {GRPC_STATUS_CANCELLED, "CANCELLED",
+     strlen("CANCELLED")},  // GRPC_ERROR_CANCELLED
 };
 
 bool grpc_error_get_int(grpc_error_handle err, grpc_error_ints which,
                         intptr_t* p) {
-  GPR_TIMER_SCOPE("grpc_error_get_int", 0);
   if (grpc_error_is_special(err)) {
     if (which != GRPC_ERROR_INT_GRPC_STATUS) return false;
     *p = error_status_map[reinterpret_cast<size_t>(err)].code;
@@ -580,28 +646,26 @@ bool grpc_error_get_int(grpc_error_handle err, grpc_error_ints which,
 
 grpc_error_handle grpc_error_set_str(grpc_error_handle src,
                                      grpc_error_strs which,
-                                     const grpc_slice& str) {
-  GPR_TIMER_SCOPE("grpc_error_set_str", 0);
+                                     absl::string_view str) {
   grpc_error_handle new_err = copy_error_and_unref(src);
-  internal_set_str(&new_err, which, str);
+  internal_set_str(&new_err, which,
+                   grpc_slice_from_copied_buffer(str.data(), str.length()));
   return new_err;
 }
 
 bool grpc_error_get_str(grpc_error_handle err, grpc_error_strs which,
-                        grpc_slice* str) {
+                        std::string* s) {
   if (grpc_error_is_special(err)) {
     if (which != GRPC_ERROR_STR_GRPC_MESSAGE) return false;
     const special_error_status_map& msg =
         error_status_map[reinterpret_cast<size_t>(err)];
-    str->refcount = &grpc_core::kNoopRefcount;
-    str->data.refcounted.bytes =
-        reinterpret_cast<uint8_t*>(const_cast<char*>(msg.msg));
-    str->data.refcounted.length = msg.len;
+    *s = std::string(msg.msg, msg.len);
     return true;
   }
   uint8_t slot = err->strs[which];
   if (slot != UINT8_MAX) {
-    *str = *reinterpret_cast<grpc_slice*>(err->arena + slot);
+    grpc_slice* slice = reinterpret_cast<grpc_slice*>(err->arena + slot);
+    *s = std::string(grpc_core::StringViewFromSlice(*slice));
     return true;
   } else {
     return false;
@@ -610,7 +674,6 @@ bool grpc_error_get_str(grpc_error_handle err, grpc_error_strs which,
 
 grpc_error_handle grpc_error_add_child(grpc_error_handle src,
                                        grpc_error_handle child) {
-  GPR_TIMER_SCOPE("grpc_error_add_child", 0);
   if (src != GRPC_ERROR_NONE) {
     if (child == GRPC_ERROR_NONE) {
       /* \a child is empty. Simply return the ref to \a src */
@@ -631,9 +694,9 @@ grpc_error_handle grpc_error_add_child(grpc_error_handle src,
   }
 }
 
-static const char* no_error_string = "\"No Error\"";
-static const char* oom_error_string = "\"Out of memory\"";
-static const char* cancelled_error_string = "\"Cancelled\"";
+static const char* no_error_string = "\"OK\"";
+static const char* oom_error_string = "\"RESOURCE_EXHAUSTED\"";
+static const char* cancelled_error_string = "\"CANCELLED\"";
 
 struct kv_pair {
   char* key;
@@ -646,7 +709,7 @@ struct kv_pairs {
 };
 static void append_chr(char c, char** s, size_t* sz, size_t* cap) {
   if (*sz == *cap) {
-    *cap = GPR_MAX(8, 3 * *cap / 2);
+    *cap = std::max(size_t(8), 3 * *cap / 2);
     *s = static_cast<char*>(gpr_realloc(*s, *cap));
   }
   (*s)[(*sz)++] = c;
@@ -698,7 +761,7 @@ static void append_esc_str(const uint8_t* str, size_t len, char** s, size_t* sz,
 
 static void append_kv(kv_pairs* kvs, char* key, char* value) {
   if (kvs->num_kvs == kvs->cap_kvs) {
-    kvs->cap_kvs = GPR_MAX(3 * kvs->cap_kvs / 2, 4);
+    kvs->cap_kvs = std::max(3 * kvs->cap_kvs / 2, size_t(4));
     kvs->kvs = static_cast<kv_pair*>(
         gpr_realloc(kvs->kvs, sizeof(*kvs->kvs) * kvs->cap_kvs));
   }
@@ -842,7 +905,6 @@ static char* finish_kvs(kv_pairs* kvs) {
 }
 
 const char* grpc_error_string(grpc_error_handle err) {
-  GPR_TIMER_SCOPE("grpc_error_string", 0);
   if (err == GRPC_ERROR_NONE) return no_error_string;
   if (err == GRPC_ERROR_OOM) return oom_error_string;
   if (err == GRPC_ERROR_CANCELLED) return cancelled_error_string;
@@ -889,9 +951,8 @@ grpc_error_handle grpc_os_error(const char* file, int line, int err,
                                 grpc_slice_from_static_string(strerror(err)),
                                 nullptr, 0),
               GRPC_ERROR_INT_ERRNO, err),
-          GRPC_ERROR_STR_OS_ERROR,
-          grpc_slice_from_static_string(strerror(err))),
-      GRPC_ERROR_STR_SYSCALL, grpc_slice_from_copied_string(call_name));
+          GRPC_ERROR_STR_OS_ERROR, strerror(err)),
+      GRPC_ERROR_STR_SYSCALL, call_name);
 }
 
 #ifdef GPR_WINDOWS
@@ -905,8 +966,8 @@ grpc_error_handle grpc_wsa_error(const char* file, int line, int err,
                                 grpc_slice_from_static_string("OS Error"), NULL,
                                 0),
               GRPC_ERROR_INT_WSA_ERROR, err),
-          GRPC_ERROR_STR_OS_ERROR, grpc_slice_from_copied_string(utf8_message)),
-      GRPC_ERROR_STR_SYSCALL, grpc_slice_from_static_string(call_name));
+          GRPC_ERROR_STR_OS_ERROR, utf8_message),
+      GRPC_ERROR_STR_SYSCALL, call_name);
   gpr_free(utf8_message);
   return error;
 }

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

@@ -32,6 +32,7 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/slice/slice_internal.h"
 
@@ -156,11 +157,11 @@ void grpc_enable_error_creation();
 #ifdef GRPC_ERROR_IS_ABSEIL_STATUS
 
 #define GRPC_ERROR_NONE absl::OkStatus()
-#define GRPC_ERROR_OOM absl::Status(absl::ResourceExhaustedError)
+#define GRPC_ERROR_OOM absl::Status(absl::ResourceExhaustedError(""))
 #define GRPC_ERROR_CANCELLED absl::CancelledError()
 
 #define GRPC_ERROR_REF(err) (err)
-#define GRPC_ERROR_UNREF(err)
+#define GRPC_ERROR_UNREF(err) (void)(err)
 
 #define GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc) \
   StatusCreate(absl::StatusCode::kUnknown, desc, DEBUG_LOCATION, {})
@@ -189,11 +190,11 @@ absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
 // them. If the vector is empty, return GRPC_ERROR_NONE.
 template <typename VectorType>
 static absl::Status grpc_status_create_from_vector(
-    const grpc_core::DebugLocation& location, const char* desc,
+    const grpc_core::DebugLocation& location, absl::string_view desc,
     VectorType* error_list) {
   absl::Status error = GRPC_ERROR_NONE;
   if (error_list->size() != 0) {
-    error = grpc_status_create(absl::StatusCode::kUnknown, desc, DEBUG_LOCATION,
+    error = grpc_status_create(absl::StatusCode::kUnknown, desc, location,
                                error_list->size(), error_list->data());
     error_list->clear();
   }
@@ -363,15 +364,12 @@ grpc_error_handle grpc_error_set_int(grpc_error_handle src,
 /// intptr_t for `p`, even if the value of `p` is not used.
 bool grpc_error_get_int(grpc_error_handle error, grpc_error_ints which,
                         intptr_t* p);
-/// This call takes ownership of the slice; the error is responsible for
-/// eventually unref-ing it.
 grpc_error_handle grpc_error_set_str(
     grpc_error_handle src, grpc_error_strs which,
-    const grpc_slice& str) GRPC_MUST_USE_RESULT;
+    absl::string_view str) GRPC_MUST_USE_RESULT;
 /// Returns false if the specified string is not set.
-/// Caller does NOT own the slice.
 bool grpc_error_get_str(grpc_error_handle error, grpc_error_strs which,
-                        grpc_slice* s);
+                        std::string* str);
 
 /// Add a child error: an error that is believed to have contributed to this
 /// error occurring. Allows root causing high level errors from lower level
@@ -398,4 +396,47 @@ inline bool grpc_log_if_error(const char* what, grpc_error_handle error,
 #define GRPC_LOG_IF_ERROR(what, error) \
   (grpc_log_if_error((what), (error), __FILE__, __LINE__))
 
+/// Helper class to get & set grpc_error_handle in a thread-safe fashion.
+/// This could be considered as atomic<grpc_error_handle>.
+class AtomicError {
+ public:
+  AtomicError() {
+    error_ = GRPC_ERROR_NONE;
+    lock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
+  }
+  explicit AtomicError(grpc_error_handle error) {
+    error_ = GRPC_ERROR_REF(error);
+  }
+  ~AtomicError() { GRPC_ERROR_UNREF(error_); }
+
+  AtomicError(const AtomicError&) = delete;
+  AtomicError& operator=(const AtomicError&) = delete;
+
+  /// returns get() == GRPC_ERROR_NONE
+  bool ok() {
+    gpr_spinlock_lock(&lock_);
+    bool ret = error_ == GRPC_ERROR_NONE;
+    gpr_spinlock_unlock(&lock_);
+    return ret;
+  }
+
+  grpc_error_handle get() {
+    gpr_spinlock_lock(&lock_);
+    grpc_error_handle ret = error_;
+    gpr_spinlock_unlock(&lock_);
+    return ret;
+  }
+
+  void set(grpc_error_handle error) {
+    gpr_spinlock_lock(&lock_);
+    GRPC_ERROR_UNREF(error_);
+    error_ = GRPC_ERROR_REF(error);
+    gpr_spinlock_unlock(&lock_);
+  }
+
+ private:
+  grpc_error_handle error_;
+  gpr_spinlock lock_;
+};
+
 #endif /* GRPC_CORE_LIB_IOMGR_ERROR_H */

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

@@ -48,7 +48,12 @@ grpc_error_handle grpc_error_create_from_cferror(const char* file, int line,
       absl::StrFormat("%s (error domain:%s, code:%ld, description:%s)",
                       custom_desc, buf_domain, code, buf_desc);
   CFRelease(desc);
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  return StatusCreate(absl::StatusCode::kUnknown, error_msg,
+                      grpc_core::DebugLocation(file, line), {});
+#else
   return grpc_error_create(
       file, line, grpc_slice_from_copied_string(error_msg.c_str()), NULL, 0);
+#endif
 }
 #endif /* GRPC_CFSTREAM */

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

@@ -195,7 +195,7 @@ struct grpc_pollset_worker {
     (worker)->kick_state_mutator = __LINE__; \
   } while (false)
 
-#define MAX_NEIGHBORHOODS 1024
+#define MAX_NEIGHBORHOODS 1024u
 
 typedef struct pollset_neighborhood {
   union {
@@ -525,7 +525,8 @@ static grpc_error_handle pollset_global_init(void) {
                 &ev) != 0) {
     return GRPC_OS_ERROR(errno, "epoll_ctl");
   }
-  g_num_neighborhoods = GPR_CLAMP(gpr_cpu_num_cores(), 1, MAX_NEIGHBORHOODS);
+  g_num_neighborhoods =
+      grpc_core::Clamp(gpr_cpu_num_cores(), 1u, MAX_NEIGHBORHOODS);
   g_neighborhoods = static_cast<pollset_neighborhood*>(
       gpr_zalloc(sizeof(*g_neighborhoods) * g_num_neighborhoods));
   for (size_t i = 0; i < g_num_neighborhoods; i++) {

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

@@ -1071,7 +1071,7 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     case WRR_EMPTIED:
       if (pollset->active_pollable != worker->pollable_obj) {
         // pollable no longer being polled: flush events
-        pollable_process_events(pollset, worker->pollable_obj, true);
+        (void)pollable_process_events(pollset, worker->pollable_obj, true);
       }
       break;
     case WRR_REMOVED:
@@ -1357,7 +1357,7 @@ static void pollset_set_add_fd(grpc_pollset_set* pss, grpc_fd* fd) {
                  err_desc);
   }
   if (pss->fd_count == pss->fd_capacity) {
-    pss->fd_capacity = GPR_MAX(pss->fd_capacity * 2, 8);
+    pss->fd_capacity = std::max(pss->fd_capacity * 2, size_t(8));
     pss->fds = static_cast<grpc_fd**>(
         gpr_realloc(pss->fds, pss->fd_capacity * sizeof(*pss->fds)));
   }
@@ -1467,7 +1467,7 @@ static void pollset_set_add_pollset(grpc_pollset_set* pss, grpc_pollset* ps) {
                                    pss->fds, &pss->fd_count),
                err_desc);
   if (pss->pollset_count == pss->pollset_capacity) {
-    pss->pollset_capacity = GPR_MAX(pss->pollset_capacity * 2, 8);
+    pss->pollset_capacity = std::max(pss->pollset_capacity * 2, size_t(8));
     pss->pollsets = static_cast<grpc_pollset**>(gpr_realloc(
         pss->pollsets, pss->pollset_capacity * sizeof(*pss->pollsets)));
   }
@@ -1492,7 +1492,7 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* a,
       return;
     }
     if (a > b) {
-      GPR_SWAP(grpc_pollset_set*, a, b);
+      std::swap(a, b);
     }
     gpr_mu* a_mu = &a->mu;
     gpr_mu* b_mu = &b->mu;
@@ -1513,7 +1513,7 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* a,
   const size_t a_size = a->fd_count + a->pollset_count;
   const size_t b_size = b->fd_count + b->pollset_count;
   if (b_size > a_size) {
-    GPR_SWAP(grpc_pollset_set*, a, b);
+    std::swap(a, b);
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_INFO, "PSS: parent %p to %p", b, a);
@@ -1521,7 +1521,7 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* a,
   a->refs.Ref();
   b->parent = a;
   if (a->fd_capacity < a->fd_count + b->fd_count) {
-    a->fd_capacity = GPR_MAX(2 * a->fd_capacity, a->fd_count + b->fd_count);
+    a->fd_capacity = std::max(2 * a->fd_capacity, a->fd_count + b->fd_count);
     a->fds = static_cast<grpc_fd**>(
         gpr_realloc(a->fds, a->fd_capacity * sizeof(*a->fds)));
   }
@@ -1539,7 +1539,7 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* a,
       err_desc);
   if (a->pollset_capacity < a->pollset_count + b->pollset_count) {
     a->pollset_capacity =
-        GPR_MAX(2 * a->pollset_capacity, a->pollset_count + b->pollset_count);
+        std::max(2 * a->pollset_capacity, a->pollset_count + b->pollset_count);
     a->pollsets = static_cast<grpc_pollset**>(
         gpr_realloc(a->pollsets, a->pollset_capacity * sizeof(*a->pollsets)));
   }