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

Commit b9d0753d authored by Hans Boehm's avatar Hans Boehm
Browse files

Revert "Prepare to fail in RefBase destructor if count is untouched" 

This reverts commit 9d3146af.

Reason for revert: It appears that weak symbols don't work as expected on MacOS, breaking the MacOS aapt build.

Change-Id: Ica0955106485a7bf2e2c3f09ff7910e230eb4139
parent 9d3146af

libbacktrace/include/backtrace/BacktraceMap.h

+0 −1
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ 


#include <deque>

#include <iterator>

#include <memory>

#include <string>

#include <vector>

libutils/CallStack.cpp

+4 −25
Original line number Diff line number Diff line
@@ -16,15 +16,16 @@ 


#define LOG_TAG "CallStack"



#include <utils/CallStack.h>



#include <memory>



#include <utils/Printer.h>

#include <utils/Errors.h>

#include <utils/Log.h>



#include <backtrace/Backtrace.h>



#define CALLSTACK_WEAK  // Don't generate weak definitions.

#include <utils/CallStack.h>



namespace android {



CallStack::CallStack() {
@@ -75,26 +76,4 @@ void CallStack::print(Printer& printer) const { 
    }

}



// The following four functions may be used via weak symbol references from libutils.

// Clients assume that if any of these symbols are available, then deleteStack() is.



CallStack::CallStackUPtr CallStack::getCurrentInternal(int ignoreDepth) {

    CallStack::CallStackUPtr stack(new CallStack());

    stack->update(ignoreDepth + 1);

    return stack;

}



void CallStack::logStackInternal(const char* logtag, const CallStack* stack,

                                 android_LogPriority priority) {

    stack->log(logtag, priority);

}



String8 CallStack::stackToStringInternal(const char* prefix, const CallStack* stack) {

    return stack->toString(prefix);

}



void CallStack::deleteStack(CallStack* stack) {

    delete stack;

}



}; // namespace android

libutils/RefBase.cpp

+23 −34
Original line number Diff line number Diff line
@@ -17,23 +17,17 @@ 
#define LOG_TAG "RefBase"

// #define LOG_NDEBUG 0



#include <memory>



#include <utils/RefBase.h>



#include <utils/CallStack.h>



#include <utils/Mutex.h>



#ifndef __unused

#define __unused __attribute__((__unused__))

#endif



// Compile with refcounting debugging enabled.

// compile with refcounting debugging enabled

#define DEBUG_REFS                      0



// The following three are ignored unless DEBUG_REFS is set.



// whether ref-tracking is enabled by default, if not, trackMe(true, false)

// needs to be called explicitly

#define DEBUG_REFS_ENABLED_BY_DEFAULT   0
@@ -48,11 +42,6 @@ 
// log all reference counting operations

#define PRINT_REFS                      0



// Continue after logging a stack trace if ~RefBase discovers that reference

// count has never been incremented. Normally we conspicuously crash in that

// case.

#define DEBUG_REFBASE_DESTRUCTION 1



// ---------------------------------------------------------------------------



namespace android {
@@ -195,7 +184,7 @@ public: 
                char inc = refs->ref >= 0 ? '+' : '-';

                ALOGD("\t%c ID %p (ref %d):", inc, refs->id, refs->ref);

#if DEBUG_REFS_CALLSTACK_ENABLED

                CallStack::logStack(LOG_TAG, refs->stack.get());

                refs->stack.log(LOG_TAG);

#endif

                refs = refs->next;

            }
@@ -209,14 +198,14 @@ public: 
                char inc = refs->ref >= 0 ? '+' : '-';

                ALOGD("\t%c ID %p (ref %d):", inc, refs->id, refs->ref);

#if DEBUG_REFS_CALLSTACK_ENABLED

                CallStack::logStack(LOG_TAG, refs->stack.get());

                refs->stack.log(LOG_TAG);

#endif

                refs = refs->next;

            }

        }

        if (dumpStack) {

            ALOGE("above errors at:");

            CallStack::logStack(LOG_TAG);

            CallStack stack(LOG_TAG);

        }

    }
@@ -290,7 +279,7 @@ public: 
                     this);

            int rc = open(name, O_RDWR | O_CREAT | O_APPEND, 644);

            if (rc >= 0) {

                (void)write(rc, text.string(), text.length());

                write(rc, text.string(), text.length());

                close(rc);

                ALOGD("STACK TRACE for %p saved in %s", this, name);

            }
@@ -305,7 +294,7 @@ private: 
        ref_entry* next;

        const void* id;

#if DEBUG_REFS_CALLSTACK_ENABLED

        CallStack::CallStackUPtr stack;

        CallStack stack;

#endif

        int32_t ref;

    };
@@ -322,7 +311,7 @@ private: 
            ref->ref = mRef;

            ref->id = id;

#if DEBUG_REFS_CALLSTACK_ENABLED

            ref->stack = CallStack::getCurrent(2);

            ref->stack.update(2);

#endif

            ref->next = *refs;

            *refs = ref;
@@ -357,7 +346,7 @@ private: 
                ref = ref->next;

            }



            CallStack::logStack(LOG_TAG);

            CallStack stack(LOG_TAG);

        }

    }
