grpc 1.30.1 → 1.40.0

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

@@ -44,7 +44,11 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string>
+#include <vector>
+
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
@@ -52,6 +56,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -60,7 +66,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
@@ -74,16 +79,16 @@ class GrpcUdpListener {
   ~GrpcUdpListener();
 
   /* Called when grpc server starts to listening on the grpc_fd. */
-  void StartListening(grpc_pollset** pollsets, size_t pollset_count,
+  void StartListening(const std::vector<grpc_pollset*>* pollsets,
                       GrpcUdpHandlerFactory* handler_factory);
 
   /* Called when data is available to read from the socket.
    * Return true if there is more data to read from fd. */
-  void OnRead(grpc_error* error, void* do_read_arg);
+  void OnRead(grpc_error_handle error, void* do_read_arg);
 
   /* Called when the socket is writeable. The given closure should be scheduled
    * when the socket becomes blocked next time. */
-  void OnCanWrite(grpc_error* error, void* do_write_arg);
+  void OnCanWrite(grpc_error_handle error, void* do_write_arg);
 
   /* Called when the grpc_fd is about to be orphaned (and the FD closed). */
   void OnFdAboutToOrphan();
@@ -103,16 +108,16 @@ class GrpcUdpListener {
 
  private:
   /* event manager callback when reads are ready */
-  static void on_read(void* arg, grpc_error* error);
-  static void on_write(void* arg, grpc_error* error);
+  static void on_read(void* arg, grpc_error_handle error);
+  static void on_write(void* arg, grpc_error_handle error);
 
-  static void do_read(void* arg, grpc_error* error);
-  static void do_write(void* arg, grpc_error* error);
+  static void do_read(void* arg, grpc_error_handle error);
+  static void do_write(void* arg, grpc_error_handle error);
   // Wrapper of grpc_fd_notify_on_write() with a grpc_closure callback
   // interface.
-  static void fd_notify_on_write_wrapper(void* arg, grpc_error* error);
+  static void fd_notify_on_write_wrapper(void* arg, grpc_error_handle error);
 
-  static void shutdown_fd(void* args, grpc_error* error);
+  static void shutdown_fd(void* args, grpc_error_handle error);
 
   int fd_;
   grpc_fd* emfd_;
@@ -148,13 +153,11 @@ GrpcUdpListener::GrpcUdpListener(grpc_udp_server* server, int fd,
       server_(server),
       orphan_notified_(false),
       already_shutdown_(false) {
-  char* name;
   std::string addr_str = grpc_sockaddr_to_string(addr, true);
-  gpr_asprintf(&name, "udp-server-listener:%s", addr_str.c_str());
-  emfd_ = grpc_fd_create(fd, name, true);
+  std::string name = absl::StrCat("udp-server-listener:", addr_str);
+  emfd_ = grpc_fd_create(fd, name.c_str(), true);
   memcpy(&addr_, addr, sizeof(grpc_resolved_address));
   GPR_ASSERT(emfd_);
-  gpr_free(name);
   gpr_mu_init(&mutex_);
 }
 
@@ -184,10 +187,9 @@ struct grpc_udp_server {
   /* shutdown callback */
   grpc_closure* shutdown_complete;
 
-  /* all pollsets interested in new connections */
-  grpc_pollset** pollsets;
-  /* number of pollsets in the pollsets array */
-  size_t pollset_count;
+  /* all pollsets interested in new connections. The object pointed at is not
+   * owned by this struct. */
+  const std::vector<grpc_pollset*>* pollsets;
   /* opaque object to pass to callbacks */
   void* user_data;
 
@@ -221,7 +223,7 @@ grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args) {
 }
 
 // static
-void GrpcUdpListener::shutdown_fd(void* args, grpc_error* error) {
+void GrpcUdpListener::shutdown_fd(void* args, grpc_error_handle error) {
   if (args == nullptr) {
     // No-op if shutdown args are null.
     return;
@@ -260,7 +262,7 @@ static void finish_shutdown(grpc_udp_server* s) {
   delete s;
 }
 
-static void destroyed_port(void* server, grpc_error* /*error*/) {
+static void destroyed_port(void* server, grpc_error_handle /*error*/) {
   grpc_udp_server* s = static_cast<grpc_udp_server*>(server);
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;
@@ -281,7 +283,7 @@ static void deactivated_all_ports(grpc_udp_server* s) {
 
   GPR_ASSERT(s->shutdown);
 
-  if (s->listeners.size() == 0) {
+  if (s->listeners.empty()) {
     gpr_mu_unlock(&s->mu);
     finish_shutdown(s);
     return;
@@ -435,7 +437,7 @@ error:
 }
 
 // static
-void GrpcUdpListener::do_read(void* arg, grpc_error* error) {
+void GrpcUdpListener::do_read(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   /* TODO: the reason we hold server->mu here is merely to prevent fd
@@ -459,12 +461,12 @@ void GrpcUdpListener::do_read(void* arg, grpc_error* error) {
 }
 
 // static
-void GrpcUdpListener::on_read(void* arg, grpc_error* error) {
+void GrpcUdpListener::on_read(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   sp->OnRead(error, arg);
 }
 
-void GrpcUdpListener::OnRead(grpc_error* error, void* do_read_arg) {
+void GrpcUdpListener::OnRead(grpc_error_handle error, void* do_read_arg) {
   if (error != GRPC_ERROR_NONE) {
     gpr_mu_lock(&server_->mu);
     if (0 == --server_->active_ports && server_->shutdown) {
@@ -496,7 +498,7 @@ 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*/) {
+                                                 grpc_error_handle /*error*/) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   gpr_mu_lock(sp->mutex());
   if (!sp->notify_on_write_armed_) {
@@ -507,7 +509,7 @@ void GrpcUdpListener::fd_notify_on_write_wrapper(void* arg,
 }
 
 // static
-void GrpcUdpListener::do_write(void* arg, grpc_error* error) {
+void GrpcUdpListener::do_write(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   gpr_mu_lock(sp->mutex());
   if (sp->already_shutdown_) {
@@ -526,12 +528,12 @@ void GrpcUdpListener::do_write(void* arg, grpc_error* error) {
 }
 
 // static
-void GrpcUdpListener::on_write(void* arg, grpc_error* error) {
+void GrpcUdpListener::on_write(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   sp->OnCanWrite(error, arg);
 }
 
-void GrpcUdpListener::OnCanWrite(grpc_error* error, void* do_write_arg) {
+void GrpcUdpListener::OnCanWrite(grpc_error_handle error, void* do_write_arg) {
   if (error != GRPC_ERROR_NONE) {
     gpr_mu_lock(&server_->mu);
     if (0 == --server_->active_ports && server_->shutdown) {
@@ -569,8 +571,7 @@ static int add_socket_to_server(grpc_udp_server* s, int fd,
   return port;
 }
 
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
+int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
                              int rcv_buf_size, int snd_buf_size,
                              GrpcUdpHandlerFactory* handler_factory,
                              size_t num_listeners) {
@@ -630,7 +631,7 @@ int grpc_udp_server_add_port(grpc_udp_server* s,
 
       /* Try listening on IPv6 first. */
       addr = &wild6;
-      // TODO(rjshade): Test and propagate the returned grpc_error*:
+      // TODO(rjshade): Test and propagate the returned grpc_error_handle:
       GRPC_ERROR_UNREF(grpc_create_dualstack_socket_using_factory(
           s->socket_factory, addr, SOCK_DGRAM, IPPROTO_UDP, &dsmode, &fd));
       allocated_port1 =
@@ -666,7 +667,7 @@ int grpc_udp_server_add_port(grpc_udp_server* s,
       addr = &wild4;
     }
 
-    // TODO(rjshade): Test and propagate the returned grpc_error*:
+    // TODO(rjshade): Test and propagate the returned grpc_error_handle:
     GRPC_ERROR_UNREF(grpc_create_dualstack_socket_using_factory(
         s->socket_factory, addr, SOCK_DGRAM, IPPROTO_UDP, &dsmode, &fd));
     if (fd < 0) {
@@ -700,29 +701,29 @@ int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index) {
   return s->listeners[port_index].fd();
 }
 
-void grpc_udp_server_start(grpc_udp_server* s, grpc_pollset** pollsets,
-                           size_t pollset_count, void* user_data) {
+void grpc_udp_server_start(grpc_udp_server* udp_server,
+                           const std::vector<grpc_pollset*>* pollsets,
+                           void* user_data) {
   gpr_log(GPR_DEBUG, "grpc_udp_server_start");
-  gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->active_ports == 0);
-  s->pollsets = pollsets;
-  s->user_data = user_data;
+  gpr_mu_lock(&udp_server->mu);
+  GPR_ASSERT(udp_server->active_ports == 0);
+  udp_server->pollsets = pollsets;
+  udp_server->user_data = user_data;
 
-  for (size_t i = 0; i < s->listeners.size(); ++i) {
-    s->listeners[i].StartListening(pollsets, pollset_count, s->handler_factory);
+  for (auto& listener : udp_server->listeners) {
+    listener.StartListening(pollsets, udp_server->handler_factory);
   }
 
-  gpr_mu_unlock(&s->mu);
+  gpr_mu_unlock(&udp_server->mu);
 }
 
-void GrpcUdpListener::StartListening(grpc_pollset** pollsets,
-                                     size_t pollset_count,
+void GrpcUdpListener::StartListening(const std::vector<grpc_pollset*>* pollsets,
                                      GrpcUdpHandlerFactory* handler_factory) {
   gpr_mu_lock(&mutex_);
   handler_factory_ = handler_factory;
   udp_handler_ = handler_factory->CreateUdpHandler(emfd_, server_->user_data);
-  for (size_t i = 0; i < pollset_count; i++) {
-    grpc_pollset_add_fd(pollsets[i], emfd_);
+  for (grpc_pollset* pollset : *pollsets) {
+    grpc_pollset_add_fd(pollset, emfd_);
   }
   GRPC_CLOSURE_INIT(&read_closure_, on_read, this, grpc_schedule_on_exec_ctx);
   grpc_fd_notify_on_read(emfd_, &read_closure_);

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <vector>
+
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -72,8 +74,9 @@ class GrpcUdpHandlerFactory {
 grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args);
 
 /* Start listening to bound ports. user_data is passed to callbacks. */
-void grpc_udp_server_start(grpc_udp_server* udp_server, grpc_pollset** pollsets,
-                           size_t pollset_count, void* user_data);
+void grpc_udp_server_start(grpc_udp_server* udp_server,
+                           const std::vector<grpc_pollset*>* pollsets,
+                           void* user_data);
 
 int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 
@@ -90,8 +93,7 @@ int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 
 /* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
                   all of the multiple socket port matching logic in one place */
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
+int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
                              int rcv_buf_size, int snd_buf_size,
                              GrpcUdpHandlerFactory* handler_factory,
                              size_t num_listeners);

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

@@ -28,6 +28,9 @@
 #include <sys/types.h>
 #include <sys/un.h>
 
+#include "absl/strings/str_cat.h"
+
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 #include <grpc/support/alloc.h>
@@ -39,31 +42,24 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
   GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
 }
 
-grpc_error* grpc_resolve_unix_domain_address(const char* name,
-                                             grpc_resolved_addresses** addrs) {
-  struct sockaddr_un* un;
-  if (strlen(name) >
-      GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) - 1) {
-    char* err_msg;
-    grpc_error* err;
-    gpr_asprintf(&err_msg,
-                 "Path name should not have more than %" PRIuPTR " characters.",
-                 GPR_ARRAY_SIZE(un->sun_path) - 1);
-    err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(err_msg);
-    gpr_free(err_msg);
-    return err;
-  }
-  *addrs = static_cast<grpc_resolved_addresses*>(
+grpc_error_handle grpc_resolve_unix_domain_address(
+    const char* name, grpc_resolved_addresses** addresses) {
+  *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addrs)->naddrs = 1;
-  (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+  (*addresses)->naddrs = 1;
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
       gpr_malloc(sizeof(grpc_resolved_address)));
-  un = reinterpret_cast<struct sockaddr_un*>((*addrs)->addrs->addr);
-  un->sun_family = AF_UNIX;
-  strncpy(un->sun_path, name, sizeof(un->sun_path));
-  (*addrs)->addrs->len =
-      static_cast<socklen_t>(strlen(un->sun_path) + sizeof(un->sun_family) + 1);
-  return GRPC_ERROR_NONE;
+  return grpc_core::UnixSockaddrPopulate(name, (*addresses)->addrs);
+}
+
+grpc_error_handle grpc_resolve_unix_abstract_domain_address(
+    const absl::string_view name, grpc_resolved_addresses** addresses) {
+  *addresses = static_cast<grpc_resolved_addresses*>(
+      gpr_malloc(sizeof(grpc_resolved_addresses)));
+  (*addresses)->naddrs = 1;
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
+      gpr_malloc(sizeof(grpc_resolved_address)));
+  return grpc_core::UnixAbstractSockaddrPopulate(name, (*addresses)->addrs);
 }
 
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) {
@@ -81,24 +77,34 @@ void grpc_unlink_if_unix_domain_socket(
   }
   struct sockaddr_un* un = reinterpret_cast<struct sockaddr_un*>(
       const_cast<char*>(resolved_addr->addr));
-  struct stat st;
 
+  // There is nothing to unlink for an abstract unix socket
+  if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
+    return;
+  }
+
+  struct stat st;
   if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) {
     unlink(un->sun_path);
   }
 }
 
-char* grpc_sockaddr_to_uri_unix_if_possible(
+std::string grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* resolved_addr) {
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   if (addr->sa_family != AF_UNIX) {
-    return nullptr;
+    return "";
   }
-
-  char* result;
-  gpr_asprintf(&result, "unix:%s", ((struct sockaddr_un*)addr)->sun_path);
-  return result;
+  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
+    return absl::StrCat(
+        "unix-abstract:",
+        absl::string_view(
+            unix_addr->sun_path + 1,
+            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
+  }
+  return absl::StrCat("unix:", unix_addr->sun_path);
 }
 
 #endif

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

@@ -21,23 +21,30 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/iomgr/port.h"
 
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#include "absl/strings/string_view.h"
+
 void grpc_create_socketpair_if_unix(int sv[2]);
 
-grpc_error* grpc_resolve_unix_domain_address(
+grpc_error_handle grpc_resolve_unix_domain_address(
     const char* name, grpc_resolved_addresses** addresses);
 
+grpc_error_handle grpc_resolve_unix_abstract_domain_address(
+    absl::string_view name, grpc_resolved_addresses** addresses);
+
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);
 
 void grpc_unlink_if_unix_domain_socket(
     const grpc_resolved_address* resolved_addr);
 
-char* grpc_sockaddr_to_uri_unix_if_possible(
+std::string grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* resolved_addr);
 
 #endif /* GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H */

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

@@ -22,28 +22,41 @@
 
 #ifndef GRPC_HAVE_UNIX_SOCKET
 
+#include <string>
+
 #include <grpc/support/log.h>
 
-void grpc_create_socketpair_if_unix(int sv[2]) {
+void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   // TODO: Either implement this for the non-Unix socket case or make
   // sure that it is never called in any such case. Until then, leave an
   // assertion to notify if this gets called inadvertently
   GPR_ASSERT(0);
 }
 
-grpc_error* grpc_resolve_unix_domain_address(
-    const char* name, grpc_resolved_addresses** addresses) {
+grpc_error_handle grpc_resolve_unix_domain_address(
+    const char* /* name */, grpc_resolved_addresses** addresses) {
   *addresses = NULL;
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Unix domain sockets are not supported on Windows");
 }
 
-int grpc_is_unix_socket(const grpc_resolved_address* addr) { return false; }
+grpc_error_handle grpc_resolve_unix_abstract_domain_address(
+    absl::string_view, grpc_resolved_addresses** addresses) {
+  *addresses = NULL;
+  return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      "Unix domain sockets are not supported on Windows");
+}
+
+int grpc_is_unix_socket(const grpc_resolved_address* /* addr */) {
+  return false;
+}
 
-void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address* addr) {}
+void grpc_unlink_if_unix_domain_socket(
+    const grpc_resolved_address* /* addr */) {}
 
-char* grpc_sockaddr_to_uri_unix_if_possible(const grpc_resolved_address* addr) {
-  return NULL;
+std::string grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* /* addr */) {
+  return "";
 }
 
 #endif

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

@@ -31,7 +31,7 @@
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 #include "src/core/lib/profiling/timers.h"
 
-static grpc_error* eventfd_create(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle eventfd_create(grpc_wakeup_fd* fd_info) {
   fd_info->read_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
   fd_info->write_fd = -1;
   if (fd_info->read_fd < 0) {
@@ -40,7 +40,7 @@ static grpc_error* eventfd_create(grpc_wakeup_fd* fd_info) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* eventfd_consume(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle eventfd_consume(grpc_wakeup_fd* fd_info) {
   eventfd_t value;
   int err;
   do {
@@ -52,7 +52,7 @@ static grpc_error* eventfd_consume(grpc_wakeup_fd* fd_info) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* eventfd_wakeup(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle eventfd_wakeup(grpc_wakeup_fd* fd_info) {
   GPR_TIMER_SCOPE("eventfd_wakeup", 0);
   int err;
   do {

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

@@ -17,7 +17,7 @@
  */
 
 /*
- * This is a dummy file to provide an invalid specialized_wakeup_fd_vtable on
+ * This is a phony file to provide an invalid specialized_wakeup_fd_vtable on
  * systems without anything better than pipe.
  */
 

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

@@ -33,14 +33,14 @@
 
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
-static grpc_error* pipe_init(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   int pipefd[2];
   int r = pipe(pipefd);
   if (0 != r) {
     gpr_log(GPR_ERROR, "pipe creation failed (%d): %s", errno, strerror(errno));
     return GRPC_OS_ERROR(errno, "pipe");
   }
-  grpc_error* err;
+  grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
   if (err != GRPC_ERROR_NONE) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
@@ -50,7 +50,7 @@ static grpc_error* pipe_init(grpc_wakeup_fd* fd_info) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* pipe_consume(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle pipe_consume(grpc_wakeup_fd* fd_info) {
   char buf[128];
   ssize_t r;
 
@@ -69,10 +69,10 @@ static grpc_error* pipe_consume(grpc_wakeup_fd* fd_info) {
   }
 }
 
-static grpc_error* pipe_wakeup(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle pipe_wakeup(grpc_wakeup_fd* fd_info) {
   char c = 0;
-  while (write(fd_info->write_fd, &c, 1) != 1 && errno == EINTR)
-    ;
+  while (write(fd_info->write_fd, &c, 1) != 1 && errno == EINTR) {
+  }
   return GRPC_ERROR_NONE;
 }
 

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

@@ -50,15 +50,15 @@ void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 
-grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->init(fd_info);
 }
 
-grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->consume(fd_info);
 }
 
-grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->wakeup(fd_info);
 }
 

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

@@ -65,9 +65,9 @@ void grpc_enable_cv_wakeup_fds(int enable);
 typedef struct grpc_wakeup_fd grpc_wakeup_fd;
 
 typedef struct grpc_wakeup_fd_vtable {
-  grpc_error* (*init)(grpc_wakeup_fd* fd_info);
-  grpc_error* (*consume)(grpc_wakeup_fd* fd_info);
-  grpc_error* (*wakeup)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*init)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*consume)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*wakeup)(grpc_wakeup_fd* fd_info);
   void (*destroy)(grpc_wakeup_fd* fd_info);
   /* Must be called before calling any other functions */
   int (*check_availability)(void);
@@ -83,10 +83,12 @@ extern int grpc_allow_pipe_wakeup_fd;
 
 #define GRPC_WAKEUP_FD_GET_READ_FD(fd_info) ((fd_info)->read_fd)
 
-grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) GRPC_MUST_USE_RESULT;
-grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info)
+    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
+    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
     GRPC_MUST_USE_RESULT;
-grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) GRPC_MUST_USE_RESULT;
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
 /* Defined in some specialized implementation's .c file, or by

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

@@ -20,6 +20,8 @@
 
 #include <functional>
 
+#include "absl/synchronization/mutex.h"
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -43,12 +45,26 @@ namespace grpc_core {
 // other callbacks from other threads might also be executed before Run()
 // returns. Since an arbitrary set of callbacks might be executed when Run() is
 // called, generally no locks should be held while calling Run().
-class WorkSerializer {
+class ABSL_LOCKABLE WorkSerializer {
  public:
   WorkSerializer();
 
   ~WorkSerializer();
 
+  // Runs a given callback.
+  //
+  // If you want to use clang thread annotation to make sure that callback is
+  // called by WorkSerializer only, you need to add the annotation to both the
+  // lambda function given to Run and the actual callback function like;
+  //
+  //   void run_callback() {
+  //     work_serializer.Run(
+  //         []() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) {
+  //            callback();
+  //         }, DEBUG_LOCATION);
+  //   }
+  //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
+  //
   // TODO(yashkt): Replace grpc_core::DebugLocation with absl::SourceLocation
   // once we can start using it directly.
   void Run(std::function<void()> callback,