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

Commit 0a1435d7 authored by Dominik Laskowski's avatar Dominik Laskowski
Browse files

SF: Enforce thread safety for SurfaceFlinger class 

Add thread annotations to display state and accessors. Add macros and
RAII helpers as escape hatches that are stricter and more meaningful
than NO_THREAD_SAFETY_ANALYSIS, and emit error on use of the latter.

Bug: 123715322
Test: Build
Change-Id: Ibada81998d70c940c7406ef292b2d487fb02189d
(cherry picked from commit 6c2c907548d66c699c5f51d21070c4508b30b669)
parent 6a04962e

services/surfaceflinger/SurfaceFlinger.cpp

+119 −111
Original line number Diff line number Diff line
@@ -125,6 +125,19 @@ 
#include "android-base/parseint.h"

#include "android-base/stringprintf.h"



#define MAIN_THREAD ACQUIRE(mStateLock) RELEASE(mStateLock)



#define ON_MAIN_THREAD(expr)                                       \

    [&] {                                                          \

        LOG_FATAL_IF(std::this_thread::get_id() != mMainThreadId); \

        UnnecessaryLock lock(mStateLock);                          \

        return (expr);                                             \

    }()



#undef NO_THREAD_SAFETY_ANALYSIS

#define NO_THREAD_SAFETY_ANALYSIS \

    _Pragma("GCC error \"Prefer MAIN_THREAD macros or {Conditional,Timed,Unnecessary}Lock.\"")



