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

Commit 579f0c2a authored by Xin Li's avatar Xin Li Committed by Gerrit Code Review
Browse files

Merge "Merge Android 14 QPR3 to AOSP main" into main

parents 1a75b0fd fd63570c

Android.bp

+6 −0
Original line number Diff line number Diff line
@@ -105,7 +105,13 @@ aidl_library { 


cc_library_headers {

    name: "libandroid_headers_private",

    host_supported: true,

    export_include_dirs: ["include/private"],

    target: {

        windows: {

            enabled: true,

        },

    },

}



filegroup {

cmds/dumpstate/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -114,6 +114,7 @@ cc_defaults { 
        "libincidentcompanion",

        "libdumpsys",

        "libserviceutils",

        "android.tracing.flags_c_lib",

    ],

}

cmds/dumpstate/dumpstate.cpp

+114 −66
Original line number Diff line number Diff line
@@ -17,49 +17,9 @@ 
#define LOG_TAG "dumpstate"

#define ATRACE_TAG ATRACE_TAG_ALWAYS



#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <libgen.h>

#include <limits.h>

#include <math.h>

#include <poll.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mount.h>

#include <sys/poll.h>

#include <sys/prctl.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/wait.h>

#include <signal.h>

#include <stdarg.h>

#include <string.h>

#include <sys/capability.h>

#include <sys/inotify.h>

#include <sys/klog.h>

#include <time.h>

#include <unistd.h>



#include <chrono>

#include <cmath>

#include <fstream>

#include <functional>

#include <future>

#include <memory>

#include <numeric>

#include <regex>

#include <set>

#include <string>

#include <utility>

#include <vector>

#include "dumpstate.h"



#include <aidl/android/hardware/dumpstate/IDumpstateDevice.h>

#include <android_app_admin_flags.h>

#include <android-base/file.h>

#include <android-base/properties.h>

#include <android-base/scopeguard.h>
@@ -74,6 +34,8 @@ 
#include <android/hardware/dumpstate/1.1/types.h>

#include <android/hidl/manager/1.0/IServiceManager.h>

#include <android/os/IIncidentCompanion.h>

#include <android_app_admin_flags.h>

#include <android_tracing.h>

#include <binder/IServiceManager.h>

#include <cutils/multiuser.h>

#include <cutils/native_handle.h>
@@ -81,21 +43,60 @@ 
#include <cutils/sockets.h>

#include <cutils/trace.h>

#include <debuggerd/client.h>

#include <dirent.h>

#include <dumpsys.h>

#include <dumputils/dump_utils.h>

#include <errno.h>

#include <fcntl.h>

#include <hardware_legacy/power.h>

#include <hidl/ServiceManagement.h>

#include <inttypes.h>

#include <libgen.h>

#include <limits.h>

#include <log/log.h>

#include <log/log_read.h>

#include <math.h>

#include <openssl/sha.h>

#include <poll.h>

#include <private/android_filesystem_config.h>

#include <private/android_logger.h>

#include <serviceutils/PriorityDumper.h>

#include <signal.h>

#include <stdarg.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/capability.h>

#include <sys/inotify.h>

#include <sys/klog.h>

#include <sys/mount.h>

#include <sys/poll.h>

#include <sys/prctl.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/wait.h>

#include <time.h>

#include <unistd.h>

#include <utils/StrongPointer.h>

#include <vintf/VintfObject.h>



#include <chrono>

#include <cmath>

#include <fstream>

#include <functional>

#include <future>

#include <memory>

#include <numeric>

#include <regex>

#include <set>

#include <string>

#include <utility>

#include <vector>



#include "DumpstateInternal.h"

#include "DumpstateService.h"

#include "dumpstate.h"



namespace dumpstate_hal_hidl_1_0 = android::hardware::dumpstate::V1_0;

namespace dumpstate_hal_hidl = android::hardware::dumpstate::V1_1;
@@ -248,7 +249,7 @@ static const std::string DUMP_NETSTATS_PROTO_TASK = "DUMP NETSTATS PROTO"; 
static const std::string DUMP_HALS_TASK = "DUMP HALS";

static const std::string DUMP_BOARD_TASK = "dumpstate_board()";

static const std::string DUMP_CHECKINS_TASK = "DUMP CHECKINS";

static const std::string POST_PROCESS_UI_TRACES_TASK = "POST-PROCESS UI TRACES";

static const std::string SERIALIZE_PERFETTO_TRACE_TASK = "SERIALIZE PERFETTO TRACE";



namespace android {

namespace os {
@@ -1088,11 +1089,11 @@ static void DumpNetstatsProto() { 


static void MaybeAddSystemTraceToZip() {

    // This function copies into the .zip the system trace that was snapshotted

    // by the early call to MaybeSnapshotSystemTrace(), if any background

    // by the early call to MaybeSnapshotSystemTraceAsync(), if any background

    // tracing was happening.

    bool system_trace_exists = access(SYSTEM_TRACE_SNAPSHOT, F_OK) == 0;

    if (!system_trace_exists) {

        // No background trace was happening at the time MaybeSnapshotSystemTrace() was invoked.

        // No background trace was happening at the time MaybeSnapshotSystemTraceAsync() was invoked

        if (!PropertiesHelper::IsUserBuild()) {

            MYLOGI(

                "No system traces found. Check for previously uploaded traces by looking for "
@@ -1564,6 +1565,13 @@ static void DumpstateLimitedOnly() { 
    RunDumpsys("DROPBOX SYSTEM SERVER CRASHES", {"dropbox", "-p", "system_server_crash"});

    RunDumpsys("DROPBOX SYSTEM APP CRASHES", {"dropbox", "-p", "system_app_crash"});





    printf("========================================================\n");

    printf("== ANR Traces\n");

    printf("========================================================\n");



    AddAnrTraceFiles();



    printf("========================================================\n");

    printf("== Final progress (pid %d): %d/%d (estimated %d)\n", ds.pid_, ds.progress_->Get(),

           ds.progress_->GetMax(), ds.progress_->GetInitialMax());
@@ -1647,7 +1655,7 @@ Dumpstate::RunStatus Dumpstate::dumpstate() { 


    // Enqueue slow functions into the thread pool, if the parallel run is enabled.

    std::future<std::string> dump_hals, dump_incident_report, dump_board, dump_checkins,

            dump_netstats_report, post_process_ui_traces;

        dump_netstats_report;

    if (ds.dump_pool_) {

        // Pool was shutdown in DumpstateDefaultAfterCritical method in order to

        // drop root user. Restarts it.
@@ -3161,8 +3169,9 @@ void Dumpstate::Cancel() { 
}



void Dumpstate::PreDumpUiData() {

    MaybeSnapshotSystemTrace();

    auto snapshot_system_trace = MaybeSnapshotSystemTraceAsync();

    MaybeSnapshotUiTraces();

    MaybeWaitForSnapshotSystemTrace(std::move(snapshot_system_trace));

}



/*
@@ -3348,13 +3357,15 @@ Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid, 
    // duration is logged into MYLOG instead.

    PrintHeader();



    std::future<std::string> snapshot_system_trace;



    bool is_dumpstate_restricted =

        options_->telephony_only || options_->wifi_only || options_->limited_only;

    if (!is_dumpstate_restricted) {

        // Snapshot the system trace now (if running) to avoid that dumpstate's

        // own activity pushes out interesting data from the trace ring buffer.

        // The trace file is added to the zip by MaybeAddSystemTraceToZip().

        MaybeSnapshotSystemTrace();

        snapshot_system_trace = MaybeSnapshotSystemTraceAsync();



        // Invoke critical dumpsys to preserve system state, before doing anything else.

        RunDumpsysCritical();
@@ -3365,6 +3376,7 @@ Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid, 
    }



    MaybeTakeEarlyScreenshot();

    MaybeWaitForSnapshotSystemTrace(std::move(snapshot_system_trace));

    onUiIntensiveBugreportDumpsFinished(calling_uid);

    MaybeCheckUserConsent(calling_uid, calling_package);

    if (options_->telephony_only) {
@@ -3461,20 +3473,35 @@ void Dumpstate::MaybeTakeEarlyScreenshot() { 
    TakeScreenshot();

}



void Dumpstate::MaybeSnapshotSystemTrace() {

std::future<std::string> Dumpstate::MaybeSnapshotSystemTraceAsync() {

    // When capturing traces via bugreport handler (BH), this function will be invoked twice:

    // 1) When BH invokes IDumpstate::PreDumpUiData()

    // 2) When BH invokes IDumpstate::startBugreport(flags = BUGREPORT_USE_PREDUMPED_UI_DATA)

    // In this case we don't want to re-invoke perfetto in step 2.

    // In all other standard invocation states, this function is invoked once

    // without the flag BUGREPORT_USE_PREDUMPED_UI_DATA.

    // This function must run asynchronously to avoid delaying MaybeTakeEarlyScreenshot() in the

    // standard invocation states (b/316110955).

    if (options_->use_predumped_ui_data) {

        return;

        return {};

    }



    // Create temporary file for the command's output

    std::string outPath = ds.bugreport_internal_dir_ + "/tmp_serialize_perfetto_trace";

    auto outFd = android::base::unique_fd(TEMP_FAILURE_RETRY(

        open(outPath.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW,

             S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)));

    if (outFd < 0) {

        MYLOGE("Could not open %s to serialize perfetto trace.\n", outPath.c_str());

        return {};

    }



    // If a stale file exists already, remove it.

    unlink(SYSTEM_TRACE_SNAPSHOT);



    MYLOGI("Launching async '%s'", SERIALIZE_PERFETTO_TRACE_TASK.c_str())

    return std::async(

        std::launch::async, [this, outPath = std::move(outPath), outFd = std::move(outFd)] {

            // If a background system trace is happening and is marked as "suitable for

            // bugreport" (i.e. bugreport_score > 0 in the trace config), this command

            // will stop it and serialize into SYSTEM_TRACE_SNAPSHOT. In the (likely)
@@ -3482,10 +3509,23 @@ void Dumpstate::MaybeSnapshotSystemTrace() { 
            // Note: this should not be enqueued as we need to freeze the trace before

            // dumpstate starts. Otherwise the trace ring buffers will contain mostly

            // the dumpstate's own activity which is irrelevant.

    RunCommand("SERIALIZE PERFETTO TRACE", {"perfetto", "--save-for-bugreport"},

               CommandOptions::WithTimeout(10).DropRoot().CloseAllFileDescriptorsOnExec().Build());

            RunCommand(

                SERIALIZE_PERFETTO_TRACE_TASK, {"perfetto", "--save-for-bugreport"},

                CommandOptions::WithTimeout(10).DropRoot().CloseAllFileDescriptorsOnExec().Build(),

                false, outFd);

            // MaybeAddSystemTraceToZip() will take care of copying the trace in the zip

            // file in the later stages.



            return outPath;

        });

}



void Dumpstate::MaybeWaitForSnapshotSystemTrace(std::future<std::string> task) {

    if (!task.valid()) {

        return;

    }



    WaitForTask(std::move(task), SERIALIZE_PERFETTO_TRACE_TASK, STDOUT_FILENO);

}



void Dumpstate::MaybeSnapshotUiTraces() {
@@ -3493,16 +3533,24 @@ void Dumpstate::MaybeSnapshotUiTraces() { 
        return;

    }



    const std::vector<std::vector<std::string>> dumpTracesForBugReportCommands = {

        {"dumpsys", "activity", "service", "SystemUIService", "WMShell", "protolog",

         "save-for-bugreport"},

        {"dumpsys", "activity", "service", "SystemUIService", "WMShell", "transitions", "tracing",

         "save-for-bugreport"},

    std::vector<std::vector<std::string>> dumpTracesForBugReportCommands = {

        {"cmd", "input_method", "tracing", "save-for-bugreport"},

        {"cmd", "window", "tracing", "save-for-bugreport"},

        {"cmd", "window", "shell", "tracing", "save-for-bugreport"},

    };



    if (!android_tracing_perfetto_transition_tracing()) {

        dumpTracesForBugReportCommands.push_back({"dumpsys", "activity", "service",

                                                  "SystemUIService", "WMShell", "transitions",

                                                  "tracing", "save-for-bugreport"});

    }



    if (!android_tracing_perfetto_protolog_tracing()) {

        dumpTracesForBugReportCommands.push_back({"dumpsys", "activity", "service",

                                                  "SystemUIService", "WMShell", "protolog",

                                                  "save-for-bugreport"});

    }



    for (const auto& command : dumpTracesForBugReportCommands) {

        RunCommand(

            // Empty name because it's not intended to be classified as a bugreport section.

cmds/dumpstate/dumpstate.h

+2 −1
Original line number Diff line number Diff line
@@ -570,7 +570,8 @@ class Dumpstate { 
    RunStatus dumpstate();



    void MaybeTakeEarlyScreenshot();

    void MaybeSnapshotSystemTrace();

    std::future<std::string> MaybeSnapshotSystemTraceAsync();

    void MaybeWaitForSnapshotSystemTrace(std::future<std::string> task);

    void MaybeSnapshotUiTraces();

    void MaybeAddUiTracesToZip();

cmds/dumpstate/tests/dumpstate_test.cpp

+24 −20
Original line number Diff line number Diff line
@@ -16,23 +16,7 @@ 


#define LOG_TAG "dumpstate_test"



#include "DumpstateInternal.h"

#include "DumpstateService.h"

#include "android/os/BnDumpstate.h"

#include "dumpstate.h"

#include "DumpPool.h"



#include <gmock/gmock.h>

#include <gmock/gmock-matchers.h>

#include <gtest/gtest.h>



#include <fcntl.h>

#include <libgen.h>

#include <signal.h>

#include <sys/types.h>

#include <unistd.h>

#include <filesystem>

#include <thread>



#include <aidl/android/hardware/dumpstate/IDumpstateDevice.h>

#include <android-base/file.h>
@@ -41,10 +25,27 @@ 
#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <android/hardware/dumpstate/1.1/types.h>

#include <android_tracing.h>

#include <cutils/log.h>

#include <cutils/properties.h>

#include <fcntl.h>

#include <gmock/gmock-matchers.h>

#include <gmock/gmock.h>

#include <gtest/gtest.h>

#include <libgen.h>

#include <signal.h>

#include <sys/types.h>

#include <unistd.h>

#include <ziparchive/zip_archive.h>



#include <filesystem>

#include <thread>



#include "DumpPool.h"

#include "DumpstateInternal.h"

#include "DumpstateService.h"

#include "android/os/BnDumpstate.h"



namespace android {

namespace os {

namespace dumpstate {
@@ -999,10 +1000,13 @@ TEST_F(DumpstateTest, DumpPool_withParallelRunDisabled_isNull) { 


TEST_F(DumpstateTest, PreDumpUiData) {

    // These traces are always enabled, i.e. they are always pre-dumped

    const std::vector<std::filesystem::path> uiTraces = {

        std::filesystem::path{"/data/misc/wmtrace/wm_transition_trace.winscope"},

        std::filesystem::path{"/data/misc/wmtrace/shell_transition_trace.winscope"},

    };

    std::vector<std::filesystem::path> uiTraces;

    if (!android_tracing_perfetto_transition_tracing()) {

        uiTraces.push_back(

            std::filesystem::path{"/data/misc/wmtrace/wm_transition_trace.winscope"});

        uiTraces.push_back(

            std::filesystem::path{"/data/misc/wmtrace/shell_transition_trace.winscope"});

    }



    for (const auto traceFile : uiTraces) {

        std::system(("rm -f " + traceFile.string()).c_str());