StaticTracepointTest.cpp File Reference

#include <algorithm>
#include <array>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
#include <boost/filesystem.hpp>
#include <folly/Conv.h>
#include <folly/Format.h>
#include <folly/Random.h>
#include <folly/String.h>
#include <folly/Subprocess.h>
#include <folly/lang/Bits.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
#include <folly/tracing/StaticTracepoint.h>
#include <folly/tracing/test/StaticTracepointTestModule.h>

Go to the source code of this file.

Classes
struct	testStruct

Functions
static uint8_t	hexToInt (const std::string &hex)
static int	get4BytesValue (const std::vector< uint8_t > &v, size_t &pos)
static void	align4Bytes (size_t &pos)
static int	getNextZero (const std::vector< uint8_t > &v, const size_t curPos, const size_t limit)
static intptr_t	getAddr (const std::vector< uint8_t > &v, size_t &pos)
static std::string	getStr (const std::vector< uint8_t > &v, size_t &pos, const size_t len)
static std::string	getExe ()
static std::string	getNoteRawContent (const std::string &fileName)
static std::vector< uint8_t >	readNote (const std::string &fileName)
template<std::size_t SIZE>
static void	checkTracepointArguments (const std::string &arguments, std::array< int, SIZE > &expectedSize)
static bool	getTracepointArguments (const std::string &expectedProvider, const std::string &expectedProbe, const uintptr_t expectedSemaphore, std::string &arguments)
static uint32_t	arrayTestFunc ()
	TEST (StaticTracepoint, TestArray)
static uint32_t	pointerTestFunc ()
	TEST (StaticTracepoint, TestPointer)
static void	emptyTestFunc ()
	TEST (StaticTracepoint, TestEmpty)
static uint32_t	manyArgTypesTestFunc ()
	TEST (StaticTracepoint, TestManyArgTypes)
static FOLLY_ALWAYS_INLINE uint32_t	alwaysInlineTestFunc ()
	TEST (StaticTracepoint, TestAlwaysInline)
static void	branchTestFunc ()
	TEST (StaticTracepoint, TestBranch)
static void	structTestFunc ()
	TEST (StaticTracepoint, TestStruct)
	TEST (StaticTracepoint, TestSemaphoreLocal)
	FOLLY_SDT_DECLARE_SEMAPHORE (folly, test_semaphore_extern)
	TEST (StaticTracepoint, TestSemaphoreExtern)

Variables
static const std::string	kUSDTSubsectionName = FOLLY_SDT_NOTE_NAME
static const int	kUSDTNoteType = FOLLY_SDT_NOTE_TYPE
static const size_t	kAddrWidth = sizeof(void*)

Function Documentation

static void align4Bytes ( size_t &  pos )

static

Definition at line 52 of file StaticTracepointTest.cpp.

Referenced by getTracepointArguments().

                                     {
  if (pos % 4 != 0) {
    pos += 4 - pos % 4;
  }
}

static FOLLY_ALWAYS_INLINE uint32_t alwaysInlineTestFunc ( )

static

Definition at line 335 of file StaticTracepointTest.cpp.

References a, b, FOLLY_SDT, folly::Random::rand32(), and uint32_t.

Referenced by TEST().

                                                           {
  uint32_t a = folly::Random::rand32();
  uint32_t b = folly::Random::rand32();
  FOLLY_SDT(folly, test_static_tracepoint_always_inline, a, b);
  return a + b;
}

static uint32_t arrayTestFunc ( )

static

Definition at line 239 of file StaticTracepointTest.cpp.

References a, FOLLY_SDT, folly::Random::rand32(), uint32_t, and uint64_t.

Referenced by TEST().

                                {
  uint32_t v1 = folly::Random::rand32();
  uint32_t v2 = folly::Random::rand32();
  uint64_t v3 = v1 + v2;
  uint32_t a[4] = {v1, v2, v1, v2};
  FOLLY_SDT(folly, test_static_tracepoint_array, a, v1, v3);
  return v1 + v2;
}

static void branchTestFunc ( )

static

Definition at line 352 of file StaticTracepointTest.cpp.

References a, b, FOLLY_SDT, max, folly::Random::rand32(), and uint32_t.

