grpc 1.51.0 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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_IOMGR_EXEC_CTX_H
 #define GRPC_CORE_LIB_IOMGR_EXEC_CTX_H
@@ -23,86 +23,87 @@
 
 #include <limits>
 
-#include <grpc/impl/codegen/gpr_types.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 
-/** A combiner represents a list of work to be executed later.
-    Forward declared here to avoid a circular dependency with combiner.h. */
+/// A combiner represents a list of work to be executed later.
+/// Forward declared here to avoid a circular dependency with combiner.h.
 typedef struct grpc_combiner grpc_combiner;
 
-/* This exec_ctx is ready to return: either pre-populated, or cached as soon as
-   the finish_check returns true */
+// This exec_ctx is ready to return: either pre-populated, or cached as soon as
+// the finish_check returns true
 #define GRPC_EXEC_CTX_FLAG_IS_FINISHED 1
-/* The exec_ctx's thread is (potentially) owned by a call or channel: care
-   should be given to not delete said call/channel from this exec_ctx */
+// The exec_ctx's thread is (potentially) owned by a call or channel: care
+// should be given to not delete said call/channel from this exec_ctx
 #define GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP 2
-/* This exec ctx was initialized by an internal thread, and should not
-   be counted by fork handlers */
+// This exec ctx was initialized by an internal thread, and should not
+// be counted by fork handlers
 #define GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 4
 
