proxygen: proxygen/folly/folly/experimental/symbolizer/test/StackTraceTest.cpp File Reference

#include <cstring>
#include <folly/experimental/TestUtil.h>
#include <folly/experimental/symbolizer/StackTrace.h>
#include <folly/experimental/symbolizer/Symbolizer.h>
#include <glog/logging.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
FOLLY_NOINLINE void	foo1 ()

FOLLY_NOINLINE void	foo2 ()

void	verifyStackTraces ()

void	handler (int, siginfo_t , void )

	TEST (StackTraceTest, Simple)

	TEST (StackTraceTest, Signal)

ssize_t	read_all (int fd, uint8_t *buffer, size_t size)

off_t	get_stack_trace (int fd, size_t file_pos, uint8_t *buffer, size_t count)

template<class StackTracePrinter >
void	testStackTracePrinter (StackTracePrinter &printer, int fd)

	TEST (StackTraceTest, SafeStackTracePrinter)

	TEST (StackTraceTest, FastStackTracePrinter)

Variables
volatile bool	handled = false

Function Documentation

void foo1 ( )

Definition at line 65 of file StackTraceTest.cpp.

References foo2().

Referenced by handler(), TEST(), and TEST_F().

             {
   foo2();
 }

void foo2 ( )

Definition at line 69 of file StackTraceTest.cpp.

References verifyStackTraces().

Referenced by foo1(), free_function_retire_test(), TEST(), and TEST_F().

             {
   verifyStackTraces();
 }

off_t get_stack_trace	(	int	fd,
		size_t	file_pos,
		uint8_t *	buffer,
		size_t	count
	)

Definition at line 115 of file StackTraceTest.cpp.

References read_all().

Referenced by testStackTracePrinter().

                                                                               {
   off_t rv = lseek(fd, file_pos, SEEK_SET);
   CHECK_EQ(rv, (off_t)file_pos);
 
   // Subtract 1 from size of buffer to hold nullptr.
   ssize_t bytes_read = read_all(fd, buffer, count - 1);
   CHECK_GT(bytes_read, 0);
   buffer[bytes_read] = '\0';
   return lseek(fd, 0, SEEK_CUR);
 }

void handler	(	int	,
		siginfo_t *	,
		void *
	)

Definition at line 74 of file StackTraceTest.cpp.

References foo1(), and handled.

                                            {
   // Yes, getStackTrace and VLOG aren't async-signal-safe, but signals
   // raised with raise() aren't "async" signals.
   foo1();
   handled = true;
 }

ssize_t read_all	(	int	fd,
		uint8_t *	buffer,
		size_t	size
	)

Definition at line 95 of file StackTraceTest.cpp.

References buffer(), fizz::detail::read(), and uint8_t.

Referenced by get_stack_trace().

                                                        {
   uint8_t* pos = buffer;
   ssize_t bytes_read;
   do {
     bytes_read = read(fd, pos, size);
     if (bytes_read < 0) {
       if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
         continue;
       }
       return bytes_read;
     }
 
     pos += bytes_read;
     size -= bytes_read;
   } while (bytes_read > 0 && size > 0);
 
   return pos - buffer;
 }

TEST	(	StackTraceTest	,
		Simple
	)

Definition at line 81 of file StackTraceTest.cpp.

References foo1().

                              {
   foo1();
 }

TEST	(	StackTraceTest	,
		Signal
	)

Definition at line 85 of file StackTraceTest.cpp.

References EXPECT_TRUE, handled, and handler().

                              {
   struct sigaction sa;
   memset(&sa, 0, sizeof(sa));
   sa.sa_sigaction = handler;
   sa.sa_flags = SA_RESETHAND | SA_SIGINFO;
   CHECK_ERR(sigaction(SIGUSR1, &sa, nullptr));
   raise(SIGUSR1);
   EXPECT_TRUE(handled);
 }

TEST	(	StackTraceTest	,
		SafeStackTracePrinter
	)