Referenced by TEST().

                             {
  uint32_t a = folly::Random::rand32();
  uint32_t b = std::max(1u, folly::Random::rand32());
  if (a > b) {
    FOLLY_SDT(folly, test_static_tracepoint_branch_1, a / b);
  } else {
    FOLLY_SDT(folly, test_static_tracepoint_branch_2, double(a) / double(b));
  }
}

template<std::size_t SIZE>

static void checkTracepointArguments ( const std::string &  arguments, std::array< int, SIZE > &  expectedSize  )

static

Definition at line 148 of file StaticTracepointTest.cpp.

References folly::empty(), EXPECT_EQ, EXPECT_FALSE, EXPECT_LT, EXPECT_NE, i, folly::size(), folly::split(), and string.

Referenced by TEST().

                                       {
  std::vector<std::string> args;
  folly::split(' ', arguments, args);
  EXPECT_EQ(expectedSize.size(), args.size());
  for (size_t i = 0; i < args.size(); i++) {
    EXPECT_FALSE(args[i].empty());
    auto pos = args[i].find("@");
    EXPECT_NE(pos, std::string::npos);
    EXPECT_LT(pos, args[i].size() - 1);
    std::string argSize = args[i].substr(0, pos);
    EXPECT_EQ(expectedSize[i], abs(folly::to<int>(argSize)));
  }
}

static void emptyTestFunc ( )

static

Definition at line 277 of file StaticTracepointTest.cpp.

References FOLLY_SDT.

Referenced by TEST().

                            {
  FOLLY_SDT(folly, test_static_tracepoint_empty);
}

FOLLY_SDT_DECLARE_SEMAPHORE	(	folly	,
		test_semaphore_extern
	)

Referenced by TEST().

static int get4BytesValue ( const std::vector< uint8_t > &  v, size_t &  pos  )

static

Definition at line 47 of file StaticTracepointTest.cpp.

References folly::Endian::little().

Referenced by getTracepointArguments().

                                                                    {
  pos += 4;
  return folly::Endian::little(folly::loadUnaligned<int>(v.data() + pos - 4));
}

static intptr_t getAddr ( const std::vector< uint8_t > &  v, size_t &  pos  )

static

Definition at line 69 of file StaticTracepointTest.cpp.

References kAddrWidth, folly::Endian::little(), and string.

Referenced by getTracepointArguments().

                                                                  {
  pos += kAddrWidth;
  return folly::Endian::little(
      folly::loadUnaligned<intptr_t>(v.data() + pos - kAddrWidth));
}

static std::string getExe ( )

static

Definition at line 89 of file StaticTracepointTest.cpp.

References folly::sformat().

Referenced by getTracepointArguments().

                          {
  auto path = folly::sformat("/proc/{}/exe", getpid());
  return boost::filesystem::read_symlink(path).string();
}

static int getNextZero ( const std::vector< uint8_t > &  v, const size_t  curPos, const size_t  limit  )

static

Definition at line 58 of file StaticTracepointTest.cpp.

Referenced by getTracepointArguments().

                        {
  auto pos = std::find(v.begin() + curPos, v.begin() + limit, 0);
  if (pos == v.begin() + limit) {
    return -1;
  }
  return std::distance(v.begin(), pos);
}

static std::string getNoteRawContent ( const std::string &  fileName )

static

Definition at line 94 of file StaticTracepointTest.cpp.

References kUSDTSubsectionName, gmock_output_test::output, folly::Subprocess::Options::pipeStdout(), gmock_test_utils::Subprocess, and folly::Subprocess::Options::usePath().

Referenced by readNote().

                                                              {
  auto subProc = folly::Subprocess(
      std::vector<std::string>{
          "objdump",
          "--full-content",
          "--section=.note." + kUSDTSubsectionName,
          fileName,
      },
      folly::Subprocess::Options().pipeStdout().usePath());
  auto output = subProc.communicate();
  auto retCode = subProc.wait();
  CHECK(retCode.exited());
  CHECK(output.second.empty());
  return output.first;
}

static std::string getStr ( const std::vector< uint8_t > &  v, size_t &  pos, const size_t  len  )

static

Definition at line 76 of file StaticTracepointTest.cpp.

References i, and string.

Referenced by getTracepointArguments().

                                                                   {
  CHECK_GE(len, 1);
  std::string res;
  res.resize(len - 1);
  for (size_t i = 0; i < len - 1; i++) {
    CHECK_NE(v[pos + i], 0);
    res[i] = char(v[pos + i]);
  }
  CHECK_EQ(0, v[pos + len - 1]);
  pos += len;
  return res;
}

