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

Commit 83729883 authored by Ady Abraham's avatar Ady Abraham
Browse files

SurfaceFlinger: protect state members in Layer 

Add proper locking to protect state members in Layer.
These members are accessed by both the main thread and binder.

Bug: 119481871
Test: SurfaceFlinger unit tests
Test: go/wm-smoke
Change-Id: I12d47711992e09c0677b77f7e1b36c1254b63a1b
parent 227d1b10

services/surfaceflinger/BufferLayer.cpp

+14 −7
Original line number Diff line number Diff line
@@ -396,6 +396,7 @@ Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime 
    }



    // Capture the old state of the layer for comparisons later

    Mutex::Autolock lock(mStateMutex);

    const State& s(getDrawingState());

    const bool oldOpacity = isOpaque(s);

    sp<GraphicBuffer> oldBuffer = mActiveBuffer;
@@ -503,7 +504,7 @@ Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime 


    // FIXME: postedRegion should be dirty & bounds

    // transform the dirty region to window-manager space

    return getTransform().transform(Region(getBufferSize(s)));

    return getTransformLocked().transform(Region(getBufferSize(s)));

}



// transaction
@@ -551,7 +552,7 @@ bool BufferLayer::latchUnsignaledBuffers() { 


// h/w composer set-up

bool BufferLayer::allTransactionsSignaled() {

    auto headFrameNumber = getHeadFrameNumber();

    auto headFrameNumber = getHeadFrameNumberLocked();

    bool matchingFramesFound = false;

    bool allTransactionsApplied = true;

    Mutex::Autolock lock(mLocalSyncPointMutex);
@@ -604,6 +605,7 @@ bool BufferLayer::needsFiltering(const RenderArea& renderArea) const { 


void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const {

    ATRACE_CALL();

    Mutex::Autolock lock(mStateMutex);

    const State& s(getDrawingState());



    computeGeometry(renderArea, getBE().mMesh, useIdentityTransform);
@@ -622,9 +624,9 @@ void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityT 
     * minimal value)? Or, we could make GL behave like HWC -- but this feel

     * like more of a hack.

     */

    const Rect bounds{computeBounds()}; // Rounds from FloatRect

    const Rect bounds{computeBoundsLocked()}; // Rounds from FloatRect



    ui::Transform t = getTransform();

    ui::Transform t = getTransformLocked();

    Rect win = bounds;

    const int bufferWidth = getBufferSize(s).getWidth();

    const int bufferHeight = getBufferSize(s).getHeight();
@@ -643,7 +645,7 @@ void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityT 
    texCoords[2] = vec2(right, 1.0f - bottom);

    texCoords[3] = vec2(right, 1.0f - top);



    const auto roundedCornerState = getRoundedCornerState();

    const auto roundedCornerState = getRoundedCornerStateLocked();

    const auto cropRect = roundedCornerState.cropRect;

    setupRoundedCornersCropCoordinates(win, cropRect);
@@ -665,7 +667,12 @@ void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityT 
}



uint64_t BufferLayer::getHeadFrameNumber() const {

    if (hasFrameUpdate()) {

    Mutex::Autolock lock(mStateMutex);

    return getHeadFrameNumberLocked();

}



uint64_t BufferLayer::getHeadFrameNumberLocked() const {

    if (hasFrameUpdateLocked()) {

        return getFrameNumber();

    } else {

        return mCurrentFrameNumber;
@@ -692,7 +699,7 @@ Rect BufferLayer::getBufferSize(const State& s) const { 
        std::swap(bufWidth, bufHeight);

    }



    if (getTransformToDisplayInverse()) {

    if (getTransformToDisplayInverseLocked()) {

        uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform();

        if (invTransform & ui::Transform::ROT_90) {

            std::swap(bufWidth, bufHeight);

services/surfaceflinger/BufferLayer.h

+36 −22
Original line number Diff line number Diff line
@@ -69,7 +69,7 @@ public: 
    bool isOpaque(const Layer::State& s) const override;



    // isVisible - true if this layer is visible, false otherwise

    bool isVisible() const override;

    bool isVisible() const override EXCLUDES(mStateMutex);



    // isFixedSize - true if content has a fixed size

    bool isFixedSize() const override;
@@ -87,7 +87,7 @@ public: 
    bool onPostComposition(const std::optional<DisplayId>& displayId,

                           const std::shared_ptr<FenceTime>& glDoneFence,

                           const std::shared_ptr<FenceTime>& presentFence,

                           const CompositorTiming& compositorTiming) override;

                           const CompositorTiming& compositorTiming) override EXCLUDES(mStateMutex);



    // latchBuffer - called each time the screen is redrawn and returns whether

    // the visible regions need to be recomputed (this is a fairly heavy
@@ -97,13 +97,13 @@ public: 
    // releaseFence will be populated with a native fence that fires when

    // composition has completed.

    Region latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,

                       const sp<Fence>& releaseFence) override;

                       const sp<Fence>& releaseFence) override EXCLUDES(mStateMutex);



    bool isBufferLatched() const override { return mRefreshPending; }



    void notifyAvailableFrames() override;



    bool hasReadyFrame() const override;

    bool hasReadyFrame() const override EXCLUDES(mStateMutex);



    // Returns the current scaling mode, unless mOverrideScalingMode

    // is set, in which case, it returns mOverrideScalingMode
@@ -114,19 +114,24 @@ public: 
    // Functions that must be implemented by derived classes

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

private:

    virtual bool fenceHasSignaled() const = 0;

    virtual bool fenceHasSignaled() const EXCLUDES(mStateMutex) = 0;



    virtual nsecs_t getDesiredPresentTime() = 0;

    virtual std::shared_ptr<FenceTime> getCurrentFenceTime() const = 0;

    std::shared_ptr<FenceTime> getCurrentFenceTime() const EXCLUDES(mStateMutex) {

        Mutex::Autolock lock(mStateMutex);

        return getCurrentFenceTimeLocked();

    }



    virtual std::shared_ptr<FenceTime> getCurrentFenceTimeLocked() const REQUIRES(mStateMutex) = 0;



    virtual void getDrawingTransformMatrix(float *matrix) = 0;

    virtual uint32_t getDrawingTransform() const = 0;

    virtual ui::Dataspace getDrawingDataSpace() const = 0;

    virtual Rect getDrawingCrop() const = 0;

    virtual uint32_t getDrawingTransform() const REQUIRES(mStateMutex) = 0;

    virtual ui::Dataspace getDrawingDataSpace() const REQUIRES(mStateMutex) = 0;

    virtual Rect getDrawingCrop() const REQUIRES(mStateMutex) = 0;

    virtual uint32_t getDrawingScalingMode() const = 0;

    virtual Region getDrawingSurfaceDamage() const = 0;

    virtual const HdrMetadata& getDrawingHdrMetadata() const = 0;

    virtual int getDrawingApi() const = 0;

    virtual Region getDrawingSurfaceDamage() const EXCLUDES(mStateMutex) = 0;

    virtual const HdrMetadata& getDrawingHdrMetadata() const EXCLUDES(mStateMutex) = 0;

    virtual int getDrawingApi() const EXCLUDES(mStateMutex) = 0;

    virtual PixelFormat getPixelFormat() const = 0;



    virtual uint64_t getFrameNumber() const = 0;
@@ -134,20 +139,21 @@ private: 
    virtual bool getAutoRefresh() const = 0;

    virtual bool getSidebandStreamChanged() const = 0;



    virtual std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) = 0;

    virtual std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions)

            EXCLUDES(mStateMutex) = 0;



    virtual bool hasFrameUpdate() const = 0;

    virtual bool hasFrameUpdateLocked() const REQUIRES(mStateMutex) = 0;



    virtual void setFilteringEnabled(bool enabled) = 0;



    virtual status_t bindTextureImage() = 0;

    virtual status_t bindTextureImage() EXCLUDES(mStateMutex) = 0;

    virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,

                                    const sp<Fence>& flushFence) = 0;

                                    const sp<Fence>& flushFence) REQUIRES(mStateMutex) = 0;



    virtual status_t updateActiveBuffer() = 0;

    virtual status_t updateActiveBuffer() REQUIRES(mStateMutex) = 0;

    virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;



    virtual void setHwcLayerBuffer(DisplayId displayId) = 0;

    virtual void setHwcLayerBuffer(DisplayId displayId) EXCLUDES(mStateMutex) = 0;



    // -----------------------------------------------------------------------
@@ -163,10 +169,15 @@ protected: 
    // Check all of the local sync points to ensure that all transactions

    // which need to have been applied prior to the frame which is about to

    // be latched have signaled

    bool allTransactionsSignaled();

    bool allTransactionsSignaled() REQUIRES(mStateMutex);



    static bool getOpacityForFormat(uint32_t format);



    bool hasFrameUpdate() const EXCLUDES(mStateMutex) {

        Mutex::Autolock lock(mStateMutex);

        return hasFrameUpdateLocked();

    }



    // from GLES

    const uint32_t mTextureName;
@@ -175,9 +186,12 @@ private: 
    bool needsFiltering(const RenderArea& renderArea) const;



    // drawing

    void drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const;

    void drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const

            EXCLUDES(mStateMutex);



    uint64_t getHeadFrameNumber() const EXCLUDES(mStateMutex);



    uint64_t getHeadFrameNumber() const;

    uint64_t getHeadFrameNumberLocked() const REQUIRES(mStateMutex);



    uint32_t mCurrentScalingMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
@@ -189,7 +203,7 @@ private: 


    bool mRefreshPending{false};



    Rect getBufferSize(const State& s) const override;

    Rect getBufferSize(const State& s) const override REQUIRES(mStateMutex);

};



} // namespace android

services/surfaceflinger/BufferQueueLayer.cpp

+13 −10
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ std::vector<OccupancyTracker::Segment> BufferQueueLayer::getOccupancyHistory(boo 
    return history;

}



bool BufferQueueLayer::getTransformToDisplayInverse() const {

bool BufferQueueLayer::getTransformToDisplayInverseLocked() const {

    return mConsumer->getTransformToDisplayInverse();

}
@@ -131,7 +131,7 @@ nsecs_t BufferQueueLayer::getDesiredPresentTime() { 
    return mConsumer->getTimestamp();

}



std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTime() const {

std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTimeLocked() const {

    return mConsumer->getCurrentFenceTime();

}
@@ -192,6 +192,7 @@ bool BufferQueueLayer::getSidebandStreamChanged() const { 


std::optional<Region> BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) {

    bool sidebandStreamChanged = true;

    Mutex::Autolock lock(mStateMutex);

    if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {

        // mSidebandStreamChanged was changed to false

        // replicated in LayerBE until FE/BE is ready to be synchronized
@@ -200,15 +201,15 @@ std::optional<Region> BufferQueueLayer::latchSidebandStream(bool& recomputeVisib 
            setTransactionFlags(eTransactionNeeded);

            mFlinger->setTransactionFlags(eTraversalNeeded);

        }

        recomputeVisibleRegions = true;



        recomputeVisibleRegions = true;

        const State& s(getDrawingState());

        return getTransform().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h)));

        return getTransformLocked().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h)));

    }

    return {};

}



