ScoopDroid/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Add heuristic data race detection to sp<>"

Browse source
This commit is contained in:
Hans Boehm 2017-03-19 04:45:36 +00:00 • committed by Gerrit Code Review
commit 04abdc6153
3 changed files with 51 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libutils/Android.bp
View file

@ -45,6 +45,7 @@ cc_library {
"StopWatch.cpp", "StopWatch.cpp",
"String8.cpp", "String8.cpp",
"String16.cpp", "String16.cpp",
"StrongPointer.cpp",
"SystemClock.cpp", "SystemClock.cpp",
"Threads.cpp", "Threads.cpp",
"Timers.cpp", "Timers.cpp",

24
libutils/StrongPointer.cpp Normal file
View file

@ -0,0 +1,24 @@
/*
* Copyright (C) 2017 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.
*/
#define LOG_TAG "sp"
#include <log/log.h>
namespace android {
void sp_report_race() { LOG_ALWAYS_FATAL("sp<> assignment detected data race"); }
}

46
libutils/include/utils/StrongPointer.h
View file

@ -108,6 +108,9 @@ private:
T* m_ptr; T* m_ptr;
}; };
// For code size reasons, we do not want this inlined or templated.
void sp_report_race();
#undef COMPARE #undef COMPARE
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -161,19 +164,21 @@ sp<T>::~sp() {
template<typename T> template<typename T>
sp<T>& sp<T>::operator =(const sp<T>& other) { sp<T>& sp<T>::operator =(const sp<T>& other) {
// Force m_ptr to be read twice, to heuristically check for data races.
T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
T* otherPtr(other.m_ptr); T* otherPtr(other.m_ptr);
if (otherPtr) if (otherPtr) otherPtr->incStrong(this);
otherPtr->incStrong(this); if (oldPtr) oldPtr->decStrong(this);
if (m_ptr) if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
m_ptr->decStrong(this);
m_ptr = otherPtr; m_ptr = otherPtr;
return *this; return *this;
} }
template<typename T> template<typename T>
sp<T>& sp<T>::operator =(sp<T>&& other) { sp<T>& sp<T>::operator =(sp<T>&& other) {
if (m_ptr) T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
m_ptr->decStrong(this); if (oldPtr) oldPtr->decStrong(this);
if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
m_ptr = other.m_ptr; m_ptr = other.m_ptr;
other.m_ptr = nullptr; other.m_ptr = nullptr;
return *this; return *this;
@ -181,29 +186,30 @@ sp<T>& sp<T>::operator =(sp<T>&& other) {
template<typename T> template<typename T>
sp<T>& sp<T>::operator =(T* other) { sp<T>& sp<T>::operator =(T* other) {
if (other) T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
other->incStrong(this); if (other) other->incStrong(this);
if (m_ptr) if (oldPtr) oldPtr->decStrong(this);
m_ptr->decStrong(this); if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
m_ptr = other; m_ptr = other;
return *this; return *this;
} }
template<typename T> template<typename U> template<typename T> template<typename U>
sp<T>& sp<T>::operator =(const sp<U>& other) { sp<T>& sp<T>::operator =(const sp<U>& other) {
T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
T* otherPtr(other.m_ptr); T* otherPtr(other.m_ptr);
if (otherPtr) if (otherPtr) otherPtr->incStrong(this);
otherPtr->incStrong(this); if (oldPtr) oldPtr->decStrong(this);
if (m_ptr) if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
m_ptr->decStrong(this);
m_ptr = otherPtr; m_ptr = otherPtr;
return *this; return *this;
} }
template<typename T> template<typename U> template<typename T> template<typename U>
sp<T>& sp<T>::operator =(sp<U>&& other) { sp<T>& sp<T>::operator =(sp<U>&& other) {
if (m_ptr) T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
m_ptr->decStrong(this); if (m_ptr) m_ptr->decStrong(this);
if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
m_ptr = other.m_ptr; m_ptr = other.m_ptr;
other.m_ptr = nullptr; other.m_ptr = nullptr;
return *this; return *this;
@ -211,10 +217,10 @@ sp<T>& sp<T>::operator =(sp<U>&& other) {
template<typename T> template<typename U> template<typename T> template<typename U>
sp<T>& sp<T>::operator =(U* other) { sp<T>& sp<T>::operator =(U* other) {
if (other) T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
(static_cast<T*>(other))->incStrong(this); if (other) (static_cast<T*>(other))->incStrong(this);
if (m_ptr) if (oldPtr) oldPtr->decStrong(this);
m_ptr->decStrong(this); if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
m_ptr = other; m_ptr = other;
return *this; return *this;
} }