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

Commit 0bebf2c1 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Fix locking issues with proto dumps"

parents 410180fc 8406fd78

services/surfaceflinger/Layer.cpp

+56 −57
Original line number Original line Diff line number Diff line
@@ -153,7 +153,6 @@ void Layer::removeRemoteSyncPoints() { 
    mRemoteSyncPoints.clear();

    mRemoteSyncPoints.clear();





    {

    {

        Mutex::Autolock pendingStateLock(mPendingStateMutex);

        for (State pendingState : mPendingStates) {

        for (State pendingState : mPendingStates) {

            pendingState.barrierLayer_legacy = nullptr;

            pendingState.barrierLayer_legacy = nullptr;

        }

        }
@@ -853,6 +852,7 @@ uint32_t Layer::doTransaction(uint32_t flags) { 




    // Commit the transaction

    // Commit the transaction

    commitTransaction(c);

    commitTransaction(c);

    mPendingStatesSnapshot = mPendingStates;

    mCurrentState.callbackHandles = {};

    mCurrentState.callbackHandles = {};

    return flags;

    return flags;

}

}
@@ -1820,14 +1820,61 @@ void Layer::setInputInfo(const InputWindowInfo& info) { 
    setTransactionFlags(eTransactionNeeded);

    setTransactionFlags(eTransactionNeeded);

}

}





void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet,

void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags) const {

                         uint32_t traceFlags) {

    ui::Transform transform = getTransform();



    if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {

        for (const auto& pendingState : mPendingStatesSnapshot) {

            auto barrierLayer = pendingState.barrierLayer_legacy.promote();

            if (barrierLayer != nullptr) {

                BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();

                barrierLayerProto->set_id(barrierLayer->sequence);

                barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);

            }

        }



        auto buffer = mActiveBuffer;

        if (buffer != nullptr) {

            LayerProtoHelper::writeToProto(buffer,

                                           [&]() { return layerInfo->mutable_active_buffer(); });

            LayerProtoHelper::writeToProto(ui::Transform(mCurrentTransform),

                                           layerInfo->mutable_buffer_transform());

        }

        layerInfo->set_invalidate(contentDirty);

        layerInfo->set_is_protected(isProtected());

        layerInfo->set_dataspace(

                dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));

        layerInfo->set_queued_frames(getQueuedFrameCount());

        layerInfo->set_refresh_pending(isBufferLatched());

        layerInfo->set_curr_frame(mCurrentFrameNumber);

        layerInfo->set_effective_scaling_mode(getEffectiveScalingMode());



        layerInfo->set_corner_radius(getRoundedCornerState().radius);

        LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());

        LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),

                                               [&]() { return layerInfo->mutable_position(); });

        LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });

        LayerProtoHelper::writeToProto(visibleRegion,

                                       [&]() { return layerInfo->mutable_visible_region(); });

        LayerProtoHelper::writeToProto(surfaceDamageRegion,

                                       [&]() { return layerInfo->mutable_damage_region(); });

    }



    if (traceFlags & SurfaceTracing::TRACE_EXTRA) {

        LayerProtoHelper::writeToProto(mSourceBounds,

                                       [&]() { return layerInfo->mutable_source_bounds(); });

        LayerProtoHelper::writeToProto(mScreenBounds,

                                       [&]() { return layerInfo->mutable_screen_bounds(); });

    }

}