-/* This application callback exec ctx was initialized by an internal thread, and
-   should not be counted by fork handlers */
+// This application callback exec ctx was initialized by an internal thread, and
+// should not be counted by fork handlers
 #define GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 1
 
 namespace grpc_core {
 class Combiner;
-/** Execution context.
- *  A bag of data that collects information along a callstack.
- *  It is created on the stack at core entry points (public API or iomgr), and
- *  stored internally as a thread-local variable.
- *
- *  Generally, to create an exec_ctx instance, add the following line at the top
- *  of the public API entry point or at the start of a thread's work function :
- *
- *  ExecCtx exec_ctx;
- *
- *  Access the created ExecCtx instance using :
- *  ExecCtx::Get()
- *
- *  Specific responsibilities (this may grow in the future):
- *  - track a list of core work that needs to be delayed until the base of the
- *    call stack (this provides a convenient mechanism to run callbacks
- *    without worrying about locking issues)
- *  - provide a decision maker (via IsReadyToFinish) that provides a
- *    signal as to whether a borrowed thread should continue to do work or
- *    should actively try to finish up and get this thread back to its owner
- *
- *  CONVENTIONS:
- *  - Instance of this must ALWAYS be constructed on the stack, never
- *    heap allocated.
- *  - Do not pass exec_ctx as a parameter to a function. Always access it using
- *    ExecCtx::Get().
- *  - NOTE: In the future, the convention is likely to change to allow only one
- *          ExecCtx on a thread's stack at the same time. The TODO below
- *          discusses this plan in more detail.
- *
- * TODO(yashykt): Only allow one "active" ExecCtx on a thread at the same time.
- *                Stage 1: If a new one is created on the stack, it should just
- *                pass-through to the underlying ExecCtx deeper in the thread's
- *                stack.
- *                Stage 2: Assert if a 2nd one is ever created on the stack
- *                since that implies a core re-entry outside of application
- *                callbacks.
- */
+/// Execution context.
+/// A bag of data that collects information along a callstack.
+/// It is created on the stack at core entry points (public API or iomgr), and
+/// stored internally as a thread-local variable.
+///
+/// Generally, to create an exec_ctx instance, add the following line at the top
+/// of the public API entry point or at the start of a thread's work function :
+///
+/// ExecCtx exec_ctx;
+///
+/// Access the created ExecCtx instance using :
+/// ExecCtx::Get()
+///
+/// Specific responsibilities (this may grow in the future):
+/// - track a list of core work that needs to be delayed until the base of the
+///   call stack (this provides a convenient mechanism to run callbacks
+///   without worrying about locking issues)
+/// - provide a decision maker (via IsReadyToFinish) that provides a
+///   signal as to whether a borrowed thread should continue to do work or
+///   should actively try to finish up and get this thread back to its owner
+///
+/// CONVENTIONS:
+/// - Instance of this must ALWAYS be constructed on the stack, never
+///   heap allocated.
+/// - Do not pass exec_ctx as a parameter to a function. Always access it using
+///   ExecCtx::Get().
+/// - NOTE: In the future, the convention is likely to change to allow only one
+///         ExecCtx on a thread's stack at the same time. The TODO below
+///         discusses this plan in more detail.
+///
+/// TODO(yashykt): Only allow one "active" ExecCtx on a thread at the same time.
+///               Stage 1: If a new one is created on the stack, it should just
+///               pass-through to the underlying ExecCtx deeper in the thread's
+///               stack.
+///               Stage 2: Assert if a 2nd one is ever created on the stack
+///               since that implies a core re-entry outside of application
+///               callbacks.
+///
 class ExecCtx {
  public:
-  /** Default Constructor */
+  /// Default Constructor
 
   ExecCtx() : flags_(GRPC_EXEC_CTX_FLAG_IS_FINISHED) {
     Fork::IncExecCtxCount();
     Set(this);
   }
 
-  /** Parameterised Constructor */
+  /// Parameterised Constructor
   explicit ExecCtx(uintptr_t fl) : flags_(fl) {
     if (!(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
       Fork::IncExecCtxCount();
@@ -110,7 +111,7 @@ class ExecCtx {
     Set(this);
   }
 
-  /** Destructor */
+  /// Destructor
   virtual ~ExecCtx() {
     flags_ |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
     Flush();
@@ -120,7 +121,7 @@ class ExecCtx {
     }
   }
 
-  /** Disallow copy and assignment operators */
+  /// Disallow copy and assignment operators
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
@@ -132,37 +133,37 @@ class ExecCtx {
   }
 
   struct CombinerData {
-    /* currently active combiner: updated only via combiner.c */
+    // currently active combiner: updated only via combiner.c
     Combiner* active_combiner;
-    /* last active combiner in the active combiner list */
+    // last active combiner in the active combiner list
     Combiner* last_combiner;
   };
 
-  /** Only to be used by grpc-combiner code */
+  /// Only to be used by grpc-combiner code
   CombinerData* combiner_data() { return &combiner_data_; }
 
-  /** Return pointer to grpc_closure_list */
+  /// Return pointer to grpc_closure_list
   grpc_closure_list* closure_list() { return &closure_list_; }
 
-  /** Return flags */
+  /// Return flags
   uintptr_t flags() { return flags_; }
 
-  /** Checks if there is work to be done */
+  /// Checks if there is work to be done
   bool HasWork() {
     return combiner_data_.active_combiner != nullptr ||
            !grpc_closure_list_empty(closure_list_);
   }
 
-  /** Flush any work that has been enqueued onto this grpc_exec_ctx.
-   *  Caller must guarantee that no interfering locks are held.
-   *  Returns true if work was performed, false otherwise.
-   */
+  /// Flush any work that has been enqueued onto this grpc_exec_ctx.
+  /// Caller must guarantee that no interfering locks are held.
+  /// Returns true if work was performed, false otherwise.
+  ///
   bool Flush();
 
-  /** Returns true if we'd like to leave this execution context as soon as
-   *  possible: useful for deciding whether to do something more or not
-   *  depending on outside context.
-   */
+  /// Returns true if we'd like to leave this execution context as soon as
+  /// possible: useful for deciding whether to do something more or not
+  /// depending on outside context.
+  ///
   bool IsReadyToFinish() {
     if ((flags_ & GRPC_EXEC_CTX_FLAG_IS_FINISHED) == 0) {
       if (CheckReadyToFinish()) {
@@ -184,7 +185,7 @@ class ExecCtx {
   }
   void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
-  /** Gets pointer to current exec_ctx. */
+  /// Gets pointer to current exec_ctx.
   static ExecCtx* Get() { return exec_ctx_; }
 
   static void Run(const DebugLocation& location, grpc_closure* closure,
@@ -193,14 +194,14 @@ class ExecCtx {
   static void RunList(const DebugLocation& location, grpc_closure_list* list);
 
  protected:
-  /** Check if ready to finish. */
+  /// Check if ready to finish.
   virtual bool CheckReadyToFinish() { return false; }
 
-  /** Disallow delete on ExecCtx. */
+  /// Disallow delete on ExecCtx.
   static void operator delete(void* /* p */) { abort(); }
 
  private:
-  /** Set exec_ctx_ to exec_ctx. */
+  /// Set exec_ctx_ to exec_ctx.
   static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
@@ -214,59 +215,59 @@ class ExecCtx {
   ExecCtx* last_exec_ctx_ = Get();
 };
 
-/** Application-callback execution context.
- *  A bag of data that collects information along a callstack.
- *  It is created on the stack at core entry points, and stored internally
- *  as a thread-local variable.
- *
- *  There are three key differences between this structure and ExecCtx:
- *    1. ApplicationCallbackExecCtx builds a list of application-level
- *       callbacks, but ExecCtx builds a list of internal callbacks to invoke.
- *    2. ApplicationCallbackExecCtx invokes its callbacks only at destruction;
- *       there is no explicit Flush method.
- *    3. If more than one ApplicationCallbackExecCtx is created on the thread's
- *       stack, only the one closest to the base of the stack is actually
- *       active and this is the only one that enqueues application callbacks.
- *       (Unlike ExecCtx, it is not feasible to prevent multiple of these on the
- *       stack since the executing application callback may itself enter core.
- *       However, the new one created will just pass callbacks through to the
- *       base one and those will not be executed until the return to the
- *       destructor of the base one, preventing unlimited stack growth.)
- *
- *  This structure exists because application callbacks may themselves cause a
- *  core re-entry (e.g., through a public API call) and if that call in turn
- *  causes another application-callback, there could be arbitrarily growing
- *  stacks of core re-entries. Instead, any application callbacks instead should
- *  not be invoked until other core work is done and other application callbacks
- *  have completed. To accomplish this, any application callback should be
- *  enqueued using ApplicationCallbackExecCtx::Enqueue .
- *
- *  CONVENTIONS:
- *  - Instances of this must ALWAYS be constructed on the stack, never
- *    heap allocated.
- *  - Instances of this are generally constructed before ExecCtx when needed.
- *    The only exception is for ExecCtx's that are explicitly flushed and
- *    that survive beyond the scope of the function that can cause application
- *    callbacks to be invoked (e.g., in the timer thread).
- *
- *  Generally, core entry points that may trigger application-level callbacks
- *  will have the following declarations:
- *
- *  ApplicationCallbackExecCtx callback_exec_ctx;
- *  ExecCtx exec_ctx;
- *
- *  This ordering is important to make sure that the ApplicationCallbackExecCtx
- *  is destroyed after the ExecCtx (to prevent the re-entry problem described
- *  above, as well as making sure that ExecCtx core callbacks are invoked first)
- *
- */
+/// Application-callback execution context.
+/// A bag of data that collects information along a callstack.
+/// It is created on the stack at core entry points, and stored internally
+/// as a thread-local variable.
+///
+/// There are three key differences between this structure and ExecCtx:
+///   1. ApplicationCallbackExecCtx builds a list of application-level
+///      callbacks, but ExecCtx builds a list of internal callbacks to invoke.
+///   2. ApplicationCallbackExecCtx invokes its callbacks only at destruction;
+///      there is no explicit Flush method.
+///   3. If more than one ApplicationCallbackExecCtx is created on the thread's
+///      stack, only the one closest to the base of the stack is actually
+///      active and this is the only one that enqueues application callbacks.
+///      (Unlike ExecCtx, it is not feasible to prevent multiple of these on the
+///      stack since the executing application callback may itself enter core.
+///      However, the new one created will just pass callbacks through to the
+///      base one and those will not be executed until the return to the
+///      destructor of the base one, preventing unlimited stack growth.)
+///
+/// This structure exists because application callbacks may themselves cause a
+/// core re-entry (e.g., through a public API call) and if that call in turn
+/// causes another application-callback, there could be arbitrarily growing
+/// stacks of core re-entries. Instead, any application callbacks instead should
+/// not be invoked until other core work is done and other application callbacks
+/// have completed. To accomplish this, any application callback should be
+/// enqueued using ApplicationCallbackExecCtx::Enqueue .
+///
+/// CONVENTIONS:
+/// - Instances of this must ALWAYS be constructed on the stack, never
+///   heap allocated.
+/// - Instances of this are generally constructed before ExecCtx when needed.
+///   The only exception is for ExecCtx's that are explicitly flushed and
+///   that survive beyond the scope of the function that can cause application
+///   callbacks to be invoked (e.g., in the timer thread).
+///
+/// Generally, core entry points that may trigger application-level callbacks
+/// will have the following declarations:
+///
+/// ApplicationCallbackExecCtx callback_exec_ctx;
+/// ExecCtx exec_ctx;
+///
+/// This ordering is important to make sure that the ApplicationCallbackExecCtx
+/// is destroyed after the ExecCtx (to prevent the re-entry problem described
+/// above, as well as making sure that ExecCtx core callbacks are invoked first)
+///
+///
 
 class ApplicationCallbackExecCtx {
  public:
-  /** Default Constructor */
+  /// Default Constructor
   ApplicationCallbackExecCtx() { Set(this, flags_); }
 
-  /** Parameterised Constructor */
+  /// Parameterised Constructor
   explicit ApplicationCallbackExecCtx(uintptr_t fl) : flags_(fl) {
     Set(this, flags_);
   }
@@ -330,4 +331,4 @@ class ApplicationCallbackExecCtx {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */
+#endif  // GRPC_CORE_LIB_IOMGR_EXEC_CTX_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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>
 
@@ -28,6 +28,7 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -175,8 +176,8 @@ void Executor::SetThreading(bool threading) {
       gpr_mu_unlock(&thd_state_[i].mu);
     }
 
-    /* Ensure no thread is adding a new thread. Once this is past, then no
-     * thread will try to add a new one either (since shutdown is true) */
+    // Ensure no thread is adding a new thread. Once this is past, then no
+    // thread will try to add a new one either (since shutdown is true)
     gpr_spinlock_lock(&adding_thread_lock_);
     gpr_spinlock_unlock(&adding_thread_lock_);
 

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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_IOMGR_EXECUTOR_H
 #define GRPC_CORE_LIB_IOMGR_EXECUTOR_H
@@ -58,18 +58,18 @@ class Executor {
 
   void Init();
 
-  /** Is the executor multi-threaded? */
+  /// Is the executor multi-threaded?
   bool IsThreaded() const;
 
-  /* Enable/disable threading - must be called after Init and Shutdown(). Never
-   * call SetThreading(false) in the middle of an application */
+  // Enable/disable threading - must be called after Init and Shutdown(). Never
+  // call SetThreading(false) in the middle of an application
   void SetThreading(bool threading);
 
-  /** Shutdown the executor, running all pending work as part of the call */
+  /// Shutdown the executor, running all pending work as part of the call
   void Shutdown();
 
-  /** Enqueue the closure onto the executor. is_short is true if the closure is
-   * a short job (i.e expected to not block and complete quickly) */
+  /// Enqueue the closure onto the executor. is_short is true if the closure is
+  /// a short job (i.e expected to not block and complete quickly)
   void Enqueue(grpc_closure* closure, grpc_error_handle error, bool is_short);
 
   // TODO(sreek): Currently we have two executors (available globally): The
@@ -116,4 +116,4 @@ class Executor {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */
+#endif  // GRPC_CORE_LIB_IOMGR_EXECUTOR_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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>
 
@@ -32,17 +32,19 @@
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
+#include "src/core/lib/surface/init_internally.h"
 
-/*
- * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
- *       AROUND VERY SPECIFIC USE CASES.
- */
+//
+// NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
+//       AROUND VERY SPECIFIC USE CASES.
+//
 
 namespace {
 bool skipped_handler = true;
@@ -53,7 +55,7 @@ void grpc_prefork() {
   skipped_handler = true;
   // This  may be called after core shuts down, so verify initialized before
   // instantiating an ExecCtx.
-  if (!grpc_is_initialized()) {
+  if (!grpc_core::IsInitializedInternally()) {
     return;
   }
   grpc_core::ExecCtx exec_ctx;

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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>
 
@@ -25,10 +25,10 @@
 #include <grpc/fork.h>
 #include <grpc/support/log.h>
 
-/*
- * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
- *       AROUND VERY SPECIFIC USE CASES.
- */
+//
+// NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
+//       AROUND VERY SPECIFIC USE CASES.
+//
 
 void grpc_prefork() { gpr_log(GPR_ERROR, "Forking not supported on Windows"); }