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

Commit b1234bcc authored by Siim Sammul's avatar Siim Sammul Committed by Automerger Merge Worker
Browse files

Merge "Move tombstone_proto_to_text out of libdebuggerd." into main am:... 

Merge "Move tombstone_proto_to_text out of libdebuggerd." into main am: 73ade161 am: 2e2d8d36 am: c41ce240

Original change: https://android-review.googlesource.com/c/platform/system/core/+/2836598



Change-Id: Ic0a6f216c7ae1032af75b4951e5e5d362663d7e2
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents f5ddf698 c41ce240

debuggerd/Android.bp

+37 −2
Original line number Diff line number Diff line
@@ -186,6 +186,41 @@ cc_library { 
    export_include_dirs: ["include"],

}



cc_library {

    name: "libdebuggerd_tombstone_proto_to_text",

    defaults: ["debuggerd_defaults"],

    ramdisk_available: true,

    recovery_available: true,

    vendor_ramdisk_available: true,



    local_include_dirs: ["libdebuggerd/include"],

    export_include_dirs: ["libdebuggerd/include"],



    srcs: [

        "libdebuggerd/tombstone_proto_to_text.cpp",

    ],



    header_libs: [

        "bionic_libc_platform_headers",

    ],



    static_libs: [

        "libbase",

        "liblog_for_runtime_apex",

        "libunwindstack",

    ],



    whole_static_libs: [

        "libtombstone_proto",

        "libprotobuf-cpp-lite",

    ],



    apex_available: [

        "//apex_available:platform",

        "com.android.runtime",

    ],

}



cc_library_static {

    name: "libdebuggerd",

    defaults: ["debuggerd_defaults"],
@@ -199,7 +234,6 @@ cc_library_static { 
        "libdebuggerd/open_files_list.cpp",

        "libdebuggerd/tombstone.cpp",

        "libdebuggerd/tombstone_proto.cpp",

        "libdebuggerd/tombstone_proto_to_text.cpp",

        "libdebuggerd/utility.cpp",

    ],
@@ -225,6 +259,7 @@ cc_library_static { 
    ],



    whole_static_libs: [

        "libdebuggerd_tombstone_proto_to_text",

        "libasync_safe",

        "gwp_asan_crash_handler",

        "libtombstone_proto",
@@ -309,7 +344,7 @@ cc_test { 
        "libdebuggerd/test/elf_fake.cpp",

        "libdebuggerd/test/log_fake.cpp",

        "libdebuggerd/test/open_files_list_test.cpp",

        "libdebuggerd/test/utility_test.cpp",

        "libdebuggerd/test/tombstone_proto_to_text_test.cpp",

    ],



    target: {

debuggerd/libdebuggerd/include/libdebuggerd/utility.h

+0 −2
Original line number Diff line number Diff line
@@ -91,8 +91,6 @@ bool signal_has_si_addr(const siginfo_t*); 
void get_signal_sender(char* buf, size_t n, const siginfo_t*);

const char* get_signame(const siginfo_t*);

const char* get_sigcode(const siginfo_t*);

std::string describe_tagged_addr_ctrl(long ctrl);

std::string describe_pac_enabled_keys(long keys);



// Number of bytes per MTE granule.

constexpr size_t kTagGranuleSize = 16;

debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp

0 → 100644
+120 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <gtest/gtest.h>

#include <sys/prctl.h>



#include <string>



#include <android-base/test_utils.h>



#include "libdebuggerd/tombstone.h"

#include "tombstone.pb.h"



using CallbackType = std::function<void(const std::string& line, bool should_log)>;



class TombstoneProtoToTextTest : public ::testing::Test {

 public:

  void SetUp() {

    tombstone_.reset(new Tombstone);



    tombstone_->set_arch(Architecture::ARM64);

    tombstone_->set_build_fingerprint("Test fingerprint");

    tombstone_->set_timestamp("1970-01-01 00:00:00");

    tombstone_->set_pid(100);

    tombstone_->set_tid(100);

    tombstone_->set_uid(0);

    tombstone_->set_selinux_label("none");



    Signal signal;

    signal.set_number(SIGSEGV);

    signal.set_name("SIGSEGV");

    signal.set_code(0);

    signal.set_code_name("none");



    *tombstone_->mutable_signal_info() = signal;



    Thread thread;

    thread.set_id(100);

    thread.set_name("main");

    thread.set_tagged_addr_ctrl(0);

    thread.set_pac_enabled_keys(0);



    auto& threads = *tombstone_->mutable_threads();

    threads[100] = thread;

    main_thread_ = &threads[100];

  }



  void ProtoToString() {

    text_ = "";

    EXPECT_TRUE(

        tombstone_proto_to_text(*tombstone_, [this](const std::string& line, bool should_log) {

          if (should_log) {

            text_ += "LOG ";

          }

          text_ += line + '\n';

        }));

  }



  Thread* main_thread_;

  std::string text_;

  std::unique_ptr<Tombstone> tombstone_;

};



TEST_F(TombstoneProtoToTextTest, tagged_addr_ctrl) {

  main_thread_->set_tagged_addr_ctrl(0);

  ProtoToString();

  EXPECT_MATCH(text_, "LOG tagged_addr_ctrl: 0000000000000000\\n");



  main_thread_->set_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE);

  ProtoToString();

  EXPECT_MATCH(text_, "LOG tagged_addr_ctrl: 0000000000000001 \\(PR_TAGGED_ADDR_ENABLE\\)\\n");



  main_thread_->set_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |

                                     (0xfffe << PR_MTE_TAG_SHIFT));

  ProtoToString();

  EXPECT_MATCH(text_,

               "LOG tagged_addr_ctrl: 000000000007fff3 \\(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, "

               "mask 0xfffe\\)\\n");



  main_thread_->set_tagged_addr_ctrl(0xf0000000 | PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |

                                     PR_MTE_TCF_ASYNC | (0xfffe << PR_MTE_TAG_SHIFT));

  ProtoToString();

  EXPECT_MATCH(text_,

               "LOG tagged_addr_ctrl: 00000000f007fff7 \\(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, "

               "PR_MTE_TCF_ASYNC, mask 0xfffe, unknown 0xf0000000\\)\\n");

}



TEST_F(TombstoneProtoToTextTest, pac_enabled_keys) {

  main_thread_->set_pac_enabled_keys(0);

  ProtoToString();

  EXPECT_MATCH(text_, "LOG pac_enabled_keys: 0000000000000000\\n");



  main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY);

  ProtoToString();

  EXPECT_MATCH(text_, "LOG pac_enabled_keys: 0000000000000001 \\(PR_PAC_APIAKEY\\)\\n");



  main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY);

  ProtoToString();

  EXPECT_MATCH(text_,

               "LOG pac_enabled_keys: 0000000000000009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY\\)\\n");



  main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY | 0x1000);

  ProtoToString();

  EXPECT_MATCH(text_,

               "LOG pac_enabled_keys: 0000000000001009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown "

               "0x1000\\)\\n");

}

