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

Commit 9245d3bf authored by Vishnu Nair's avatar Vishnu Nair
Browse files

SF: Add trace section flags and InputWindowInfo to sf trace 

Trace section flags allow users to specify sections of the trace to be collected. By default, all
sections are collected. Options are:
  TRACE_CRITICAL - adds data critical for debugging
  TRACE_INPUT - adds InputWindowInfo
  TRACE_EXTRA - adds non essential data (metadata, derived data)
  TRACE_ALL - includes all sections (default)

To set the trace flags from shell:
$ adb shell su root service call SurfaceFlinger 1033 i32 <trace_flags>

Bug: 123992966
Test: record and view sf trace
Change-Id: Icfd4d2bde08a4b3d04e37eca72ff505c7ea518f7
parent 9ae031a6

services/surfaceflinger/Layer.cpp

+97 −81
Original line number Diff line number Diff line
@@ -1845,7 +1845,8 @@ void Layer::setInputInfo(const InputWindowInfo& info) { 
    setTransactionFlags(eTransactionNeeded);

}



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

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

                         uint32_t traceFlags) {

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

    const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;

    const State& state = useDrawing ? mDrawingState : mCurrentState;
@@ -1853,6 +1854,7 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
    ui::Transform requestedTransform = state.active_legacy.transform;

    ui::Transform transform = getTransform();



    if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {

        layerInfo->set_id(sequence);

        layerInfo->set_name(getName().c_str());

        layerInfo->set_type(String8(getTypeId()));
@@ -1881,21 +1883,24 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
        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();

                                               });



        LayerProtoHelper::writeSizeToProto(state.active_legacy.w, state.active_legacy.h,

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



    LayerProtoHelper::writeToProto(state.crop_legacy, [&]() { return layerInfo->mutable_crop(); });

        LayerProtoHelper::writeToProto(state.crop_legacy,

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

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



        layerInfo->set_is_opaque(isOpaque(state));

        layerInfo->set_invalidate(contentDirty);



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

    layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));

        layerInfo->set_dataspace(

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



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

        LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
@@ -1904,7 +1909,8 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
        layerInfo->set_flags(state.flags);



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

    LayerProtoHelper::writeToProto(requestedTransform, layerInfo->mutable_requested_transform());

        LayerProtoHelper::writeToProto(requestedTransform,

                                       layerInfo->mutable_requested_transform());



        auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote();

        if (parent != nullptr) {
@@ -1941,26 +1947,36 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
                barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);

            }

        }

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

    }



    if (traceFlags & SurfaceTracing::TRACE_INPUT) {

        LayerProtoHelper::writeToProto(state.inputInfo, state.touchableRegionCrop,

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

    }



    if (traceFlags & SurfaceTracing::TRACE_EXTRA) {

        auto protoMap = layerInfo->mutable_metadata();

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

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

        }

    LayerProtoHelper::writeToProto(mEffectiveTransform, layerInfo->mutable_effective_transform());

        LayerProtoHelper::writeToProto(mEffectiveTransform,

                                       layerInfo->mutable_effective_transform());

        LayerProtoHelper::writeToProto(mSourceBounds,

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

        LayerProtoHelper::writeToProto(mScreenBounds,

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

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

    }

}



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

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

                         uint32_t traceFlags) {

    auto outputLayer = findOutputLayerForDisplay(displayDevice);

    if (!outputLayer) {

        return;

    }



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

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



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

services/surfaceflinger/Layer.h

+4 −3
Original line number Diff line number Diff line
@@ -433,10 +433,11 @@ public: 


    bool isRemovedFromCurrentState() const;



    void writeToProto(LayerProto* layerInfo,

                      LayerVector::StateSet stateSet = LayerVector::StateSet::Drawing);

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

                      uint32_t traceFlags = SurfaceTracing::TRACE_ALL);



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

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

                      uint32_t traceFlags = SurfaceTracing::TRACE_ALL);



    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; }

services/surfaceflinger/LayerProtoHelper.cpp

+36 −0
Original line number Diff line number Diff line
@@ -119,5 +119,41 @@ void LayerProtoHelper::writeToProto(const sp<GraphicBuffer>& buffer, 
    }

}



