diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index b30469d..e24c0db 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -320,6 +320,8 @@
 
 const char* KERNEL_IDLE_TIMER_PROP = "graphics.display.kernel_idle_timer.enabled";
 
+static const int MAX_TRACING_MEMORY = 1024 * 1024 * 1024; // 1GB
+
 // ---------------------------------------------------------------------------
 int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
 bool SurfaceFlinger::useHwcForRgbToYuv;
@@ -481,7 +483,6 @@
 
     if (!mIsUserBuild && base::GetBoolProperty("debug.sf.enable_transaction_tracing"s, true)) {
         mTransactionTracing.emplace();
-        mLayerTracing.setTransactionTracing(*mTransactionTracing);
     }
 
     mIgnoreHdrCameraLayers = ignore_hdr_camera_layers(false);
@@ -826,17 +827,6 @@
     initScheduler(display);
     dispatchDisplayHotplugEvent(display->getPhysicalId(), true);
 
-    mLayerTracing.setTakeLayersSnapshotProtoFunction([&](uint32_t traceFlags) {
-        auto snapshot = perfetto::protos::LayersSnapshotProto{};
-        mScheduler
-                ->schedule([&]() FTL_FAKE_GUARD(mStateLock) FTL_FAKE_GUARD(kMainThreadContext) {
-                    snapshot = takeLayersSnapshotProto(traceFlags, TimePoint::now(),
-                                                       mLastCommittedVsyncId, true);
-                })
-                .wait();
-        return snapshot;
-    });
-
     // Commit secondary display(s).
     processDisplayChangesLocked();
 
@@ -2388,6 +2378,11 @@
         mTimeStats->incrementMissedFrames();
     }
 