@@ -384,7 +373,7 @@ private: 
                     inc, refs->id, refs->ref);

            out->append(buf);

#if DEBUG_REFS_CALLSTACK_ENABLED

            out->append(CallStack::stackToString("\t\t", refs->stack.get()));

            out->append(refs->stack.toString("\t\t"));

#else

            out->append("\t\t(call stacks disabled)");

#endif
@@ -711,16 +700,16 @@ RefBase::~RefBase() 
        if (mRefs->mWeak.load(std::memory_order_relaxed) == 0) {

            delete mRefs;

        }

    } else if (mRefs->mStrong.load(std::memory_order_relaxed) == INITIAL_STRONG_VALUE) {

    } else if (mRefs->mStrong.load(std::memory_order_relaxed)

            == INITIAL_STRONG_VALUE) {

        // We never acquired a strong reference on this object.

#if DEBUG_REFBASE_DESTRUCTION

        // Treating this as fatal is prone to causing boot loops. For debugging, it's

        // better to treat as non-fatal.

        ALOGD("RefBase: Explicit destruction, weak count = %d (in %p)", mRefs->mWeak.load(), this);

        CallStack::logStack(LOG_TAG);

#else

        LOG_ALWAYS_FATAL("RefBase: Explicit destruction, weak count = %d", mRefs->mWeak.load());

#endif

        LOG_ALWAYS_FATAL_IF(mRefs->mWeak.load() != 0,

                "RefBase: Explicit destruction with non-zero weak "

                "reference count");

        // TODO: Always report if we get here. Currently MediaMetadataRetriever

        // C++ objects are inconsistently managed and sometimes get here.

        // There may be other cases, but we believe they should all be fixed.

        delete mRefs;

    }

    // For debugging purposes, clear mRefs.  Ineffective against outstanding wp's.

    const_cast<weakref_impl*&>(mRefs) = nullptr;

libutils/include/utils/CallStack.h

+3 −61
Original line number Diff line number Diff line
@@ -17,8 +17,6 @@ 
#ifndef ANDROID_CALLSTACK_H

#define ANDROID_CALLSTACK_H



#include <memory>



#include <android/log.h>

#include <backtrace/backtrace_constants.h>

#include <utils/String8.h>
@@ -27,11 +25,6 @@ 
#include <stdint.h>

#include <sys/types.h>



#ifndef CALLSTACK_WEAK

#define CALLSTACK_WEAK __attribute__((weak))

#endif

#define ALWAYS_INLINE __attribute__((always_inline))



namespace android {



class Printer;
@@ -70,58 +63,7 @@ public: 
    // Get the count of stack frames that are in this call stack.

    size_t size() const { return mFrameLines.size(); }



    // DO NOT USE ANYTHING BELOW HERE. The following public members are expected

    // to disappear again shortly, once a better replacement facility exists.

    // The replacement facility will be incompatible!



    // Debugging accesses to some basic functionality. These use weak symbols to

    // avoid introducing a dependency on libutilscallstack. Such a dependency from

    // libutils results in a cyclic build dependency. These routines can be called

    // from within libutils. But if the actual library is unavailable, they do

    // nothing.

    //

    // DO NOT USE THESE. They will disappear.

    struct StackDeleter {

        void operator()(CallStack* stack) { deleteStack(stack); }

    };



    typedef std::unique_ptr<CallStack, StackDeleter> CallStackUPtr;



    // Return current call stack if possible, nullptr otherwise.

    static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {

        if (reinterpret_cast<uintptr_t>(getCurrentInternal) == 0) {

            ALOGW("CallStack::getCurrentInternal not linked, returning null");

            return CallStackUPtr(nullptr);

        } else {

            return getCurrentInternal(ignoreDepth);

        }

    }

    static void ALWAYS_INLINE logStack(const char* logtag, CallStack* stack = getCurrent().get(),

                                       android_LogPriority priority = ANDROID_LOG_DEBUG) {

        if (reinterpret_cast<uintptr_t>(logStackInternal) != 0 && stack != nullptr) {

            logStackInternal(logtag, stack, priority);

        } else {

            ALOGW("CallStack::logStackInternal not linked");

        }

    }

    static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,

                                               const CallStack* stack = getCurrent().get()) {

        if (reinterpret_cast<uintptr_t>(stackToStringInternal) != 0 && stack != nullptr) {

            return stackToStringInternal(prefix, stack);

        } else {

            return String8("<CallStack package not linked>");

        }

    }



private:

    static CallStackUPtr CALLSTACK_WEAK getCurrentInternal(int32_t ignoreDepth);

    static void CALLSTACK_WEAK logStackInternal(const char* logtag, const CallStack* stack,

                                                android_LogPriority priority);

    static String8 CALLSTACK_WEAK stackToStringInternal(const char* prefix, const CallStack* stack);

    // The deleter is only invoked on non-null pointers. Hence it will never be

    // invoked if CallStack is not linked.

    static void CALLSTACK_WEAK deleteStack(CallStack* stack);



    Vector<String8> mFrameLines;

};