void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,

                                    uint32_t traceFlags) const {

    const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;

    const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;

    const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;

    const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;

    const State& state = useDrawing ? mDrawingState : mCurrentState;

    const State& state = useDrawing ? mDrawingState : mCurrentState;





    ui::Transform requestedTransform = state.active_legacy.transform;

    ui::Transform requestedTransform = state.active_legacy.transform;

    ui::Transform transform = getTransform();





    if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {

    if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {

        layerInfo->set_id(sequence);

        layerInfo->set_id(sequence);
@@ -1847,17 +1894,10 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet, 




        LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,

        LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,

                                       [&]() { return layerInfo->mutable_transparent_region(); });

                                       [&]() { return layerInfo->mutable_transparent_region(); });

        LayerProtoHelper::writeToProto(visibleRegion,

                                       [&]() { return layerInfo->mutable_visible_region(); });

        LayerProtoHelper::writeToProto(surfaceDamageRegion,

                                       [&]() { return layerInfo->mutable_damage_region(); });





        layerInfo->set_layer_stack(getLayerStack());

        layerInfo->set_layer_stack(getLayerStack());

        layerInfo->set_z(state.z);

        layerInfo->set_z(state.z);





        LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),

                                               [&]() { return layerInfo->mutable_position(); });



        LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),

        LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),

                                               [&]() {

                                               [&]() {

                                                   return layerInfo->mutable_requested_position();

                                                   return layerInfo->mutable_requested_position();
@@ -1868,15 +1908,9 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet, 




        LayerProtoHelper::writeToProto(state.crop_legacy,

        LayerProtoHelper::writeToProto(state.crop_legacy,

                                       [&]() { return layerInfo->mutable_crop(); });

                                       [&]() { return layerInfo->mutable_crop(); });

        layerInfo->set_corner_radius(getRoundedCornerState().radius);





        layerInfo->set_is_opaque(isOpaque(state));

        layerInfo->set_is_opaque(isOpaque(state));

        layerInfo->set_invalidate(contentDirty);

        layerInfo->set_is_protected(isProtected());





        // XXX (b/79210409) mCurrentDataSpace is not protected

        layerInfo->set_dataspace(

                dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));





        layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));

        layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));

        LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });

        LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
@@ -1884,7 +1918,6 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet, 
                                       [&]() { return layerInfo->mutable_requested_color(); });

                                       [&]() { return layerInfo->mutable_requested_color(); });

        layerInfo->set_flags(state.flags);

        layerInfo->set_flags(state.flags);





        LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());

        LayerProtoHelper::writeToProto(requestedTransform,

        LayerProtoHelper::writeToProto(requestedTransform,

                                       layerInfo->mutable_requested_transform());

                                       layerInfo->mutable_requested_transform());
@@ -1901,29 +1934,6 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet, 
        } else {

        } else {

            layerInfo->set_z_order_relative_of(-1);

            layerInfo->set_z_order_relative_of(-1);

        }

        }



        auto buffer = mActiveBuffer;

        if (buffer != nullptr) {

            LayerProtoHelper::writeToProto(buffer,

                                           [&]() { return layerInfo->mutable_active_buffer(); });

            LayerProtoHelper::writeToProto(ui::Transform(mCurrentTransform),

                                           layerInfo->mutable_buffer_transform());

        }



        layerInfo->set_queued_frames(getQueuedFrameCount());

        layerInfo->set_refresh_pending(isBufferLatched());

        layerInfo->set_curr_frame(mCurrentFrameNumber);

        layerInfo->set_effective_scaling_mode(getEffectiveScalingMode());



        for (const auto& pendingState : mPendingStates) {

            auto barrierLayer = pendingState.barrierLayer_legacy.promote();

            if (barrierLayer != nullptr) {

                BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();

                barrierLayerProto->set_id(barrierLayer->sequence);

                barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);

            }

        }

        LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });

    }

    }





    if (traceFlags & SurfaceTracing::TRACE_INPUT) {

    if (traceFlags & SurfaceTracing::TRACE_INPUT) {
@@ -1936,23 +1946,19 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet, 
        for (const auto& entry : state.metadata.mMap) {

        for (const auto& entry : state.metadata.mMap) {

            (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());

            (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());

        }

        }

        LayerProtoHelper::writeToProto(mEffectiveTransform,

                                       layerInfo->mutable_effective_transform());

        LayerProtoHelper::writeToProto(mSourceBounds,

                                       [&]() { return layerInfo->mutable_source_bounds(); });

        LayerProtoHelper::writeToProto(mScreenBounds,

                                       [&]() { return layerInfo->mutable_screen_bounds(); });

    }

    }

}

}





void Layer::writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice,

void Layer::writeToProtoCompositionState(LayerProto* layerInfo,

                         uint32_t traceFlags) {

                                         const sp<DisplayDevice>& displayDevice,

                                         uint32_t traceFlags) const {

    auto outputLayer = findOutputLayerForDisplay(displayDevice);

    auto outputLayer = findOutputLayerForDisplay(displayDevice);

    if (!outputLayer) {

    if (!outputLayer) {

        return;

        return;

    }

    }





    writeToProto(layerInfo, LayerVector::StateSet::Drawing, traceFlags);

    writeToProtoDrawingState(layerInfo, traceFlags);

    writeToProtoCommonState(layerInfo, LayerVector::StateSet::Drawing, traceFlags);





    const auto& compositionState = outputLayer->getState();

    const auto& compositionState = outputLayer->getState();
@@ -1970,13 +1976,6 @@ void Layer::writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& display 
            static_cast<int32_t>(compositionState.hwc ? (*compositionState.hwc).hwcCompositionType

            static_cast<int32_t>(compositionState.hwc ? (*compositionState.hwc).hwcCompositionType

                                                      : Hwc2::IComposerClient::Composition::CLIENT);

                                                      : Hwc2::IComposerClient::Composition::CLIENT);

    layerInfo->set_hwc_composition_type(compositionType);

    layerInfo->set_hwc_composition_type(compositionType);



    if (std::strcmp(getTypeId(), "BufferLayer") == 0 &&

        static_cast<BufferLayer*>(this)->isProtected()) {

        layerInfo->set_is_protected(true);

    } else {

        layerInfo->set_is_protected(false);

    }

}

}





