Merge "audio_mutex: Add APM mutex order" into main

2 files changed, 135 insertions, 62 deletions

diff --git a/audio_utils/include/audio_utils/mutex.h b/audio_utils/include/audio_utils/mutex.h
index c78860ff..cb59397a 100644
--- a/audio_utils/include/audio_utils/mutex.h
+++ b/audio_utils/include/audio_utils/mutex.h
@@ -49,34 +49,47 @@ namespace android::audio_utils {
 
 // Lock order
 enum class MutexOrder : uint32_t {
-    kEffectHandle_Mutex = 0,
-    kEffectBase_PolicyMutex = 1,
-    kAudioFlinger_Mutex = 2,
-    kAudioFlinger_HardwareMutex = 3,
-    kDeviceEffectManager_Mutex = 4,
-    kPatchCommandThread_Mutex = 5,
-    kThreadBase_Mutex = 6,
-    kAudioFlinger_ClientMutex = 7,
-    kMelReporter_Mutex = 8,
-    kEffectChain_Mutex = 9,
-    kDeviceEffectProxy_ProxyMutex = 10,
-    kEffectBase_Mutex = 11,
-    kAudioFlinger_UnregisteredWritersMutex = 12,
-    kAsyncCallbackThread_Mutex = 13,
-    kConfigEvent_Mutex = 14,
-    kOutputTrack_TrackMetadataMutex = 15,
-    kPassthruPatchRecord_ReadMutex = 16,
-    kPatchCommandThread_ListenerMutex = 17,
-    kPlaybackThread_AudioTrackCbMutex = 18,
-    kMediaLogNotifier_Mutex = 19,
-    kOtherMutex = 20,
-    kSize = 21,
+    kSpatializer_Mutex = 0,
+    kAudioPolicyEffects_Mutex = 1,
+    kEffectHandle_Mutex = 2,
+    kEffectBase_PolicyMutex = 3,
+    kAudioPolicyService_Mutex = 4,
+    kCommandThread_Mutex = 5,
+    kAudioCommand_Mutex = 6,
+    kUidPolicy_Mutex = 7,
+    kAudioFlinger_Mutex = 8,
+    kAudioFlinger_HardwareMutex = 9,
+    kDeviceEffectManager_Mutex = 10,
+    kPatchCommandThread_Mutex = 11,
+    kThreadBase_Mutex = 12,
+    kAudioFlinger_ClientMutex = 13,
+    kMelReporter_Mutex = 14,
+    kEffectChain_Mutex = 15,
+    kDeviceEffectProxy_ProxyMutex = 16,
+    kEffectBase_Mutex = 17,
+    kAudioFlinger_UnregisteredWritersMutex = 18,
+    kAsyncCallbackThread_Mutex = 19,
+    kConfigEvent_Mutex = 20,
+    kOutputTrack_TrackMetadataMutex = 21,
+    kPassthruPatchRecord_ReadMutex = 22,
+    kPatchCommandThread_ListenerMutex = 23,
+    kPlaybackThread_AudioTrackCbMutex = 24,
+    kAudioPolicyService_NotificationClientsMutex = 25,
+    kMediaLogNotifier_Mutex = 26,
+    kOtherMutex = 27,
+    kSize = 28,
 };
 
 // Lock by name
 inline constexpr const char* const gMutexNames[] = {
+    "Spatializer_Mutex",
+    "AudioPolicyEffects_Mutex",
     "EffectHandle_Mutex",
     "EffectBase_PolicyMutex",
+    "AudioPolicyService_Mutex",
+    "CommandThread_Mutex",
+    "AudioCommand_Mutex",
+    "UidPolicy_Mutex",
     "AudioFlinger_Mutex",
     "AudioFlinger_HardwareMutex",
     "DeviceEffectManager_Mutex",
@@ -94,6 +107,7 @@ inline constexpr const char* const gMutexNames[] = {
     "PassthruPatchRecord_ReadMutex",
     "PatchCommandThread_ListenerMutex",
     "PlaybackThread_AudioTrackCbMutex",
+    "AudioPolicyService_NotificationClientsMutex",
     "MediaLogNotifier_Mutex",
     "OtherMutex",
 };
@@ -105,11 +119,23 @@ using mutex = mutex_impl<AudioMutexAttributes>;
 
 // Capabilities in priority order
 // (declaration only, value is nullptr)
-inline mutex* EffectHandle_Mutex;
+inline mutex* Spatializer_Mutex;
+inline mutex* AudioPolicyEffects_Mutex
+        ACQUIRED_AFTER(android::audio_utils::Spatializer_Mutex);
+inline mutex* EffectHandle_Mutex
+        ACQUIRED_AFTER(android::audio_utils::AudioPolicyEffects_Mutex);
 inline mutex* EffectBase_PolicyMutex
         ACQUIRED_AFTER(android::audio_utils::EffectHandle_Mutex);
-inline mutex* AudioFlinger_Mutex
+inline mutex* AudioPolicyService_Mutex
         ACQUIRED_AFTER(android::audio_utils::EffectBase_PolicyMutex);
+inline mutex* CommandThread_Mutex
+        ACQUIRED_AFTER(android::audio_utils::AudioPolicyService_Mutex);
+inline mutex* AudioCommand_Mutex
+        ACQUIRED_AFTER(android::audio_utils::CommandThread_Mutex);
+inline mutex* UidPolicy_Mutex
+        ACQUIRED_AFTER(android::audio_utils::AudioCommand_Mutex);
+inline mutex* AudioFlinger_Mutex
+        ACQUIRED_AFTER(android::audio_utils::UidPolicy_Mutex);
 inline mutex* AudioFlinger_HardwareMutex
         ACQUIRED_AFTER(android::audio_utils::AudioFlinger_Mutex);
 inline mutex* DeviceEffectManager_Mutex
@@ -142,8 +168,10 @@ inline mutex* PatchCommandThread_ListenerMutex
         ACQUIRED_AFTER(android::audio_utils::PassthruPatchRecord_ReadMutex);
 inline mutex* PlaybackThread_AudioTrackCbMutex
         ACQUIRED_AFTER(android::audio_utils::PatchCommandThread_ListenerMutex);
-inline mutex* MediaLogNotifier_Mutex
+inline mutex* AudioPolicyService_NotificationClientsMutex
         ACQUIRED_AFTER(android::audio_utils::PlaybackThread_AudioTrackCbMutex);
+inline mutex* MediaLogNotifier_Mutex
+        ACQUIRED_AFTER(android::audio_utils::AudioPolicyService_NotificationClientsMutex);
 inline mutex* OtherMutex
         ACQUIRED_AFTER(android::audio_utils::MediaLogNotifier_Mutex);
 
@@ -159,8 +187,14 @@ inline mutex* OtherMutex
     EXCLUDES(android::audio_utils::MediaLogNotifier_Mutex) \
     EXCLUDES_BELOW_MediaLogNotifier_Mutex
 
-#define EXCLUDES_BELOW_PlaybackThread_AudioTrackCbMutex \
+#define EXCLUDES_BELOW_AudioPolicyService_NotificationClientsMutex \
     EXCLUDES_MediaLogNotifier_Mutex
+#define EXCLUDES_AudioPolicyService_NotificationClientsMutex \
+    EXCLUDES(android::audio_utils::AudioPolicyService_NotificationClientsMutex) \
+    EXCLUDES_BELOW_AudioPolicyService_NotificationClientsMutex
+
+#define EXCLUDES_BELOW_PlaybackThread_AudioTrackCbMutex \
+    EXCLUDES_AudioPolicyService_NotificationClientsMutex
 #define EXCLUDES_PlaybackThread_AudioTrackCbMutex \
     EXCLUDES(android::audio_utils::PlaybackThread_AudioTrackCbMutex) \
     EXCLUDES_BELOW_PlaybackThread_AudioTrackCbMutex
@@ -261,8 +295,32 @@ inline mutex* OtherMutex
     EXCLUDES(android::audio_utils::AudioFlinger_Mutex) \
     EXCLUDES_BELOW_AudioFlinger_Mutex
 
-#define EXCLUDES_BELOW_EffectBase_PolicyMutex \
+#define EXCLUDES_BELOW_UidPolicy_Mutex \
     EXCLUDES_AudioFlinger_Mutex
+#define EXCLUDES_UidPolicy_Mutex \
+    EXCLUDES(android::audio_utils::UidPolicy_Mutex) \
+    EXCLUDES_BELOW_UidPolicy_Mutex
+
+#define EXCLUDES_BELOW_AudioCommand_Mutex \
+    EXCLUDES_UidPolicy_Mutex
+#define EXCLUDES_AudioCommand_Mutex \
+    EXCLUDES(android::audio_utils::AudioCommand_Mutex) \
+    EXCLUDES_BELOW_AudioCommand_Mutex
+
+#define EXCLUDES_BELOW_CommandThread_Mutex \
+    EXCLUDES_AudioCommand_Mutex
+#define EXCLUDES_CommandThread_Mutex \
+    EXCLUDES(android::audio_utils::CommandThread_Mutex) \
+    EXCLUDES_BELOW_CommandThread_Mutex
+
+#define EXCLUDES_BELOW_AudioPolicyService_Mutex \
+    EXCLUDES_CommandThread_Mutex
+#define EXCLUDES_AudioPolicyService_Mutex \
+    EXCLUDES(android::audio_utils::AudioPolicyService_Mutex) \
+    EXCLUDES_BELOW_AudioPolicyService_Mutex
+
+#define EXCLUDES_BELOW_EffectBase_PolicyMutex \
+    EXCLUDES_AudioPolicyService_Mutex
 #define EXCLUDES_EffectBase_PolicyMutex \
     EXCLUDES(android::audio_utils::EffectBase_PolicyMutex) \
     EXCLUDES_BELOW_EffectBase_PolicyMutex
@@ -273,8 +331,20 @@ inline mutex* OtherMutex
     EXCLUDES(android::audio_utils::EffectHandle_Mutex) \
     EXCLUDES_BELOW_EffectHandle_Mutex
 
-#define EXCLUDES_AUDIO_ALL \
+#define EXCLUDES_BELOW_AudioPolicyEffects_Mutex \
     EXCLUDES_EffectHandle_Mutex
+#define EXCLUDES_AudioPolicyEffects_Mutex \
+    EXCLUDES(android::audio_utils::AudioPolicyEffects_Mutex) \
+    EXCLUDES_BELOW_AudioPolicyEffects_Mutex
+
+#define EXCLUDES_BELOW_Spatializer_Mutex \
+    EXCLUDES_AudioPolicyEffects_Mutex
+#define EXCLUDES_Spatializer_Mutex \
+    EXCLUDES(android::audio_utils::Spatializer_Mutex) \
+    EXCLUDES_BELOW_Spatializer_Mutex
+
+#define EXCLUDES_AUDIO_ALL \
+    EXCLUDES_Spatializer_Mutex
 
 // --- End generated section
 
diff --git a/audio_utils/tests/generate_mutex_order.cpp b/audio_utils/tests/generate_mutex_order.cpp
index 0f9f45dd..feec60c5 100644
--- a/audio_utils/tests/generate_mutex_order.cpp
+++ b/audio_utils/tests/generate_mutex_order.cpp
@@ -22,14 +22,6 @@
 // $ ./a.out
 //
 
-// Some versions of clang do not include std::size().
-// Provide our own copy in case it is not available.
-template <class T, std::size_t N>
-constexpr size_t size(const T (&array)[N]) noexcept
-{
-    return N;
-}
-
 constexpr const char* mutexes[] {
   // These mutexes obey partial ordering rules.
   // 1) AudioFlinger::mutex() -> PatchCommandThread::mutex() -> MelReporter::mutex().
@@ -41,31 +33,42 @@ constexpr const char* mutexes[] {
   // 4) AudioFlinger -> ThreadBase -> EffectChain -> EffectBase(EffectModule)
   // 5) EffectHandle -> ThreadBase -> EffectChain -> EffectBase(EffectModule)
 
-  "EffectHandle_Mutex",
-  "EffectBase_PolicyMutex",  // held for AudioSystem::registerEffect, must come
-                             // after EffectHandle_Mutex.
-  "AudioFlinger_Mutex",
-  "AudioFlinger_HardwareMutex",
-  "DeviceEffectManager_Mutex",
-  "PatchCommandThread_Mutex",
-  "ThreadBase_Mutex",
-  "AudioFlinger_ClientMutex",
-  "MelReporter_Mutex",
-  "EffectChain_Mutex",
-  "DeviceEffectProxy_ProxyMutex",  // used for device effects (which have no chain).
-  "EffectBase_Mutex",
+
+  "Spatializer_Mutex",         // AP - must come before EffectHandle_Mutex
+  "AudioPolicyEffects_Mutex",  // AP - never hold AudioPolicyEffects_Mutex while calling APS,
+                               // not sure if this is still true.
+  "EffectHandle_Mutex",        // AF - must be after AudioPolicyEffects_Mutex
+  "EffectBase_PolicyMutex",    // AF - Held for AudioSystem::registerEffect, must come
+                               // after EffectHandle_Mutex and before AudioPolicyService_Mutex
+
+  "AudioPolicyService_Mutex",  // AP
+  "CommandThread_Mutex",       // AP
+  "AudioCommand_Mutex",        // AP
+  "UidPolicy_Mutex",           // AP
+
+  "AudioFlinger_Mutex",            // AF
+  "AudioFlinger_HardwareMutex",    // AF
+  "DeviceEffectManager_Mutex",     // AF
+  "PatchCommandThread_Mutex",      // AF
+  "ThreadBase_Mutex",              // AF
+  "AudioFlinger_ClientMutex",      // AF
+  "MelReporter_Mutex",             // AF
+  "EffectChain_Mutex",             // AF
+  "DeviceEffectProxy_ProxyMutex",  // AF: used for device effects (which have no chain).
+  "EffectBase_Mutex",              // AF
 
   // These mutexes are in leaf objects
   // and are presented afterwards in arbitrary order.
 
-  "AudioFlinger_UnregisteredWritersMutex",
-  "AsyncCallbackThread_Mutex",
-  "ConfigEvent_Mutex",
-  "OutputTrack_TrackMetadataMutex",
-  "PassthruPatchRecord_ReadMutex",
-  "PatchCommandThread_ListenerMutex",
-  "PlaybackThread_AudioTrackCbMutex",
-  "MediaLogNotifier_Mutex",
+  "AudioFlinger_UnregisteredWritersMutex",       // AF
+  "AsyncCallbackThread_Mutex",                   // AF
+  "ConfigEvent_Mutex",                           // AF
+  "OutputTrack_TrackMetadataMutex",              // AF
+  "PassthruPatchRecord_ReadMutex",               // AF
+  "PatchCommandThread_ListenerMutex",            // AF
+  "PlaybackThread_AudioTrackCbMutex",            // AF
+  "AudioPolicyService_NotificationClientsMutex", // AP
+  "MediaLogNotifier_Mutex",                      // AF
   "OtherMutex", // DO NOT CHANGE THIS: OtherMutex is used for mutexes without a specified order.
                 // An OtherMutex will always be the lowest order mutex and cannot acquire
                 // another named mutex while being held.
@@ -80,15 +83,15 @@ int main() {
   cout << "// Lock order\n";
   cout << "enum class MutexOrder : uint32_t {\n";
 
-  for (size_t i = 0; i < size(mutexes); ++i) {
+  for (size_t i = 0; i < std::size(mutexes); ++i) {
       cout << "    k" << mutexes[i] << " = " << i << ",\n";
   }
-  cout << "    kSize = " << size(mutexes) << ",\n";
+  cout << "    kSize = " << std::size(mutexes) << ",\n";
   cout << "};\n";
 
   cout << "\n// Lock by name\n";
   cout << "inline constexpr const char* const gMutexNames[] = {\n";
-  for (size_t i = 0; i < size(mutexes); ++i) {
+  for (size_t i = 0; i < std::size(mutexes); ++i) {
       cout << "    \"" << mutexes[i] << "\",\n";
   }
   cout << "};\n";
@@ -115,9 +118,9 @@ int main() {
 
   cout << "// Exclusion by capability\n";
   last = nullptr;
-  for (size_t i = 0; i < size(mutexes); ++i) {
+  for (size_t i = 0; i < std::size(mutexes); ++i) {
     // exclusion is defined in reverse order of priority.
-    auto mutex = mutexes[size(mutexes) - i - 1];
+    auto mutex = mutexes[std::size(mutexes) - i - 1];
     if (last == nullptr) {
       cout << "#define EXCLUDES_BELOW_" << mutex << "\n";
     } else {