Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b54b40bb authored by Leon Scroggins III's avatar Leon Scroggins III
Browse files

FTL: Add wrapper for shared_mutex 

std::shared_mutex on Android is missing capabilities necessary for
threading annotations. b/135688034 tracks adding them, but is blocked on
b/175635923. In the meantime, add a simple wrapper so that we can start
using annotations.

Only add the methods we currently need. Other methods can be added as
needed.

Bug: 185536303
Test: ftl_test
Change-Id: Ic7c2152bc7e46b31eecdba42fac1126b26aafd60
parent ecd23b16

include/ftl/shared_mutex.h

0 → 100644
+47 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2022 The Android Open Source Project

 *

 * 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.

 */



#pragma once



#include <shared_mutex>



namespace android::ftl {



// Wrapper around std::shared_mutex to provide capabilities for thread-safety

// annotations.

// TODO(b/257958323): This class is no longer needed once b/135688034 is fixed (currently blocked on

// b/175635923).

class [[clang::capability("shared_mutex")]] SharedMutex final {

 public:

  [[clang::acquire_capability()]] void lock() {

    mutex_.lock();

  }

  [[clang::release_capability()]] void unlock() {

    mutex_.unlock();

  }



  [[clang::acquire_shared_capability()]] void lock_shared() {

    mutex_.lock_shared();

  }

  [[clang::release_shared_capability()]] void unlock_shared() {

    mutex_.unlock_shared();

  }



 private:

  std::shared_mutex mutex_;

};



}  // namespace android::ftl

libs/ftl/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ cc_test { 
        "match_test.cpp",

        "non_null_test.cpp",

        "optional_test.cpp",

        "shared_mutex_test.cpp",

        "small_map_test.cpp",

        "small_vector_test.cpp",

        "static_vector_test.cpp",

libs/ftl/shared_mutex_test.cpp

0 → 100644
+60 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2022 The Android Open Source Project

 *

 * 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 <ftl/shared_mutex.h>

#include <gtest/gtest.h>

#include <ftl/fake_guard.h>



namespace android::test {



TEST(SharedMutex, SharedLock) {

  ftl::SharedMutex mutex;

  std::shared_lock shared_lock(mutex);



  { std::shared_lock shared_lock2(mutex); }

}



TEST(SharedMutex, ExclusiveLock) {

  ftl::SharedMutex mutex;

  std::unique_lock unique_lock(mutex);

}



TEST(SharedMutex, Annotations) {

  struct {

    void foo() FTL_ATTRIBUTE(requires_shared_capability(mutex)) { num++; }

    void bar() FTL_ATTRIBUTE(requires_capability(mutex)) { num++; }

    void baz() {

      std::shared_lock shared_lock(mutex);

      num++;

    }

    ftl::SharedMutex mutex;

    int num = 0;



  } s;



  {

    // TODO(b/257958323): Use an RAII class instead of locking manually.

    s.mutex.lock_shared();

    s.foo();

    s.baz();

    s.mutex.unlock_shared();

  }

  s.mutex.lock();

  s.bar();

  s.mutex.unlock();

}



}  // namespace android::test