bool BufferQueueLayer::hasFrameUpdate() const {

bool BufferQueueLayer::hasFrameUpdateLocked() const {

    return mQueuedFrames > 0;

}
@@ -228,16 +229,18 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t 
    // buffer mode.

    bool queuedBuffer = false;

    const int32_t layerID = getSequence();

    LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,

    status_t updateResult;

    LayerRejecter r(mState.drawing, getCurrentState(), recomputeVisibleRegions,

                    getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode,

                    getTransformToDisplayInverse(), mFreezeGeometryUpdates);

                    getTransformToDisplayInverseLocked(), mFreezeGeometryUpdates);



    const nsecs_t expectedPresentTime = mFlinger->mUseScheduler

            ? mFlinger->mScheduler->mPrimaryDispSync->expectedPresentTime()

            : mFlinger->mPrimaryDispSync->expectedPresentTime();

    status_t updateResult =

            mConsumer->updateTexImage(&r, expectedPresentTime, &mAutoRefresh, &queuedBuffer,



    updateResult = mConsumer->updateTexImage(&r, expectedPresentTime, &mAutoRefresh, &queuedBuffer,

                                             mLastFrameNumberReceived, releaseFence);



    if (updateResult == BufferQueue::PRESENT_LATER) {

        // Producer doesn't want buffer to be displayed yet.  Signal a

        // layer update so we check again at the next opportunity.

services/surfaceflinger/BufferQueueLayer.h

+10 −9
Original line number Diff line number Diff line
@@ -44,7 +44,7 @@ public: 


    std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;



    bool getTransformToDisplayInverse() const override;

    bool getTransformToDisplayInverseLocked() const override REQUIRES(mStateMutex);



    // If a buffer was replaced this frame, release the former buffer

    void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
@@ -64,12 +64,12 @@ public: 


private:

    nsecs_t getDesiredPresentTime() override;

    std::shared_ptr<FenceTime> getCurrentFenceTime() const override;

    std::shared_ptr<FenceTime> getCurrentFenceTimeLocked() const override REQUIRES(mStateMutex);



    void getDrawingTransformMatrix(float *matrix) override;

    uint32_t getDrawingTransform() const override;

    ui::Dataspace getDrawingDataSpace() const override;

    Rect getDrawingCrop() const override;

    uint32_t getDrawingTransform() const override REQUIRES(mStateMutex);

    ui::Dataspace getDrawingDataSpace() const override REQUIRES(mStateMutex);

    Rect getDrawingCrop() const override REQUIRES(mStateMutex);

    uint32_t getDrawingScalingMode() const override;

    Region getDrawingSurfaceDamage() const override;

    const HdrMetadata& getDrawingHdrMetadata() const override;
@@ -81,17 +81,18 @@ private: 
    bool getAutoRefresh() const override;

    bool getSidebandStreamChanged() const override;



    std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) override;

    std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) override

            EXCLUDES(mStateMutex);



    bool hasFrameUpdate() const override;

    bool hasFrameUpdateLocked() const override REQUIRES(mStateMutex);



    void setFilteringEnabled(bool enabled) override;



    status_t bindTextureImage() override;

    status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,

                            const sp<Fence>& releaseFence) override;

                            const sp<Fence>& releaseFence) override REQUIRES(mStateMutex);



    status_t updateActiveBuffer() override;

    status_t updateActiveBuffer() override REQUIRES(mStateMutex);

    status_t updateFrameNumber(nsecs_t latchTime) override;



    void setHwcLayerBuffer(DisplayId displayId) override;

services/surfaceflinger/BufferStateLayer.cpp

+94 −68

File changed.

Preview size limit exceeded, changes collapsed.