static bool getTracepointArguments ( const std::string &  expectedProvider, const std::string &  expectedProbe, const uintptr_t  expectedSemaphore, std::string &  arguments  )

static

This helper reads the .note.stapsdt section of the currently running binary, checks if the tracepoints listed there are properly formatted, and return the arguments layout description string for the expected provider and probe combination if it exists.

Definition at line 170 of file StaticTracepointTest.cpp.

References align4Bytes(), exe, get4BytesValue(), getAddr(), getExe(), getNextZero(), getStr(), folly::recordio_helpers::headerSize(), kAddrWidth, kUSDTNoteType, kUSDTSubsectionName, readNote(), and string.

Referenced by TEST().

                          {
  // Read the note and check if it's non-empty.
  std::string exe = getExe();
  auto note = readNote(exe);
  auto len = note.size();
  CHECK_GT(len, 0);
  // The loop to read tracepoints one by one.
  size_t pos = 0;
  while (pos < len) {
    // Check size information of the tracepoint.
    CHECK_LE(pos + 12, len);

    int headerSize = get4BytesValue(note, pos);
    CHECK_EQ(kUSDTSubsectionName.size() + 1, headerSize);

    int contentSize = get4BytesValue(note, pos);
    size_t remaining = contentSize;
    CHECK_GE(contentSize, kAddrWidth * 3);

    int noteType = get4BytesValue(note, pos);
    CHECK_EQ(kUSDTNoteType, noteType);

    CHECK_LE(pos + headerSize + contentSize, len);

    // Check header of the tracepoint.
    std::string header = getStr(note, pos, headerSize);
    CHECK_EQ(kUSDTSubsectionName, header);
    align4Bytes(pos);

    // Check address information of the tracepoint
    intptr_t probeAddr = getAddr(note, pos);
    CHECK_GT(probeAddr, 0);
    remaining -= kAddrWidth;

    intptr_t baseAddr = getAddr(note, pos);
    CHECK_EQ(0, baseAddr);
    remaining -= kAddrWidth;

    intptr_t semaphoreAddr = getAddr(note, pos);
    remaining -= kAddrWidth;

    // Read tracepoint provider, probe and argument layout description.
    int providerEnd = getNextZero(note, pos, pos + remaining - 1);
    CHECK_GE(providerEnd, 0);
    size_t providerLen = providerEnd - pos + 1;
    std::string provider = getStr(note, pos, providerLen);
    remaining -= providerLen;

    int probeEnd = getNextZero(note, pos, pos + remaining - 1);
    CHECK_GE(probeEnd, 0);
    size_t probeLen = probeEnd - pos + 1;
    std::string probe = getStr(note, pos, probeLen);
    remaining -= probeLen;

    arguments = getStr(note, pos, remaining);
    align4Bytes(pos);

    if (provider == expectedProvider && probe == expectedProbe) {
      CHECK_EQ(expectedSemaphore, semaphoreAddr);
      return true;
    }
  }
  return false;
}

static uint8_t hexToInt ( const std::string &  hex )

static

Definition at line 40 of file StaticTracepointTest.cpp.

References uint8_t, and value.

Referenced by readNote().

                                              {
  std::stringstream converter(hex);
  int value;
  converter >> std::hex >> value;
  return uint8_t(value);
}

static uint32_t manyArgTypesTestFunc ( )

static

Definition at line 292 of file StaticTracepointTest.cpp.

References a, b, FOLLY_SDT, FOLLY_SDT_WITH_SEMAPHORE, folly::Random::rand32(), and uint32_t.

Referenced by TEST().

                                       {
  uint32_t a = folly::Random::rand32();
  uint32_t b = folly::Random::rand32();
  bool bool_ = (a % 2) == (b % 2);
  char char_ = a & 255;
  short short_ = b & 32767;
  long long_ = a;
  float float_ = float(a) / float(b);
  double double_ = double(a) / double(b);
  FOLLY_SDT(
      folly,
      test_static_tracepoint_many_arg_types,
      a,
      b,
      bool_,
      char_,
      short_,
      long_,
      float_,
      double_);
  FOLLY_SDT_WITH_SEMAPHORE(folly, test_semaphore_local, long_, short_);
  return a + b;
}