Definition at line 150 of file StackTraceTest.cpp.

References folly::test::TemporaryFile::fd().

                                             {
   test::TemporaryFile file;
 
   SafeStackTracePrinter printer{10, file.fd()};
 
   testStackTracePrinter<SafeStackTracePrinter>(printer, file.fd());
 }

TEST	(	StackTraceTest	,
		FastStackTracePrinter
	)

Definition at line 158 of file StackTraceTest.cpp.

References folly::test::TemporaryFile::fd().

                                             {
   test::TemporaryFile file;
 
   FastStackTracePrinter printer{
       std::make_unique<FDSymbolizePrinter>(file.fd())};
 
   testStackTracePrinter<FastStackTracePrinter>(printer, file.fd());
 }

template<class StackTracePrinter >

void testStackTracePrinter	(	StackTracePrinter &	printer,
		int	fd
	)

Definition at line 127 of file StackTraceTest.cpp.

References ASSERT_GT, ASSERT_STREQ, folly::gen::first, and get_stack_trace().

                                                                {
   ASSERT_GT(fd, 0);
 
   printer.printStackTrace(true);
   printer.flush();
 
   std::array<uint8_t, 4000> first;
   off_t pos = get_stack_trace(fd, 0, first.data(), first.size());
   ASSERT_GT(pos, 0);
 
   printer.printStackTrace(true);
   printer.flush();
 
   std::array<uint8_t, 4000> second;
   get_stack_trace(fd, pos, second.data(), second.size());
 
   // The first two lines refer to this stack frame, which is different in the
   // two cases, so strip those off.  The rest should be equal.
   ASSERT_STREQ(
       strchr(strchr((const char*)first.data(), '\n') + 1, '\n') + 1,
       strchr(strchr((const char*)second.data(), '\n') + 1, '\n') + 1);
 }

void verifyStackTraces ( )

Definition at line 33 of file StackTraceTest.cpp.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::SymbolizePrinter::COLOR_IF_TTY, EXPECT_EQ, folly::symbolizer::FrameArray< N >::frameCount, folly::symbolizer::getStackTrace(), folly::symbolizer::getStackTraceSafe(), i, folly::INFO, folly::symbolizer::SymbolizePrinter::println(), and folly::symbolizer::Symbolizer::symbolize().

Referenced by foo2().

                          {
   constexpr size_t kMaxAddresses = 100;
   FrameArray<kMaxAddresses> fa;
   CHECK(getStackTrace(fa));
 
   FrameArray<kMaxAddresses> faSafe;
   CHECK(getStackTraceSafe(faSafe));
 
   CHECK_EQ(fa.frameCount, faSafe.frameCount);
 
   if (VLOG_IS_ON(1)) {
     Symbolizer symbolizer;
     OStreamSymbolizePrinter printer(std::cerr, SymbolizePrinter::COLOR_IF_TTY);
 
     symbolizer.symbolize(fa);
     VLOG(1) << "getStackTrace\n";
     printer.println(fa);
 
     symbolizer.symbolize(faSafe);
     VLOG(1) << "getStackTraceSafe\n";
     printer.println(faSafe);
   }
 
   // Other than the top 2 frames (this one and getStackTrace /
   // getStackTraceSafe), the stack traces should be identical
   for (size_t i = 2; i < fa.frameCount; ++i) {
     LOG(INFO) << "i=" << i << " " << std::hex << "0x" << fa.addresses[i]
               << " 0x" << faSafe.addresses[i];
     EXPECT_EQ(fa.addresses[i], faSafe.addresses[i]);
   }
 }

Variable Documentation

volatile bool handled = false

Definition at line 73 of file StackTraceTest.cpp.

Referenced by folly::StandardLogHandlerFactory::createHandler(), folly::exception_wrapper::handle_(), handler(), TEST(), and folly::exception_wrapper::with_exception_().

Functions

Variables

Function Documentation

Variable Documentation