namespace android {



using namespace std::string_literals;
@@ -173,12 +186,12 @@ bool isWideColorMode(const ColorMode colorMode) { 
#pragma clang diagnostic pop



template <typename Mutex>

struct ConditionalLockGuard {

    ConditionalLockGuard(Mutex& mutex, bool lock) : mutex(mutex), lock(lock) {

struct SCOPED_CAPABILITY ConditionalLockGuard {

    ConditionalLockGuard(Mutex& mutex, bool lock) ACQUIRE(mutex) : mutex(mutex), lock(lock) {

        if (lock) mutex.lock();

    }



    ~ConditionalLockGuard() {

    ~ConditionalLockGuard() RELEASE() {

        if (lock) mutex.unlock();

    }
@@ -188,6 +201,27 @@ struct ConditionalLockGuard { 


using ConditionalLock = ConditionalLockGuard<Mutex>;



struct SCOPED_CAPABILITY TimedLock {

    TimedLock(Mutex& mutex, nsecs_t timeout, const char* whence) ACQUIRE(mutex)

          : mutex(mutex), status(mutex.timedLock(timeout)) {

        ALOGE_IF(!locked(), "%s timed out locking: %s (%d)", whence, strerror(-status), status);

    }



    ~TimedLock() RELEASE() {

        if (locked()) mutex.unlock();

    }



    bool locked() const { return status == NO_ERROR; }



    Mutex& mutex;

    const status_t status;

};



struct SCOPED_CAPABILITY UnnecessaryLock {

    explicit UnnecessaryLock(Mutex& mutex) ACQUIRE(mutex) {}

    ~UnnecessaryLock() RELEASE() {}

};



// TODO(b/141333600): Consolidate with HWC2::Display::Config::Builder::getDefaultDensity.

constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV;
@@ -995,7 +1029,7 @@ status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mo 
    }



    auto future = schedule([=]() -> status_t {

        const auto display = getDisplayDeviceLocked(displayToken);

        const auto display = ON_MAIN_THREAD(getDisplayDeviceLocked(displayToken));

        if (!display) {

            ALOGE("Attempt to set allowed display configs for invalid display token %p",

                  displayToken.get());
@@ -1180,7 +1214,7 @@ ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) { 
}



status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {

    schedule([=] {

    schedule([=]() MAIN_THREAD {

        Vector<ColorMode> modes;

        getDisplayColorModes(displayToken, &modes);

        bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
@@ -1226,7 +1260,7 @@ status_t SurfaceFlinger::getAutoLowLatencyModeSupport(const sp<IBinder>& display 
}



void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {

    static_cast<void>(schedule([=] {

    static_cast<void>(schedule([=]() MAIN_THREAD {

        if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {

            getHwComposer().setAutoLowLatencyMode(*displayId, on);

        } else {
@@ -1257,7 +1291,7 @@ status_t SurfaceFlinger::getGameContentTypeSupport(const sp<IBinder>& displayTok 
}



void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {

    static_cast<void>(schedule([=] {

    static_cast<void>(schedule([=]() MAIN_THREAD {

        if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {

            const auto type = on ? hal::ContentType::GAME : hal::ContentType::NONE;

            getHwComposer().setContentType(*displayId, type);
@@ -1323,7 +1357,7 @@ status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder> 
status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,

                                                          bool enable, uint8_t componentMask,

                                                          uint64_t maxFrames) {

    return schedule([=]() -> status_t {

    return schedule([=]() MAIN_THREAD -> status_t {

               if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {

                   return getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,

                                                                           componentMask,
@@ -1392,13 +1426,9 @@ status_t SurfaceFlinger::injectVSync(nsecs_t when) { 
    return mScheduler->injectVSync(when, calculateExpectedPresentTime(when)) ? NO_ERROR : BAD_VALUE;

}



status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const

        NO_THREAD_SAFETY_ANALYSIS {

    // Try to acquire a lock for 1s, fail gracefully

    const status_t err = mStateLock.timedLock(s2ns(1));

    const bool locked = (err == NO_ERROR);

    if (!locked) {

        ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);

status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const {

    TimedLock lock(mStateLock, s2ns(1), __FUNCTION__);

    if (!lock.locked()) {

        return TIMED_OUT;

    }
@@ -1407,7 +1437,6 @@ status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayer 
    mCurrentState.traverseInZOrder(

            [&](Layer* layer) { outLayers->push_back(layer->getLayerDebugInfo(display.get())); });



    mStateLock.unlock();

    return NO_ERROR;

}
@@ -1464,7 +1493,7 @@ status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken, f 
        return BAD_VALUE;

    }



    return promise::chain(schedule([=] {

    return promise::chain(schedule([=]() MAIN_THREAD {

               if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {

                   return getHwComposer().setDisplayBrightness(*displayId, brightness);

               } else {
@@ -1577,7 +1606,7 @@ void SurfaceFlinger::changeRefreshRateLocked(const RefreshRate& refreshRate, 
}



void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,

                                       hal::Connection connection) NO_THREAD_SAFETY_ANALYSIS {

                                       hal::Connection connection) {

    ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,

          connection == hal::Connection::CONNECTED ? "connected" : "disconnected");
@@ -1630,8 +1659,7 @@ void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) { 


    // Enable / Disable HWVsync from the main thread to avoid race conditions with

    // display power state.

    static_cast<void>(

            schedule([=]() NO_THREAD_SAFETY_ANALYSIS { setPrimaryVsyncEnabledInternal(enabled); }));

    static_cast<void>(schedule([=]() MAIN_THREAD { setPrimaryVsyncEnabledInternal(enabled); }));

}



void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) {
@@ -1647,7 +1675,6 @@ void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) { 
    }

}



// Note: it is assumed the caller holds |mStateLock| when this is called

void SurfaceFlinger::resetDisplayState() {

    mScheduler->disableHardwareVsync(true);

    // Clear the drawing state so that the logic inside of
@@ -1740,7 +1767,7 @@ void SurfaceFlinger::updateVrFlinger() { 
    setTransactionFlags(eDisplayTransactionNeeded);

}



sp<Fence> SurfaceFlinger::previousFrameFence() NO_THREAD_SAFETY_ANALYSIS {

sp<Fence> SurfaceFlinger::previousFrameFence() {

    // We are storing the last 2 present fences. If sf's phase offset is to be

    // woken up before the actual vsync but targeting the next vsync, we need to check

    // fence N-2
@@ -1748,7 +1775,7 @@ sp<Fence> SurfaceFlinger::previousFrameFence() NO_THREAD_SAFETY_ANALYSIS { 
                                                : mPreviousPresentFences[1];

}



bool SurfaceFlinger::previousFramePending(int graceTimeMs) NO_THREAD_SAFETY_ANALYSIS {

bool SurfaceFlinger::previousFramePending(int graceTimeMs) {

    ATRACE_CALL();

    const sp<Fence>& fence = previousFrameFence();
@@ -1762,7 +1789,7 @@ bool SurfaceFlinger::previousFramePending(int graceTimeMs) NO_THREAD_SAFETY_ANAL 
    return status == -ETIME;

}



nsecs_t SurfaceFlinger::previousFramePresentTime() NO_THREAD_SAFETY_ANALYSIS {

nsecs_t SurfaceFlinger::previousFramePresentTime() {

    const sp<Fence>& fence = previousFrameFence();



    if (fence == Fence::NO_FENCE) {
@@ -1780,8 +1807,7 @@ nsecs_t SurfaceFlinger::calculateExpectedPresentTime(nsecs_t now) const { 
    return mVSyncModulator->getOffsets().sf > 0 ? presentTime : presentTime + stats.vsyncPeriod;

}



void SurfaceFlinger::onMessageReceived(int32_t what,

                                       nsecs_t expectedVSyncTime) NO_THREAD_SAFETY_ANALYSIS {

void SurfaceFlinger::onMessageReceived(int32_t what, nsecs_t expectedVSyncTime) {

    ATRACE_CALL();

    switch (what) {

        case MessageQueue::INVALIDATE: {
@@ -1795,7 +1821,7 @@ void SurfaceFlinger::onMessageReceived(int32_t what, 
    }

}



void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) NO_THREAD_SAFETY_ANALYSIS {

void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) {

    ATRACE_CALL();



    const nsecs_t frameStart = systemTime();
@@ -1868,7 +1894,7 @@ void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) NO_THREAD_SA 
        // We received the present fence from the HWC, so we assume it successfully updated

        // the config, hence we update SF.

        mSetActiveConfigPending = false;

        setActiveConfigInternal();

        ON_MAIN_THREAD(setActiveConfigInternal());

    }



    if (framePending && mPropagateBackpressure) {
@@ -1887,12 +1913,12 @@ void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) NO_THREAD_SA 
            std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count();

    // If we're in a user build then don't push any atoms

    if (!mIsUserBuild && mMissedFrameJankCount > 0) {

        const auto displayDevice = getDefaultDisplayDeviceLocked();

        const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());

        // Only report jank when the display is on, as displays in DOZE

        // power mode may operate at a different frame rate than is

        // reported in their config, which causes noticeable (but less

        // severe) jank.

        if (displayDevice && displayDevice->getPowerMode() == hal::PowerMode::ON) {

        if (display && display->getPowerMode() == hal::PowerMode::ON) {

            const nsecs_t currentTime = systemTime();

            const nsecs_t jankDuration = currentTime - mMissedFrameJankStart;

            if (jankDuration > kMinJankyDuration && jankDuration < kMaxJankyDuration) {
@@ -1949,7 +1975,7 @@ void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) NO_THREAD_SA 
        mScheduler->chooseRefreshRateForContent();

    }



    performSetActiveConfig();

    ON_MAIN_THREAD(performSetActiveConfig());



    updateCursorAsync();

    updateInputFlinger();
@@ -1998,8 +2024,9 @@ void SurfaceFlinger::onMessageRefresh() { 
    mRefreshPending = false;



    compositionengine::CompositionRefreshArgs refreshArgs;

    refreshArgs.outputs.reserve(mDisplays.size());

    for (const auto& [_, display] : mDisplays) {

    const auto& displays = ON_MAIN_THREAD(mDisplays);

    refreshArgs.outputs.reserve(displays.size());

    for (const auto& [_, display] : displays) {

        refreshArgs.outputs.push_back(display->getCompositionDisplay());

    }

    mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
@@ -2054,21 +2081,18 @@ void SurfaceFlinger::onMessageRefresh() { 


    const bool prevFrameHadDeviceComposition = mHadDeviceComposition;



    mHadClientComposition =

            std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {

                auto& displayDevice = tokenDisplayPair.second;

                return displayDevice->getCompositionDisplay()->getState().usesClientComposition &&

                        !displayDevice->getCompositionDisplay()->getState().reusedClientComposition;

    mHadClientComposition = std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {

        const auto& state = pair.second->getCompositionDisplay()->getState();

        return state.usesClientComposition && !state.reusedClientComposition;

    });

    mHadDeviceComposition =

            std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {

                auto& displayDevice = tokenDisplayPair.second;

                return displayDevice->getCompositionDisplay()->getState().usesDeviceComposition;

    mHadDeviceComposition = std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {

        const auto& state = pair.second->getCompositionDisplay()->getState();

        return state.usesDeviceComposition;

    });

    mReusedClientComposition =

            std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {

                auto& displayDevice = tokenDisplayPair.second;

                return displayDevice->getCompositionDisplay()->getState().reusedClientComposition;

            std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {

                const auto& state = pair.second->getCompositionDisplay()->getState();

                return state.reusedClientComposition;

            });



    // Only report a strategy change if we move in and out of composition with hw overlays
@@ -2174,14 +2198,14 @@ void SurfaceFlinger::postComposition() 
    for (auto& layer : mLayersWithQueuedFrames) {

        layer->releasePendingBuffer(dequeueReadyTime);

    }

    // |mStateLock| not needed as we are on the main thread

    const auto displayDevice = getDefaultDisplayDeviceLocked();



    const auto* display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked()).get();



    getBE().mGlCompositionDoneTimeline.updateSignalTimes();

    std::shared_ptr<FenceTime> glCompositionDoneFenceTime;

    if (displayDevice && displayDevice->getCompositionDisplay()->getState().usesClientComposition) {

    if (display && display->getCompositionDisplay()->getState().usesClientComposition) {

        glCompositionDoneFenceTime =

                std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()

                std::make_shared<FenceTime>(display->getCompositionDisplay()

                                                    ->getRenderSurface()

                                                    ->getClientTargetAcquireFence());

        getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
@@ -2191,9 +2215,8 @@ void SurfaceFlinger::postComposition() 


    getBE().mDisplayTimeline.updateSignalTimes();

    mPreviousPresentFences[1] = mPreviousPresentFences[0];

    mPreviousPresentFences[0] = displayDevice

            ? getHwComposer().getPresentFence(*displayDevice->getId())

            : Fence::NO_FENCE;

    mPreviousPresentFences[0] =

            display ? getHwComposer().getPresentFence(*display->getId()) : Fence::NO_FENCE;

    auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);

    getBE().mDisplayTimeline.push(presentFenceTime);
@@ -2212,8 +2235,7 @@ void SurfaceFlinger::postComposition() 
    }



    mDrawingState.traverse([&](Layer* layer) {

        const bool frameLatched =

                layer->onPostComposition(displayDevice.get(), glCompositionDoneFenceTime,

        const bool frameLatched = layer->onPostComposition(display, glCompositionDoneFenceTime,

                                                           presentFenceTime, compositorTiming);

        if (frameLatched) {

            recordBufferingStats(layer->getName(), layer->getOccupancyHistory(false));
@@ -2223,14 +2245,15 @@ void SurfaceFlinger::postComposition() 
    mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);

    mTransactionCompletedThread.sendCallbacks();



    if (displayDevice && displayDevice->isPrimary() &&

        displayDevice->getPowerMode() == hal::PowerMode::ON && presentFenceTime->isValid()) {

    if (display && display->isPrimary() && display->getPowerMode() == hal::PowerMode::ON &&

        presentFenceTime->isValid()) {

        mScheduler->addPresentFence(presentFenceTime);

    }



    const bool isDisplayConnected = display && getHwComposer().isConnected(*display->getId());



    if (!hasSyncFramework) {

        if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&

            displayDevice->isPoweredOn()) {

        if (isDisplayConnected && display->isPoweredOn()) {

            mScheduler->enableHardwareVsync();

        }

    }
@@ -2241,11 +2264,10 @@ void SurfaceFlinger::postComposition() 
        if (presentFenceTime->isValid()) {

            mAnimFrameTracker.setActualPresentFence(

                    std::move(presentFenceTime));

        } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {

        } else if (isDisplayConnected) {

            // The HWC doesn't support present fences, so use the refresh

            // timestamp instead.

            const nsecs_t presentTime =

                    getHwComposer().getRefreshTimestamp(*displayDevice->getId());

            const nsecs_t presentTime = getHwComposer().getRefreshTimestamp(*display->getId());

            mAnimFrameTracker.setActualPresentTime(presentTime);

        }

        mAnimFrameTracker.advanceFrame();
@@ -2266,8 +2288,7 @@ void SurfaceFlinger::postComposition() 
    const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);

    mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);



    if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&

        !displayDevice->isPoweredOn()) {

    if (isDisplayConnected && !display->isPoweredOn()) {

        return;

    }
@@ -2323,7 +2344,7 @@ FloatRect SurfaceFlinger::getLayerClipBoundsForDisplay(const DisplayDevice& disp 
}



void SurfaceFlinger::computeLayerBounds() {

    for (const auto& pair : mDisplays) {

    for (const auto& pair : ON_MAIN_THREAD(mDisplays)) {

        const auto& displayDevice = pair.second;

        const auto display = displayDevice->getCompositionDisplay();

        for (const auto& layer : mDrawingState.layersSortedByZ) {
@@ -2338,10 +2359,8 @@ void SurfaceFlinger::computeLayerBounds() { 
    }

}



void SurfaceFlinger::postFrame()

{

    // |mStateLock| not needed as we are on the main thread

    const auto display = getDefaultDisplayDeviceLocked();

void SurfaceFlinger::postFrame() {

    const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());

    if (display && getHwComposer().isConnected(*display->getId())) {

        uint32_t flipCount = display->getPageFlipCount();

        if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
@@ -2772,7 +2791,7 @@ void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags) 
        sp<const DisplayDevice> hintDisplay;

        uint32_t currentlayerStack = 0;

        bool first = true;

        mCurrentState.traverse([&](Layer* layer) {

        mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {

            // NOTE: we rely on the fact that layers are sorted by

            // layerStack first (so we don't have to traverse the list

            // of displays for every layer).
@@ -2885,10 +2904,9 @@ void SurfaceFlinger::commitInputWindowCommands() { 
    mPendingInputWindowCommands.clear();

}



void SurfaceFlinger::updateCursorAsync()

{

void SurfaceFlinger::updateCursorAsync() {

    compositionengine::CompositionRefreshArgs refreshArgs;

    for (const auto& [_, display] : mDisplays) {

    for (const auto& [_, display] : ON_MAIN_THREAD(mDisplays)) {

        if (display->getId()) {

            refreshArgs.outputs.push_back(display->getCompositionDisplay());

        }
@@ -2898,7 +2916,7 @@ void SurfaceFlinger::updateCursorAsync() 
}



void SurfaceFlinger::changeRefreshRate(const RefreshRate& refreshRate,

                                       Scheduler::ConfigEvent event) NO_THREAD_SAFETY_ANALYSIS {

                                       Scheduler::ConfigEvent event) {

    // If this is called from the main thread mStateLock must be locked before

    // Currently the only way to call this function from the main thread is from

    // Sheduler::chooseRefreshRateForContent
@@ -3024,7 +3042,7 @@ void SurfaceFlinger::commitOffscreenLayers() { 
}



void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {

    for (const auto& [token, displayDevice] : mDisplays) {

    for (const auto& [token, displayDevice] : ON_MAIN_THREAD(mDisplays)) {

        auto display = displayDevice->getCompositionDisplay();

        if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {

            display->editState().dirtyRegion.orSelf(dirty);
@@ -4125,7 +4143,7 @@ void SurfaceFlinger::onInitializeDisplays() { 


void SurfaceFlinger::initializeDisplays() {

    // Async since we may be called from the main thread.

    static_cast<void>(schedule([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));

    static_cast<void>(schedule([this]() MAIN_THREAD { onInitializeDisplays(); }));

}



void SurfaceFlinger::setVsyncEnabledInHWC(DisplayId displayId, hal::Vsync enabled) {
@@ -4216,7 +4234,7 @@ void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal: 
}



void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {

    schedule([=]() NO_THREAD_SAFETY_ANALYSIS {

    schedule([=]() MAIN_THREAD {

        const auto display = getDisplayDeviceLocked(displayToken);

        if (!display) {

            ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
@@ -4229,8 +4247,7 @@ void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) { 
    }).wait();

}



status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,

                                bool asProto) NO_THREAD_SAFETY_ANALYSIS {

status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {

    std::string result;



    IPCThreadState* ipc = IPCThreadState::self();
@@ -4242,18 +4259,6 @@ status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, 
        StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",

                      pid, uid);

    } else {

        // Try to get the main lock, but give up after one second

        // (this would indicate SF is stuck, but we want to be able to

        // print something in dumpsys).

        status_t err = mStateLock.timedLock(s2ns(1));

        bool locked = (err == NO_ERROR);

        if (!locked) {

            StringAppendF(&result,

                          "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "

                          "(no locks held)\n",

                          strerror(-err), err);

        }



        static const std::unordered_map<std::string, Dumper> dumpers = {

                {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},

                {"--dispsync"s,
@@ -4271,18 +4276,23 @@ status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, 


        const auto flag = args.empty() ? ""s : std::string(String8(args[0]));



        const auto it = dumpers.find(flag);

        if (it != dumpers.end()) {

        bool dumpLayers = true;

        {

            TimedLock lock(mStateLock, s2ns(1), __FUNCTION__);

            if (!lock.locked()) {

                StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",

                              strerror(-lock.status), lock.status);

            }



            if (const auto it = dumpers.find(flag); it != dumpers.end()) {

                (it->second)(args, asProto, result);

                dumpLayers = false;

            } else if (!asProto) {

                dumpAllLocked(args, result);

            }



        if (locked) {

            mStateLock.unlock();

        }



        if (it == dumpers.end()) {

        if (dumpLayers) {

            const LayersProto layersProto = dumpProtoFromMainThread();

            if (asProto) {

                result.append(layersProto.SerializeAsString());
@@ -4556,7 +4566,7 @@ void SurfaceFlinger::dumpWideColorInfo(std::string& result) const { 


LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {

    // If context is SurfaceTracing thread, mTracingLock blocks display transactions on main thread.

    const auto display = getDefaultDisplayDeviceLocked();

    const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());



    LayersProto layersProto;

    for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
@@ -5392,7 +5402,7 @@ status_t SurfaceFlinger::setSchedFifo(bool enabled) { 
    return NO_ERROR;

}



const sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {

sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {

    const sp<IBinder> displayToken = getPhysicalDisplayTokenLocked(DisplayId{displayOrLayerStack});

    if (displayToken) {

        return getDisplayDeviceLocked(displayToken);
@@ -5402,7 +5412,7 @@ const sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t disp 
    return getDisplayByLayerStack(displayOrLayerStack);

}



const sp<DisplayDevice> SurfaceFlinger::getDisplayByLayerStack(uint64_t layerStack) {

sp<DisplayDevice> SurfaceFlinger::getDisplayByLayerStack(uint64_t layerStack) {

    for (const auto& [token, display] : mDisplays) {

        if (display->getLayerStack() == layerStack) {

            return display;
@@ -5978,7 +5988,7 @@ status_t SurfaceFlinger::setDesiredDisplayConfigSpecs(const sp<IBinder>& display 
    }



    auto future = schedule([=]() -> status_t {

        const auto display = getDisplayDeviceLocked(displayToken);

        const auto display = ON_MAIN_THREAD(getDisplayDeviceLocked(displayToken));

        if (!display) {

            ALOGE("Attempt to set desired display configs for invalid display token %p",

                  displayToken.get());
@@ -6133,7 +6143,7 @@ status_t SurfaceFlinger::setFrameRate(const sp<IGraphicBufferProducer>& surface, 
        return BAD_VALUE;

    }



    static_cast<void>(schedule([=]() NO_THREAD_SAFETY_ANALYSIS {

    static_cast<void>(schedule([=] {

        Mutex::Autolock lock(mStateLock);

        if (authenticateSurfaceTextureLocked(surface)) {

            sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
@@ -6162,8 +6172,7 @@ status_t SurfaceFlinger::acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) 
        sp<IBinder> token;



        if (mFrameRateFlexibilityTokenCount == 0) {

            // |mStateLock| not needed as we are on the main thread

            const auto display = getDefaultDisplayDeviceLocked();

            const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());



            // This is a little racy, but not in a way that hurts anything. As we grab the

            // defaultConfig from the display manager policy, we could be setting a new display
@@ -6213,8 +6222,7 @@ void SurfaceFlinger::onFrameRateFlexibilityTokenReleased() { 
        mFrameRateFlexibilityTokenCount--;

        ALOGD("Frame rate flexibility token released. count=%d", mFrameRateFlexibilityTokenCount);

        if (mFrameRateFlexibilityTokenCount == 0) {

            // |mStateLock| not needed as we are on the main thread

            const auto display = getDefaultDisplayDeviceLocked();

            const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());

            constexpr bool kOverridePolicy = true;

            status_t result = setDesiredDisplayConfigSpecsInternal(display, {}, kOverridePolicy);

            LOG_ALWAYS_FATAL_IF(result < 0, "Failed releasing frame rate flexibility token");

services/surfaceflinger/SurfaceFlinger.h

+28 −32

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+2 −2
Original line number Diff line number Diff line
@@ -289,14 +289,14 @@ public: 
        return mFlinger->destroyDisplay(displayToken);

    }



    auto resetDisplayState() { return mFlinger->resetDisplayState(); }

    auto resetDisplayState() NO_THREAD_SAFETY_ANALYSIS { return mFlinger->resetDisplayState(); }



    auto setupNewDisplayDeviceInternal(

            const wp<IBinder>& displayToken,

            std::shared_ptr<compositionengine::Display> compositionDisplay,

            const DisplayDeviceState& state,

            const sp<compositionengine::DisplaySurface>& dispSurface,

            const sp<IGraphicBufferProducer>& producer) {

            const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {

        return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,

                                                       dispSurface, producer);

    }