+    if (mTracingEnabledChanged) {
+        mLayerTracingEnabled = mLayerTracing.isEnabled();
+        mTracingEnabledChanged = false;
+    }
+
     // If a mode set is pending and the fence hasn't fired yet, wait for the next commit.
     if (std::any_of(frameTargets.begin(), frameTargets.end(),
                     [this](const auto& pair) FTL_FAKE_GUARD(mStateLock)
@@ -2514,9 +2509,11 @@
     if (!mustComposite) {
         updateInputFlinger(vsyncId, pacesetterFrameTarget.frameBeginTime());
     }
-    doActiveLayersTracingIfNeeded(false, mVisibleRegionsDirty,
-                                  pacesetterFrameTarget.frameBeginTime(), vsyncId);
 
+    if (mLayerTracingEnabled && !mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
+        // This will block and tracing should only be enabled for debugging.
+        addToLayerTracing(mVisibleRegionsDirty, pacesetterFrameTarget.frameBeginTime(), vsyncId);
+    }
     mLastCommittedVsyncId = vsyncId;
 
     persistDisplayBrightness(mustComposite);
@@ -2738,8 +2735,10 @@
 
     mLayersWithQueuedFrames.clear();
     mLayersIdsWithQueuedFrames.clear();
-    doActiveLayersTracingIfNeeded(true, mVisibleRegionsDirty, pacesetterTarget.frameBeginTime(),
-                                  vsyncId);
+    if (mLayerTracingEnabled && mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
+        // This will block and should only be used for debugging.
+        addToLayerTracing(mVisibleRegionsDirty, pacesetterTarget.frameBeginTime(), vsyncId);
+    }
 
     updateInputFlinger(vsyncId, pacesetterTarget.frameBeginTime());
 
@@ -6367,6 +6366,11 @@
 
     StringAppendF(&result, "  transaction time: %f us\n", inTransactionDuration / 1000.0);
 
+    /*
+     * Tracing state
+     */
+    mLayerTracing.dump(result);
+
     result.append("\nTransaction tracing: ");
     if (mTransactionTracing) {
         result.append("enabled\n");
@@ -6718,13 +6722,42 @@
             case 1024: {
                 return NAME_NOT_FOUND;
             }
-            // Deprecated, use perfetto to start/stop the layer tracing
-            case 1025: {
-                return NAME_NOT_FOUND;
+            case 1025: { // Set layer tracing
+                n = data.readInt32();
+                bool tracingEnabledChanged;
+                if (n == 1) {
+                    int64_t fixedStartingTime = data.readInt64();
+                    ALOGD("LayerTracing enabled");
+                    tracingEnabledChanged = mLayerTracing.enable();
+                    if (tracingEnabledChanged) {
+                        const TimePoint startingTime = fixedStartingTime
+                                ? TimePoint::fromNs(fixedStartingTime)
+                                : TimePoint::now();
+
+                        mScheduler
+                                ->schedule([this, startingTime]() FTL_FAKE_GUARD(
+                                                   mStateLock) FTL_FAKE_GUARD(kMainThreadContext) {
+                                    constexpr bool kVisibleRegionDirty = true;
+                                    addToLayerTracing(kVisibleRegionDirty, startingTime,
+                                                      mLastCommittedVsyncId);
+                                })
+                                .wait();
+                    }
+                } else if (n == 2) {
+                    std::string filename = std::string(data.readCString());
+                    ALOGD("LayerTracing disabled. Trace wrote to %s", filename.c_str());
+                    tracingEnabledChanged = mLayerTracing.disable(filename.c_str());
+                } else {
+                    ALOGD("LayerTracing disabled");
+                    tracingEnabledChanged = mLayerTracing.disable();
+                }
+                mTracingEnabledChanged = tracingEnabledChanged;
+                reply->writeInt32(NO_ERROR);
+                return NO_ERROR;
             }
-            // Deprecated, execute "adb shell perfetto --query" to see the ongoing tracing sessions
-            case 1026: {
-                return NAME_NOT_FOUND;
+            case 1026: { // Get layer tracing status
+                reply->writeBool(mLayerTracing.isEnabled());
+                return NO_ERROR;
             }
             // Is a DisplayColorSetting supported?
             case 1027: {
@@ -6752,9 +6785,19 @@
             case 1028: { // Unused.
                 return NAME_NOT_FOUND;
             }
-            // Deprecated, use perfetto to set the active layer tracing buffer size
+            // Set buffer size for SF tracing (value in KB)
             case 1029: {
-                return NAME_NOT_FOUND;
+                n = data.readInt32();
+                if (n <= 0 || n > MAX_TRACING_MEMORY) {
+                    ALOGW("Invalid buffer size: %d KB", n);
+                    reply->writeInt32(BAD_VALUE);
+                    return BAD_VALUE;
+                }
+
+                ALOGD("Updating trace buffer to %d KB", n);
+                mLayerTracing.setBufferSize(n * 1024);
+                reply->writeInt32(NO_ERROR);
+                return NO_ERROR;
             }
             // Is device color managed?
             case 1030: {
@@ -6794,9 +6837,13 @@
                 }
                 return NO_ERROR;
             }
-            // Deprecated, use perfetto to set layer trace flags
+            // Set trace flags
             case 1033: {
-                return NAME_NOT_FOUND;
+                n = data.readUint32();
+                ALOGD("Updating trace flags to 0x%x", n);
+                mLayerTracing.setTraceFlags(n);
+                reply->writeInt32(NO_ERROR);
+                return NO_ERROR;
             }
             case 1034: {
                 n = data.readInt32();
@@ -6955,6 +7002,9 @@
                 if (mTransactionTracing) {
                     mTransactionTracing->writeToFile();
                 }
+                if (mLayerTracingEnabled) {
+                    mLayerTracing.writeToFile();
+                }
                 reply->writeInt32(NO_ERROR);
                 return NO_ERROR;
             }
@@ -8741,50 +8791,19 @@
     return update;
 }
 
-void SurfaceFlinger::doActiveLayersTracingIfNeeded(bool isCompositionComputed,
-                                                   bool visibleRegionDirty, TimePoint time,
-                                                   VsyncId vsyncId) {
-    if (!mLayerTracing.isActiveTracingStarted()) {
-        return;
-    }
-    if (isCompositionComputed !=
-        mLayerTracing.isActiveTracingFlagSet(LayerTracing::Flag::TRACE_COMPOSITION)) {
-        return;
-    }
-    if (!visibleRegionDirty &&
-        !mLayerTracing.isActiveTracingFlagSet(LayerTracing::Flag::TRACE_BUFFERS)) {
-        return;
-    }
-    auto snapshot = takeLayersSnapshotProto(mLayerTracing.getActiveTracingFlags(), time, vsyncId,
-                                            visibleRegionDirty);
-    mLayerTracing.addProtoSnapshotToOstream(std::move(snapshot), LayerTracing::Mode::MODE_ACTIVE);
-}
-
-perfetto::protos::LayersSnapshotProto SurfaceFlinger::takeLayersSnapshotProto(
-        uint32_t traceFlags, TimePoint time, VsyncId vsyncId, bool visibleRegionDirty) {
-    ATRACE_CALL();
-    perfetto::protos::LayersSnapshotProto snapshot;
-    snapshot.set_elapsed_realtime_nanos(time.ns());
-    snapshot.set_vsync_id(ftl::to_underlying(vsyncId));
-    snapshot.set_where(visibleRegionDirty ? "visibleRegionsDirty" : "bufferLatched");
-    snapshot.set_excludes_composition_state((traceFlags & LayerTracing::Flag::TRACE_COMPOSITION) ==
-                                            0);
-
-    auto layers = dumpDrawingStateProto(traceFlags);
-    if (traceFlags & LayerTracing::Flag::TRACE_EXTRA) {
+void SurfaceFlinger::addToLayerTracing(bool visibleRegionDirty, TimePoint time, VsyncId vsyncId) {
+    const uint32_t tracingFlags = mLayerTracing.getFlags();
+    perfetto::protos::LayersProto layers(dumpDrawingStateProto(tracingFlags));
+    if (tracingFlags & LayerTracing::TRACE_EXTRA) {
         dumpOffscreenLayersProto(layers);
     }
-    *snapshot.mutable_layers() = std::move(layers);
-
-    if (traceFlags & LayerTracing::Flag::TRACE_HWC) {
-        std::string hwcDump;
+    std::string hwcDump;
+    if (tracingFlags & LayerTracing::TRACE_HWC) {
         dumpHwc(hwcDump);
-        snapshot.set_hwc_blob(std::move(hwcDump));
     }
-
-    *snapshot.mutable_displays() = dumpDisplayProto();
-
-    return snapshot;
+    auto displays = dumpDisplayProto();
+    mLayerTracing.notify(visibleRegionDirty, time.ns(), ftl::to_underlying(vsyncId), &layers,
+                         std::move(hwcDump), &displays);
 }
 
 // sfdo functions