bool Layer::isRemovedFromCurrentState() const  {

bool Layer::isRemovedFromCurrentState() const  {

services/surfaceflinger/Layer.h

+22 −10
Original line number Original line Diff line number Diff line
@@ -435,11 +435,21 @@ public: 




    bool isRemovedFromCurrentState() const;

    bool isRemovedFromCurrentState() const;





    void writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet,

    // Write states that are modified by the main thread. This includes drawing

                      uint32_t traceFlags = SurfaceTracing::TRACE_ALL);

    // state as well as buffer data. This should be called in the main or tracing



    // thread.

    void writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice,

    void writeToProtoDrawingState(LayerProto* layerInfo,

                      uint32_t traceFlags = SurfaceTracing::TRACE_ALL);

                                  uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;

    // Write states that are modified by the main thread. This includes drawing

    // state as well as buffer data and composition data for layers on the specified

    // display. This should be called in the main or tracing thread.

    void writeToProtoCompositionState(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice,

                                      uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;

    // Write drawing or current state. If writing current state, the caller should hold the

    // external mStateLock. If writing drawing state, this function should be called on the

    // main or tracing thread.

    void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,

                                 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;





    virtual Geometry getActiveGeometry(const Layer::State& s) const { return s.active_legacy; }

    virtual Geometry getActiveGeometry(const Layer::State& s) const { return s.active_legacy; }

    virtual uint32_t getActiveWidth(const Layer::State& s) const { return s.active_legacy.w; }

    virtual uint32_t getActiveWidth(const Layer::State& s) const { return s.active_legacy.w; }
@@ -813,13 +823,15 @@ protected: 




    bool mPrimaryDisplayOnly = false;

    bool mPrimaryDisplayOnly = false;





    // these are protected by an external lock

    // These are only accessed by the main thread or the tracing thread.

    State mCurrentState;

    State mDrawingState;

    State mDrawingState;

    std::atomic<uint32_t> mTransactionFlags{0};

    // Store a copy of the pending state so that the drawing thread can access the

    // states without a lock.

    Vector<State> mPendingStatesSnapshot;





    // Accessed from main thread and binder threads

    // these are protected by an external lock (mStateLock)

    Mutex mPendingStateMutex;

    State mCurrentState;

    std::atomic<uint32_t> mTransactionFlags{0};

    Vector<State> mPendingStates;

    Vector<State> mPendingStates;





    // Timestamp history for UIAutomation. Thread safe.

    // Timestamp history for UIAutomation. Thread safe.

services/surfaceflinger/SurfaceFlinger.cpp

+22 −21
Original line number Original line Diff line number Diff line
@@ -4500,18 +4500,22 @@ status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, 




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

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

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

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

        } else {

        } else if (!asProto) {

            if (asProto) {

                LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);

                result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());

            } else {

            dumpAllLocked(args, result);

            dumpAllLocked(args, result);

        }

        }

        }





        if (locked) {

        if (locked) {

            mStateLock.unlock();

            mStateLock.unlock();

        }

        }



        LayersProto layersProto = dumpProtoFromMainThread();

        if (asProto) {

            result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());

        } else {

            auto layerTree = LayerProtoParser::generateLayerTree(layersProto);

            result.append(LayerProtoParser::layerTreeToString(layerTree));

            result.append("\n");

        }

    }

    }

    write(fd, result.c_str(), result.size());

    write(fd, result.c_str(), result.size());

    return NO_ERROR;

    return NO_ERROR;
@@ -4752,19 +4756,23 @@ void SurfaceFlinger::dumpWideColorInfo(std::string& result) const { 
    result.append("\n");

    result.append("\n");

}

}





LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet,

LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {

                                          uint32_t traceFlags) const {

    LayersProto layersProto;

    LayersProto layersProto;

    const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;

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

    const State& state = useDrawing ? mDrawingState : mCurrentState;

    state.traverseInZOrder([&](Layer* layer) {

        LayerProto* layerProto = layersProto.add_layers();

        LayerProto* layerProto = layersProto.add_layers();

        layer->writeToProto(layerProto, stateSet, traceFlags);

        layer->writeToProtoDrawingState(layerProto, traceFlags);

        layer->writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags);

    });

    });





    return layersProto;

    return layersProto;

}

}





LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {

    LayersProto layersProto;

    postMessageSync(new LambdaMessage([&]() { layersProto = dumpDrawingStateProto(traceFlags); }));

    return layersProto;

}



LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(

LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(

        const sp<DisplayDevice>& displayDevice) const {

        const sp<DisplayDevice>& displayDevice) const {

    LayersProto layersProto;

    LayersProto layersProto;
@@ -4785,7 +4793,7 @@ LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo( 
    mDrawingState.traverseInZOrder([&](Layer* layer) {

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

        if (!layer->visibleRegion.isEmpty() && !display->getOutputLayersOrderedByZ().empty()) {

        if (!layer->visibleRegion.isEmpty() && !display->getOutputLayersOrderedByZ().empty()) {

            LayerProto* layerProto = layersProto.add_layers();

            LayerProto* layerProto = layersProto.add_layers();

            layer->writeToProto(layerProto, displayDevice);

            layer->writeToProtoCompositionState(layerProto, displayDevice);

        }

        }

    });

    });
@@ -4849,13 +4857,6 @@ void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) co 
                  mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);

                  mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);

    colorizer.reset(result);

    colorizer.reset(result);





    {

        LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);

        auto layerTree = LayerProtoParser::generateLayerTree(layersProto);

        result.append(LayerProtoParser::layerTreeToString(layerTree));

        result.append("\n");

    }



    {

    {

        StringAppendF(&result, "Composition layers\n");

        StringAppendF(&result, "Composition layers\n");

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

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

services/surfaceflinger/SurfaceFlinger.h

+5 −3
Original line number Original line Diff line number Diff line
@@ -265,7 +265,8 @@ public: 
    status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);

    status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);





    // post a synchronous message to the main thread

    // post a synchronous message to the main thread

    status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);

    status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0)

            EXCLUDES(mStateLock);





    // force full composition on all displays

    // force full composition on all displays

    void repaintEverything();

    void repaintEverything();
@@ -889,8 +890,9 @@ private: 
    void dumpBufferingStats(std::string& result) const;

    void dumpBufferingStats(std::string& result) const;

    void dumpDisplayIdentificationData(std::string& result) const;

    void dumpDisplayIdentificationData(std::string& result) const;

    void dumpWideColorInfo(std::string& result) const;

    void dumpWideColorInfo(std::string& result) const;

    LayersProto dumpProtoInfo(LayerVector::StateSet stateSet,

    LayersProto dumpDrawingStateProto(uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;

                              uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;

    LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)

            EXCLUDES(mStateLock);

    void withTracingLock(std::function<void()> operation) REQUIRES(mStateLock);

    void withTracingLock(std::function<void()> operation) REQUIRES(mStateLock);

    LayersProto dumpVisibleLayersProtoInfo(const sp<DisplayDevice>& display) const;

    LayersProto dumpVisibleLayersProtoInfo(const sp<DisplayDevice>& display) const;

services/surfaceflinger/SurfaceTracing.cpp

+1 −1
Original line number Original line Diff line number Diff line
@@ -162,7 +162,7 @@ LayersTraceProto SurfaceTracing::traceLayersLocked(const char* where) { 
    LayersTraceProto entry;

    LayersTraceProto entry;

    entry.set_elapsed_realtime_nanos(elapsedRealtimeNano());

    entry.set_elapsed_realtime_nanos(elapsedRealtimeNano());

    entry.set_where(where);

    entry.set_where(where);

    LayersProto layers(mFlinger.dumpProtoInfo(LayerVector::StateSet::Drawing, mTraceFlags));

    LayersProto layers(mFlinger.dumpDrawingStateProto(mTraceFlags));

    entry.mutable_layers()->Swap(&layers);

    entry.mutable_layers()->Swap(&layers);





    return entry;

    return entry;