tests/execinfo_test.cpp - platform/bionic.git - Git at Google

 /*
  * Copyright (C) 2021 The Android Open Source Project
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *  * Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */

 #include <gtest/gtest.h>

 #include <dlfcn.h>
 #include <execinfo.h>
 #include <string.h>

 #include <fstream>
 #include <regex>
 #include <string>
 #include <vector>

 #include <android-base/file.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/test_utils.h>

 TEST(execinfo, backtrace_errors) {
   void* frames[20];
   ASSERT_EQ(0, backtrace(frames, 0));
   ASSERT_EQ(0, backtrace(frames, -1));
 }

 static constexpr int kMaxFrames = 50;

 // Disable optimizations so that these functions show up properly in
 // the backtrace.
 #pragma clang optimize off
 extern "C" __attribute__((__noinline__)) void CallTwo(std::vector<void*>& frames) {
   int num_frames = backtrace(frames.data(), static_cast<int>(frames.size()));
   ASSERT_LT(0, num_frames);
   frames.resize(static_cast<size_t>(num_frames));
 }

 extern "C" __attribute__((__noinline__)) void CallOne(std::vector<void*>& frames) {
   CallTwo(frames);
 }
 #pragma clang optimize on

 static std::string DumpFrames(std::vector<void*>& frames) {
   std::string frame_data;
   for (auto frame : frames) {
     frame_data += android::base::StringPrintf("[%p]", frame);
     Dl_info info;
     if (dladdr(frame, &info) != 0 && info.dli_sname != nullptr) {
       frame_data += ' ';
       frame_data += info.dli_sname;
     }
     frame_data += '\n';
   }
   return frame_data;
 }

 static size_t FindFunction(std::vector<void*>& frames, uintptr_t func_addr) {
   Dl_info func_info;
   if (!dladdr(reinterpret_cast<void*>(func_addr), &func_info)) {
     return 0;
   }
   for (size_t i = 0; i < frames.size(); i++) {
     Dl_info frame_info;
     if (dladdr(frames[i], &frame_info) && func_info.dli_saddr == frame_info.dli_saddr) {
       return i + 1;
     }
   }
   return 0;
 }

 static void VerifyCalls(std::vector<void*>& frames, size_t* one_idx = nullptr,
                         size_t* two_idx = nullptr) {
   // Try and find the CallOne and CallTwo function addresses.
   size_t call_one_idx = FindFunction(frames, reinterpret_cast<uintptr_t>(&CallOne));
   ASSERT_TRUE(call_one_idx != 0) << DumpFrames(frames);
   size_t call_two_idx = FindFunction(frames, reinterpret_cast<uintptr_t>(&CallTwo));
   ASSERT_TRUE(call_two_idx != 0) << DumpFrames(frames);

   ASSERT_LT(call_two_idx, call_one_idx) << "CallTwo function found after CallOne\n"
                                         << DumpFrames(frames);

   if (one_idx != nullptr) *one_idx = call_one_idx;
   if (two_idx != nullptr) *two_idx = call_two_idx;
 }

 TEST(execinfo, backtrace) {
   std::vector<void*> frames(kMaxFrames);
   ASSERT_NO_FATAL_FAILURE(CallOne(frames));

   // Verfiy that there are at least two frames.
   ASSERT_LT(3U, frames.size()) << DumpFrames(frames);

   VerifyCalls(frames);
 }

 TEST(execinfo, backtrace_cutoff_frames) {
   // Verify the max frames is handled properly
   std::vector<void*> frames(1);
   ASSERT_NO_FATAL_FAILURE(CallOne(frames));
   ASSERT_EQ(1U, frames.size()) << DumpFrames(frames);
 }

 TEST(execinfo, backtrace_symbols_errors) {
   void* frames[kMaxFrames];
   // glibc incorrectly returns memory when a zero is passed in.
   // Since we know this works properly on bionic, only verify
   // this there.
 #if defined(__BIONIC__)
   ASSERT_EQ(nullptr, backtrace_symbols(frames, 0));
 #endif
   ASSERT_EQ(nullptr, backtrace_symbols(frames, -1));
 }

 static void VerifyLineFormat(std::string& line) {
   // Verify that the format of the line is one of these:
   //   elf_file(FuncName+0xFuncAddr) [0xAddress]
   //   elf_file(+0xRelAddress) [0xAddress]
   //   elf_file [0xAddress]
   //   [0xAddress]
 #if defined(__GLIBC__)
   // For some reason, glibc will print a space before [0xAddress] for
   // backtrace symbols, and no space for backtrace_symbols_fd. Allow this
   // only for glibc.
   std::regex format1("[^\\(\\s]+\\([^\\+]+\\+0x[0-9a-fA-F]+\\) ?\\[0x[0-9a-fA-F]+\\]");
   std::regex format2("[^\\(\\s]+\\(+\\+0x[0-9a-fA-F]+\\) ?\\[0x[0-9a-fA-F]+\\]");
   std::regex format3("[^\\(\\s]+ ?\\[0x[0-9a-fA-F]+\\]");
 #else
   std::regex format1("[^\\(\\s]+\\([^\\+]+\\+0x[0-9a-fA-F]+\\) \\[0x[0-9a-fA-F]+\\]");
   std::regex format2("[^\\(\\s]+\\(+\\+0x[0-9a-fA-F]+\\) \\[0x[0-9a-fA-F]+\\]");
   std::regex format3("[^\\(\\s]+ \\[0x[0-9a-fA-F]+\\]");
 #endif
   std::regex format4("\\[0x[0-9a-fA-F]+\\]");

   EXPECT_TRUE(std::regex_match(line, format1) || std::regex_match(line, format2) ||
               std::regex_match(line, format3) || std::regex_match(line, format4))
       << "Unknown format of line:\n"
       << line;
 }

 static void VerifyLineFormat(char* raw_line, size_t length) {
   std::string line(raw_line, length);
   VerifyLineFormat(line);
 }

 TEST(execinfo, backtrace_symbols) {
   std::vector<void*> frames(kMaxFrames);
   ASSERT_NO_FATAL_FAILURE(CallOne(frames));
   ASSERT_LT(3U, frames.size()) << DumpFrames(frames);

   char** symbols = backtrace_symbols(frames.data(), static_cast<int>(frames.size()));
   ASSERT_TRUE(symbols != nullptr);
   for (size_t i = 0; i < frames.size(); i++) {
     ASSERT_TRUE(frames[i] != nullptr);
     VerifyLineFormat(symbols[i], strlen(symbols[i]));
   }

   size_t call_one_idx;
   size_t call_two_idx;
   ASSERT_NO_FATAL_FAILURE(VerifyCalls(frames, &call_one_idx, &call_two_idx));
   // Now verify that those frames contain the function names we expect.
   SCOPED_TRACE(DumpFrames(frames));
   ASSERT_MATCH(symbols[call_one_idx - 1], "\\(CallOne+");
   ASSERT_MATCH(symbols[call_two_idx - 1], "\\(CallTwo+");
   free(symbols);
 }

 TEST(execinfo, backtrace_symbols_fd_errors) {
   void* frames[kMaxFrames];
   frames[0] = reinterpret_cast<void*>(&backtrace_symbols);

   {
     TemporaryFile tf;
     backtrace_symbols_fd(frames, 0, tf.fd);
     close(tf.fd);
     std::string content;
     ASSERT_TRUE(android::base::ReadFileToString(tf.path, &content));
     // Verify that no data is written to the file.
     ASSERT_TRUE(content.empty());
   }

   {
     TemporaryFile tf;
     backtrace_symbols_fd(frames, -1, tf.fd);
     close(tf.fd);
     std::string content;
     ASSERT_TRUE(android::base::ReadFileToString(tf.path, &content));
     // Verify that no data is written to the file.
     ASSERT_TRUE(content.empty());
   }

   // Verify that there isn't a crash.
   backtrace_symbols_fd(frames, 0, -1);
 }

 TEST(execinfo, backtrace_symbols_fd) {
   std::vector<void*> frames(kMaxFrames);
   ASSERT_NO_FATAL_FAILURE(CallOne(frames));
   ASSERT_LT(3U, frames.size()) << DumpFrames(frames);

   TemporaryFile tf;
   backtrace_symbols_fd(frames.data(), static_cast<int>(frames.size()), tf.fd);
   close(tf.fd);

   size_t call_one_idx;
   size_t call_two_idx;
   ASSERT_NO_FATAL_FAILURE(VerifyCalls(frames, &call_one_idx, &call_two_idx));

   std::ifstream frame_stream(tf.path);
   ASSERT_TRUE(frame_stream.is_open());
   size_t num_lines = 0;
   std::string line;
   while (std::getline(frame_stream, line)) {
     ASSERT_FALSE(line.empty());
     VerifyLineFormat(line);
     num_lines++;

     if (num_lines == call_one_idx) {
       EXPECT_MATCH(line, "\\(CallOne+");
     } else if (num_lines == call_two_idx) {
       EXPECT_MATCH(line, "\\(CallTwo+");
     }
   }
   ASSERT_EQ(num_lines, frames.size()) << "Number of lines in file does not match number of frames.";
 }
	/*
	* Copyright (C) 2021 The Android Open Source Project
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*/

	#include <gtest/gtest.h>

	#include <dlfcn.h>
	#include <execinfo.h>
	#include <string.h>

	#include <fstream>
	#include <regex>
	#include <string>
	#include <vector>

	#include <android-base/file.h>
	#include <android-base/stringprintf.h>
	#include <android-base/strings.h>
	#include <android-base/test_utils.h>

	TEST(execinfo, backtrace_errors) {
	void* frames[20];
	ASSERT_EQ(0, backtrace(frames, 0));
	ASSERT_EQ(0, backtrace(frames, -1));
	}

	static constexpr int kMaxFrames = 50;

	// Disable optimizations so that these functions show up properly in
	// the backtrace.
	#pragma clang optimize off
	extern "C" __attribute__((__noinline__)) void CallTwo(std::vector<void*>& frames) {
	int num_frames = backtrace(frames.data(), static_cast<int>(frames.size()));
	ASSERT_LT(0, num_frames);
	frames.resize(static_cast<size_t>(num_frames));
	}

	extern "C" __attribute__((__noinline__)) void CallOne(std::vector<void*>& frames) {
	CallTwo(frames);
	}
	#pragma clang optimize on

	static std::string DumpFrames(std::vector<void*>& frames) {
	std::string frame_data;
	for (auto frame : frames) {
	frame_data += android::base::StringPrintf("[%p]", frame);
	Dl_info info;
	if (dladdr(frame, &info) != 0 && info.dli_sname != nullptr) {
	frame_data += ' ';
	frame_data += info.dli_sname;
	}
	frame_data += '\n';
	}
	return frame_data;
	}

	static size_t FindFunction(std::vector<void*>& frames, uintptr_t func_addr) {
	Dl_info func_info;
	if (!dladdr(reinterpret_cast<void*>(func_addr), &func_info)) {
	return 0;
	}
	for (size_t i = 0; i < frames.size(); i++) {
	Dl_info frame_info;
	if (dladdr(frames[i], &frame_info) && func_info.dli_saddr == frame_info.dli_saddr) {
	return i + 1;
	}
	}
	return 0;
	}

	static void VerifyCalls(std::vector<void>& frames, size_t one_idx = nullptr,
	size_t* two_idx = nullptr) {
	// Try and find the CallOne and CallTwo function addresses.
	size_t call_one_idx = FindFunction(frames, reinterpret_cast<uintptr_t>(&CallOne));
	ASSERT_TRUE(call_one_idx != 0) << DumpFrames(frames);
	size_t call_two_idx = FindFunction(frames, reinterpret_cast<uintptr_t>(&CallTwo));
	ASSERT_TRUE(call_two_idx != 0) << DumpFrames(frames);

	ASSERT_LT(call_two_idx, call_one_idx) << "CallTwo function found after CallOne\n"
	<< DumpFrames(frames);

	if (one_idx != nullptr) *one_idx = call_one_idx;
	if (two_idx != nullptr) *two_idx = call_two_idx;
	}

	TEST(execinfo, backtrace) {
	std::vector<void*> frames(kMaxFrames);
	ASSERT_NO_FATAL_FAILURE(CallOne(frames));

	// Verfiy that there are at least two frames.
	ASSERT_LT(3U, frames.size()) << DumpFrames(frames);

	VerifyCalls(frames);
	}

	TEST(execinfo, backtrace_cutoff_frames) {
	// Verify the max frames is handled properly
	std::vector<void*> frames(1);
	ASSERT_NO_FATAL_FAILURE(CallOne(frames));
	ASSERT_EQ(1U, frames.size()) << DumpFrames(frames);
	}

	TEST(execinfo, backtrace_symbols_errors) {
	void* frames[kMaxFrames];
	// glibc incorrectly returns memory when a zero is passed in.
	// Since we know this works properly on bionic, only verify
	// this there.
	#if defined(__BIONIC__)
	ASSERT_EQ(nullptr, backtrace_symbols(frames, 0));
	#endif
	ASSERT_EQ(nullptr, backtrace_symbols(frames, -1));
	}

	static void VerifyLineFormat(std::string& line) {
	// Verify that the format of the line is one of these:
	// elf_file(FuncName+0xFuncAddr) [0xAddress]
	// elf_file(+0xRelAddress) [0xAddress]
	// elf_file [0xAddress]
	// [0xAddress]
	#if defined(__GLIBC__)
	// For some reason, glibc will print a space before [0xAddress] for
	// backtrace symbols, and no space for backtrace_symbols_fd. Allow this
	// only for glibc.
	std::regex format1("[^\\(\\s]+\\([^\\+]+\\+0x[0-9a-fA-F]+\\) ?\\[0x[0-9a-fA-F]+\\]");
	std::regex format2("[^\\(\\s]+\\(+\\+0x[0-9a-fA-F]+\\) ?\\[0x[0-9a-fA-F]+\\]");
	std::regex format3("[^\\(\\s]+ ?\\[0x[0-9a-fA-F]+\\]");
	#else
	std::regex format1("[^\\(\\s]+\\([^\\+]+\\+0x[0-9a-fA-F]+\\) \\[0x[0-9a-fA-F]+\\]");
	std::regex format2("[^\\(\\s]+\\(+\\+0x[0-9a-fA-F]+\\) \\[0x[0-9a-fA-F]+\\]");
	std::regex format3("[^\\(\\s]+ \\[0x[0-9a-fA-F]+\\]");
	#endif
	std::regex format4("\\[0x[0-9a-fA-F]+\\]");

	EXPECT_TRUE(std::regex_match(line, format1) \|\| std::regex_match(line, format2) \|\|
	std::regex_match(line, format3) \|\| std::regex_match(line, format4))
	<< "Unknown format of line:\n"
	<< line;
	}

	static void VerifyLineFormat(char* raw_line, size_t length) {
	std::string line(raw_line, length);
	VerifyLineFormat(line);
	}

	TEST(execinfo, backtrace_symbols) {
	std::vector<void*> frames(kMaxFrames);
	ASSERT_NO_FATAL_FAILURE(CallOne(frames));
	ASSERT_LT(3U, frames.size()) << DumpFrames(frames);

	char** symbols = backtrace_symbols(frames.data(), static_cast<int>(frames.size()));
	ASSERT_TRUE(symbols != nullptr);
	for (size_t i = 0; i < frames.size(); i++) {
	ASSERT_TRUE(frames[i] != nullptr);
	VerifyLineFormat(symbols[i], strlen(symbols[i]));
	}

	size_t call_one_idx;
	size_t call_two_idx;
	ASSERT_NO_FATAL_FAILURE(VerifyCalls(frames, &call_one_idx, &call_two_idx));
	// Now verify that those frames contain the function names we expect.
	SCOPED_TRACE(DumpFrames(frames));
	ASSERT_MATCH(symbols[call_one_idx - 1], "\\(CallOne+");
	ASSERT_MATCH(symbols[call_two_idx - 1], "\\(CallTwo+");
	free(symbols);
	}

	TEST(execinfo, backtrace_symbols_fd_errors) {
	void* frames[kMaxFrames];
	frames[0] = reinterpret_cast<void*>(&backtrace_symbols);

	{
	TemporaryFile tf;
	backtrace_symbols_fd(frames, 0, tf.fd);
	close(tf.fd);
	std::string content;
	ASSERT_TRUE(android::base::ReadFileToString(tf.path, &content));
	// Verify that no data is written to the file.
	ASSERT_TRUE(content.empty());
	}

	{
	TemporaryFile tf;
	backtrace_symbols_fd(frames, -1, tf.fd);
	close(tf.fd);
	std::string content;
	ASSERT_TRUE(android::base::ReadFileToString(tf.path, &content));
	// Verify that no data is written to the file.
	ASSERT_TRUE(content.empty());
	}

	// Verify that there isn't a crash.
	backtrace_symbols_fd(frames, 0, -1);
	}

	TEST(execinfo, backtrace_symbols_fd) {
	std::vector<void*> frames(kMaxFrames);
	ASSERT_NO_FATAL_FAILURE(CallOne(frames));
	ASSERT_LT(3U, frames.size()) << DumpFrames(frames);

	TemporaryFile tf;
	backtrace_symbols_fd(frames.data(), static_cast<int>(frames.size()), tf.fd);
	close(tf.fd);

	size_t call_one_idx;
	size_t call_two_idx;
	ASSERT_NO_FATAL_FAILURE(VerifyCalls(frames, &call_one_idx, &call_two_idx));

	std::ifstream frame_stream(tf.path);
	ASSERT_TRUE(frame_stream.is_open());
	size_t num_lines = 0;
	std::string line;
	while (std::getline(frame_stream, line)) {
	ASSERT_FALSE(line.empty());
	VerifyLineFormat(line);
	num_lines++;

	if (num_lines == call_one_idx) {
	EXPECT_MATCH(line, "\\(CallOne+");
	} else if (num_lines == call_two_idx) {
	EXPECT_MATCH(line, "\\(CallTwo+");
	}
	}
	ASSERT_EQ(num_lines, frames.size()) << "Number of lines in file does not match number of frames.";
	}