static uint32_t pointerTestFunc ( )

static

Definition at line 258 of file StaticTracepointTest.cpp.

References a, FOLLY_SDT, folly::Random::rand32(), string, and uint32_t.

Referenced by TEST().

                                  {
  uint32_t v1 = folly::Random::rand32();
  uint32_t v2 = folly::Random::rand32();
  std::string str = "test string";
  const char* a = str.c_str();
  FOLLY_SDT(folly, test_static_tracepoint_pointer, a, v2, &v1);
  return v1 + v2;
}

static std::vector<uint8_t> readNote ( const std::string &  fileName )

static

Definition at line 110 of file StaticTracepointTest.cpp.

References getNoteRawContent(), hexToInt(), i, kUSDTSubsectionName, folly::gen::lines(), folly::size(), folly::split(), and string.

Referenced by getTracepointArguments().

                                                              {
  std::vector<uint8_t> res;
  std::string rawContent = getNoteRawContent(fileName);
  CHECK(!rawContent.empty());
  // Strip out the part of output containing raw content, and split by line.
  std::string contentStart =
      "Contents of section .note." + kUSDTSubsectionName + ":";
  auto pos = rawContent.find(contentStart);
  CHECK_NE(pos, std::string::npos);
  pos = rawContent.find("\n", pos + 1);
  CHECK_NE(pos, std::string::npos);
  rawContent = rawContent.substr(pos + 1);
  std::vector<std::string> lines;
  folly::split('\n', rawContent, lines, true);
  CHECK_GT(lines.size(), 0);
  // Parse each line.
  for (auto line : lines) {
    // Empty segments or ASCIIified content after two spaces.
    auto endPos = line.find("  ");
    CHECK_NE(endPos, std::string::npos);
    line = line.substr(0, endPos);
    std::vector<std::string> segments;
    folly::split(' ', line, segments, true);
    CHECK_GE(segments.size(), 2);
    // First segment is address offset.
    for (size_t i = 1; i < segments.size(); i++) {
      CHECK_EQ(8, segments[i].size());
      for (size_t j = 0; j < 8; j += 2) {
        std::string hex = segments[i].substr(j, 2);
        res.push_back(hexToInt(hex));
      }
    }
  }
  CHECK_EQ(0, res.size() % 4);
  return res;
}

static void structTestFunc ( )

static

Definition at line 384 of file StaticTracepointTest.cpp.

References testStruct::a, testStruct::b, FOLLY_SDT, folly::Random::rand32(), s, and folly::pushmi::detail::t.

Referenced by TEST().

                             {
  testStruct s, t;
  s.a = folly::Random::rand32();
  s.b = folly::Random::rand32();
  t.a = folly::Random::rand32();
  t.b = folly::Random::rand32();
  FOLLY_SDT(folly, test_static_tracepoint_struct, s, t);
}

TEST	(	StaticTracepoint	,
		TestArray
	)

Definition at line 248 of file StaticTracepointTest.cpp.

References arrayTestFunc(), ASSERT_TRUE, checkTracepointArguments(), getTracepointArguments(), int64_t, and string.

                                  {
  arrayTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_array", 0, arguments));
  std::array<int, 3> expected{{sizeof(void*), sizeof(int), sizeof(int64_t)}};
  checkTracepointArguments(arguments, expected);
}

TEST	(	StaticTracepoint	,
		TestPointer
	)

Definition at line 267 of file StaticTracepointTest.cpp.

References ASSERT_TRUE, checkTracepointArguments(), getTracepointArguments(), pointerTestFunc(), and string.

                                    {
  pointerTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_array", 0, arguments));
  std::array<int, 3> expected{{sizeof(void*), sizeof(int), sizeof(void*)}};
  checkTracepointArguments(arguments, expected);
}

TEST	(	StaticTracepoint	,
		TestEmpty
	)

Definition at line 281 of file StaticTracepointTest.cpp.

References ASSERT_TRUE, emptyTestFunc(), EXPECT_TRUE, FOLLY_SDT_DEFINE_SEMAPHORE, getTracepointArguments(), and string.

                                  {
  emptyTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_empty", 0, arguments));
  EXPECT_TRUE(arguments.empty());
}

TEST	(	StaticTracepoint	,
		TestManyArgTypes
	)

Definition at line 316 of file StaticTracepointTest.cpp.

