YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// 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 "yb/rocksdb/port/stack_trace.h"

#if defined(ROCKSDB_LITE) || !(defined(__linux__) || defined(OS_MACOSX)) || \

    defined(CYGWIN)

// noop

namespace rocksdb {

namespace port {

void InstallStackTraceHandler() {}

void PrintStack(int first_frames_to_skip) {}

}  // namespace port

}  // namespace rocksdb

#else

#include <execinfo.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <cxxabi.h>

namespace rocksdb {

namespace port {

namespace {

#ifdef __linux__

const char* GetExecutableName() {

  static char name[1024];

  char link[1024];

  snprintf(link, sizeof(link), "/proc/%d/exe", getpid());

  auto read = readlink(link, name, sizeof(name) - 1);

  if (-1 == read) {

    return nullptr;

  } else {

    name[read] = 0;

    return name;

  }

}

void PrintStackTraceLine(const char* symbol, void* frame) {

  static const char* executable = GetExecutableName();

  if (symbol) {

    fprintf(stderr, "%s ", symbol);

  }

  if (executable) {

    // out source to addr2line, for the address translation

    const int kLineMax = 256;

    char cmd[kLineMax];

    snprintf(cmd, kLineMax, "addr2line %p -e %s -f -C 2>&1", frame, executable);

    auto f = popen(cmd, "r");

    if (f) {

      char line[kLineMax];

      while (fgets(line, sizeof(line), f)) {

        line[strlen(line) - 1] = 0;  // remove newline

        fprintf(stderr, "%s\t", line);

      }

      pclose(f);

    }

  } else {

    fprintf(stderr, " %p", frame);

  }

  fprintf(stderr, "\n");

}

#elif defined(OS_MACOSX)

void PrintStackTraceLine(const char* symbol, void* frame) {

  static int pid = getpid();

  // out source to atos, for the address translation

  const int kLineMax = 256;

  char cmd[kLineMax];

  snprintf(cmd, kLineMax, "xcrun atos %p -p %d  2>&1", frame, pid);

  auto f = popen(cmd, "r");

  if (f) {

    char line[kLineMax];

    while (fgets(line, sizeof(line), f)) {

      line[strlen(line) - 1] = 0;  // remove newline

      fprintf(stderr, "%s\t", line);

    }

    pclose(f);

  } else if (symbol) {

    fprintf(stderr, "%s ", symbol);

  }

  fprintf(stderr, "\n");

}

#endif

}  // namespace

void PrintStack(int first_frames_to_skip) {

  const int kMaxFrames = 100;

  void* frames[kMaxFrames];

  auto num_frames = backtrace(frames, kMaxFrames);

  auto symbols = backtrace_symbols(frames, num_frames);

  for (int i = first_frames_to_skip; i < num_frames; ++i) {

    fprintf(stderr, "#%-2d  ", i - first_frames_to_skip);

    PrintStackTraceLine((symbols != nullptr) ? symbols[i] : nullptr, frames[i]);

  }

}

static void StackTraceHandler(int sig) {

  // reset to default handler

  signal(sig, SIG_DFL);

  fprintf(stderr, "Received signal %d (%s)\n", sig, strsignal(sig));

  // skip the top three signal handler related frames

  PrintStack(3);

  // re-signal to default handler (so we still get core dump if needed...)

  raise(sig);

}

void InstallStackTraceHandler() {

  // just use the plain old signal as it's simple and sufficient

  // for this use case

  signal(SIGILL, StackTraceHandler);

  signal(SIGSEGV, StackTraceHandler);

  signal(SIGBUS, StackTraceHandler);

  signal(SIGABRT, StackTraceHandler);

}

}  // namespace port

}  // namespace rocksdb

#endif