void LayerProtoHelper::writeToProto(

        const InputWindowInfo& inputInfo, const wp<Layer>& touchableRegionBounds,

        std::function<InputWindowInfoProto*()> getInputWindowInfoProto) {

    if (inputInfo.token == nullptr) {

        return;

    }



    InputWindowInfoProto* proto = getInputWindowInfoProto();

    proto->set_layout_params_flags(inputInfo.layoutParamsFlags);

    proto->set_layout_params_type(inputInfo.layoutParamsType);



    LayerProtoHelper::writeToProto({inputInfo.frameLeft, inputInfo.frameTop, inputInfo.frameRight,

                                    inputInfo.frameBottom},

                                   [&]() { return proto->mutable_frame(); });

    LayerProtoHelper::writeToProto(inputInfo.touchableRegion,

                                   [&]() { return proto->mutable_touchable_region(); });



    proto->set_surface_inset(inputInfo.surfaceInset);

    proto->set_visible(inputInfo.visible);

    proto->set_can_receive_keys(inputInfo.canReceiveKeys);

    proto->set_has_focus(inputInfo.hasFocus);

    proto->set_has_wallpaper(inputInfo.hasWallpaper);



    proto->set_global_scale_factor(inputInfo.globalScaleFactor);

    proto->set_window_x_scale(inputInfo.windowXScale);

    proto->set_window_y_scale(inputInfo.windowYScale);

    proto->set_replace_touchable_region_with_crop(inputInfo.replaceTouchableRegionWithCrop);

    auto cropLayer = touchableRegionBounds.promote();

    if (cropLayer != nullptr) {

        proto->set_crop_layer_id(cropLayer->sequence);

        LayerProtoHelper::writeToProto(cropLayer->getScreenBounds(

                                               false /* reduceTransparentRegion */),

                                       [&]() { return proto->mutable_touchable_region_crop(); });

    }

}



} // namespace surfaceflinger

} // namespace android

services/surfaceflinger/LayerProtoHelper.h

+5 −0
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 


#include <layerproto/LayerProtoHeader.h>



#include <Layer.h>

#include <input/InputWindow.h>

#include <math/vec4.h>

#include <ui/GraphicBuffer.h>

#include <ui/Rect.h>
@@ -38,6 +40,9 @@ public: 
    static void writeToProto(const ui::Transform& transform, TransformProto* transformProto);

    static void writeToProto(const sp<GraphicBuffer>& buffer,

                             std::function<ActiveBufferProto*()> getActiveBufferProto);

    static void writeToProto(const InputWindowInfo& inputInfo,

                             const wp<Layer>& touchableRegionBounds,

                             std::function<InputWindowInfoProto*()> getInputWindowInfoProto);

};



} // namespace surfaceflinger

services/surfaceflinger/SurfaceFlinger.cpp

+13 −4
Original line number Diff line number Diff line
@@ -4644,13 +4644,14 @@ void SurfaceFlinger::dumpWideColorInfo(std::string& result) const { 
    result.append("\n");

}



LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet) const {

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

                                          uint32_t traceFlags) const {

    LayersProto layersProto;

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

    const State& state = useDrawing ? mDrawingState : mCurrentState;

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

        LayerProto* layerProto = layersProto.add_layers();

        layer->writeToProto(layerProto, stateSet);

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

    });



    return layersProto;
@@ -4993,9 +4994,9 @@ status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) { 
        code == IBinder::SYSPROPS_TRANSACTION) {

        return OK;

    }

    // Numbers from 1000 to 1032 are currently use for backdoors. The code

    // Numbers from 1000 to 1033 are currently used for backdoors. The code

    // in onTransact verifies that the user is root, and has access to use SF.

    if (code >= 1000 && code <= 1032) {

    if (code >= 1000 && code <= 1033) {

        ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);

        return OK;

    }
@@ -5303,6 +5304,14 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r 
                mDebugEnableProtectedContent = n;

                return NO_ERROR;

            }

            // Set trace flags

            case 1033: {

                n = data.readUint32();

                ALOGD("Updating trace flags to 0x%x", n);

                mTracing.setTraceFlags(n);

                reply->writeInt32(NO_ERROR);

                return NO_ERROR;

            }

        }

    }

    return err;