debuggerd/libdebuggerd/test/utility_test.cpp

deleted100644 → 0
+0 −42
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <gtest/gtest.h>

#include <sys/prctl.h>



#include "libdebuggerd/utility.h"



TEST(UtilityTest, describe_tagged_addr_ctrl) {

  EXPECT_EQ("", describe_tagged_addr_ctrl(0));

  EXPECT_EQ(" (PR_TAGGED_ADDR_ENABLE)", describe_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE));

  EXPECT_EQ(" (PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, mask 0xfffe)",

            describe_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |

                                      (0xfffe << PR_MTE_TAG_SHIFT)));

  EXPECT_EQ(

      " (PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, PR_MTE_TCF_ASYNC, mask 0xfffe, unknown "

      "0xf0000000)",

      describe_tagged_addr_ctrl(0xf0000000 | PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |

                                PR_MTE_TCF_ASYNC | (0xfffe << PR_MTE_TAG_SHIFT)));

}



TEST(UtilityTest, describe_pac_enabled_keys) {

  EXPECT_EQ("", describe_pac_enabled_keys(0));

  EXPECT_EQ(" (PR_PAC_APIAKEY)", describe_pac_enabled_keys(PR_PAC_APIAKEY));

  EXPECT_EQ(" (PR_PAC_APIAKEY, PR_PAC_APDBKEY)",

            describe_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY));

  EXPECT_EQ(" (PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown 0x1000)",

            describe_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY | 0x1000));

}

debuggerd/libdebuggerd/tombstone_proto_to_text.cpp

+37 −0
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 
#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <bionic/macros.h>

#include <sys/prctl.h>



#include "tombstone.pb.h"
@@ -40,6 +41,42 @@ using android::base::StringPrintf; 
#define CBS(...) CB(false, __VA_ARGS__)

using CallbackType = std::function<void(const std::string& line, bool should_log)>;



#define DESCRIBE_FLAG(flag) \

  if (value & flag) {       \

    desc += ", ";           \

    desc += #flag;          \

    value &= ~flag;         \

  }



static std::string describe_end(long value, std::string& desc) {

  if (value) {

    desc += StringPrintf(", unknown 0x%lx", value);

  }

  return desc.empty() ? "" : " (" + desc.substr(2) + ")";

}



static std::string describe_tagged_addr_ctrl(long value) {

  std::string desc;

  DESCRIBE_FLAG(PR_TAGGED_ADDR_ENABLE);

  DESCRIBE_FLAG(PR_MTE_TCF_SYNC);

  DESCRIBE_FLAG(PR_MTE_TCF_ASYNC);

  if (value & PR_MTE_TAG_MASK) {

    desc += StringPrintf(", mask 0x%04lx", (value & PR_MTE_TAG_MASK) >> PR_MTE_TAG_SHIFT);

    value &= ~PR_MTE_TAG_MASK;

  }

  return describe_end(value, desc);

}



static std::string describe_pac_enabled_keys(long value) {

  std::string desc;

  DESCRIBE_FLAG(PR_PAC_APIAKEY);

  DESCRIBE_FLAG(PR_PAC_APIBKEY);

  DESCRIBE_FLAG(PR_PAC_APDAKEY);

  DESCRIBE_FLAG(PR_PAC_APDBKEY);

  DESCRIBE_FLAG(PR_PAC_APGAKEY);

  return describe_end(value, desc);

}



static const char* abi_string(const Tombstone& tombstone) {

  switch (tombstone.arch()) {

    case Architecture::ARM32: