cras_thread: Add non-fatal functions to acquire thread ctxs

The non-fatal variants make it easier to workaround
callers on the incorrect thread.

BUG=b:340129658
TEST=bazel test //...

Change-Id: I772a30d8fbe3828e461a3bdebb68d95f1a9fc20e
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/adhd/+/5528492
Tested-by: [email protected] <[email protected]>
Reviewed-by: Yu-Hsuan Hsu <[email protected]>
Commit-Queue: Li-Yu Yu <[email protected]>

Author: afq984

cras/server/cras_thread.c

@@ -14,20 +14,36 @@
 static thread_local bool main_ctx_allowed = false;
 static thread_local bool audio_ctx_allowed = false;
 
+static struct cras_main_ctx mctx = {};
+
 struct cras_main_ctx* checked_main_ctx() {
   CRAS_CHECK(main_ctx_allowed);
 
-  static struct cras_main_ctx mctx = {};
   return &mctx;
 }
 
+struct cras_main_ctx* get_main_ctx_or_null() {
+  if (main_ctx_allowed) {
+    return &mctx;
+  }
+  return NULL;
+}
+
+static struct cras_audio_ctx actx = {};
+
 struct cras_audio_ctx* checked_audio_ctx() {
   CRAS_CHECK(audio_ctx_allowed);
 
-  static struct cras_audio_ctx actx = {};
   return &actx;
 }
 
+struct cras_audio_ctx* get_audio_ctx_or_null() {
+  if (audio_ctx_allowed) {
+    return &actx;
+  }
+  return NULL;
+}
+
 __attribute__((constructor)) static void init() {
   main_ctx_allowed = audio_ctx_allowed = true;
 }

cras/server/cras_thread.h

@@ -30,6 +30,13 @@ struct cras_audio_ctx {
 // Otherwise aborts (SIGABRT) the program.
 struct cras_main_ctx* checked_main_ctx();
 
+// Like checked_main_ctx() but returns NULL instead of SIGABRT-ing when
+// called from the wrong thread.
+//
+// Use this instead of checked_main_ctx() only when you need to workaround
+// unexpected callers gracefully.
+struct cras_main_ctx* get_main_ctx_or_null();
+
 // Returns the audio thread context singleton if any of the following is true:
 // - The current thread is the audio thread
 // - The audio thread has not started yet.
@@ -38,6 +45,13 @@ struct cras_main_ctx* checked_main_ctx();
 // Otherwise aborts (SIGABRT) the program.
 struct cras_audio_ctx* checked_audio_ctx();
 
+// Like checked_audio_ctx() but returns NULL instead of SIGABRT-ing when
+// called from the wrong thread.
+//
+// Use this instead of checked_audio_ctx() only when you need to workaround
+// unexpected callers gracefully.
+struct cras_audio_ctx* get_audio_ctx_or_null();
+
 // Wrapper to create the audio thread.
 int cras_thread_create_audio(pthread_t* thread,
                              const pthread_attr_t* attr,

cras/server/cras_thread_test.cc

@@ -9,13 +9,18 @@
 // be one the main thread.
 TEST(CrasThread, Checks) {
   // Both contexts are allowed on the main thread.
+  EXPECT_TRUE(get_main_ctx_or_null());
+  EXPECT_TRUE(get_audio_ctx_or_null());
   checked_main_ctx()->test_num = 1;
   checked_audio_ctx()->test_num = 2;
 
   {
     pthread_t child_tid = {};
     auto audio_thread = [](void* data) -> void* {
+      // main_ctx disallowed in the audio thread.
+      EXPECT_FALSE(get_main_ctx_or_null());
       // audio_ctx allowed in the audio thread.
+      EXPECT_TRUE(get_audio_ctx_or_null());
       EXPECT_EQ(checked_audio_ctx()->test_num, 2);
       return nullptr;
     };
@@ -24,8 +29,10 @@ TEST(CrasThread, Checks) {
         0);
     EXPECT_NE(pthread_self(), child_tid);
     // main_ctx allowed after creating the audio thread.
+    EXPECT_TRUE(get_main_ctx_or_null());
     EXPECT_EQ(checked_main_ctx()->test_num, 1);
     // audio_ctx not allowed after creating the audio thread.
+    EXPECT_FALSE(get_audio_ctx_or_null());
     EXPECT_EXIT(checked_audio_ctx(), testing::KilledBySignal(SIGABRT),
                 "audio_ctx_allowed");
     pthread_join(child_tid, nullptr);