References ASSERT_TRUE, checkTracepointArguments(), getTracepointArguments(), manyArgTypesTestFunc(), string, and uint32_t.

                                         {
  manyArgTypesTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_many_arg_types", 0, arguments));
  std::array<int, 8> expected{{
      sizeof(uint32_t),
      sizeof(uint32_t),
      sizeof(bool),
      sizeof(char),
      sizeof(short),
      sizeof(long),
      sizeof(float),
      sizeof(double),
  }};
  checkTracepointArguments(arguments, expected);
}

TEST	(	StaticTracepoint	,
		TestAlwaysInline
	)

Definition at line 342 of file StaticTracepointTest.cpp.

References alwaysInlineTestFunc(), ASSERT_TRUE, checkTracepointArguments(), getTracepointArguments(), string, and uint32_t.

                                         {
  alwaysInlineTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_always_inline", 0, arguments));
  std::array<int, 2> expected{{sizeof(uint32_t), sizeof(uint32_t)}};
  checkTracepointArguments(arguments, expected);
}

TEST	(	StaticTracepoint	,
		TestBranch
	)

Definition at line 362 of file StaticTracepointTest.cpp.

References ASSERT_TRUE, branchTestFunc(), checkTracepointArguments(), getTracepointArguments(), string, and uint32_t.

                                   {
  branchTestFunc();

  std::string arguments1;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_branch_1", 0, arguments1));
  std::array<int, 1> expected1{{sizeof(uint32_t)}};
  checkTracepointArguments(arguments1, expected1);

  std::string arguments2;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_branch_2", 0, arguments2));
  std::array<int, 1> expected2{{sizeof(double)}};
  checkTracepointArguments(arguments2, expected2);
}

TEST	(	StaticTracepoint	,
		TestStruct
	)

Definition at line 393 of file StaticTracepointTest.cpp.

References ASSERT_TRUE, checkTracepointArguments(), getTracepointArguments(), string, and structTestFunc().

                                   {
  structTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly", "test_static_tracepoint_struct", 0, arguments));
  std::array<int, 2> expected{{sizeof(testStruct), sizeof(testStruct)}};
  checkTracepointArguments(arguments, expected);
}

TEST	(	StaticTracepoint	,
		TestSemaphoreLocal
	)

Definition at line 403 of file StaticTracepointTest.cpp.

References ASSERT_TRUE, checkTracepointArguments(), EXPECT_FALSE, FOLLY_SDT_DECLARE_SEMAPHORE(), FOLLY_SDT_IS_ENABLED, FOLLY_SDT_SEMAPHORE, getTracepointArguments(), manyArgTypesTestFunc(), and string.

                                           {
  manyArgTypesTestFunc();

  std::string arguments;
  ASSERT_TRUE(getTracepointArguments(
      "folly",
      "test_semaphore_local",
      (uintptr_t)((void*)&FOLLY_SDT_SEMAPHORE(folly, test_semaphore_local)),
      arguments));
  std::array<int, 2> expected{{sizeof(long), sizeof(short)}};
  checkTracepointArguments(arguments, expected);
  EXPECT_FALSE(FOLLY_SDT_IS_ENABLED(folly, test_semaphore_local));
}

TEST	(	StaticTracepoint	,
		TestSemaphoreExtern
	)

Definition at line 419 of file StaticTracepointTest.cpp.

References EXPECT_FALSE, FOLLY_SDT_IS_ENABLED, folly::Random::rand32(), and folly::test::staticTracepointTestFunc().

                                            {
  unsigned v = folly::Random::rand32();
  CHECK_EQ(v * v, folly::test::staticTracepointTestFunc(v));
  EXPECT_FALSE(FOLLY_SDT_IS_ENABLED(folly, test_semaphore_extern));
}

Variable Documentation

const size_t kAddrWidth = sizeof(void*)

static

Definition at line 38 of file StaticTracepointTest.cpp.

Referenced by getAddr(), and getTracepointArguments().

const int kUSDTNoteType = FOLLY_SDT_NOTE_TYPE

static

Definition at line 37 of file StaticTracepointTest.cpp.

Referenced by getTracepointArguments().

const std::string kUSDTSubsectionName = FOLLY_SDT_NOTE_NAME

static

Definition at line 36 of file StaticTracepointTest.cpp.

Referenced by getNoteRawContent(), getTracepointArguments(), and readNote().