stacktrace.cpp

/**
 * \file stacktrace.cpp
 * \brief Stack trace functions source file
 * \author Jiri Havranek <havraji6@fit.cvut.cz>
 * \date 2021
 */
/*
 * Copyright (C) 2021 CESNET
 *
 * LICENSE TERMS
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of the Company nor the names of its contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * ALTERNATIVELY, provided that this notice is retained in full, this
 * product may be distributed under the terms of the GNU General Public
 * License (GPL) version 2 or later, in which case the provisions
 * of the GPL apply INSTEAD OF those given above.
 *
 * This software is provided ``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 company 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 <config.h>

#ifdef HAVE_LIBUNWIND
#include <unistd.h>
#include <string.h>
#include <sys/syscall.h>
#include <sys/types.h>

#define UNW_LOCAL_ONLY
#include <libunwind.h>

#include "stacktrace.h"

static void st_write(int fd, const char *buffer, size_t buflen)
{
   size_t total = 0;
   while (total < buflen) {
      ssize_t written = write(fd, buffer + total, buflen - total);
      if (written < 0) {
         return;
      }

      total += written;
   }
}

static void st_write_str(int fd, const char *str)
{
   st_write(fd, str, strlen(str));
}

static void st_write_num(int fd, int num, int padding=0)
{
   char buf[22];
   int idx = 0;
   int tmp = num < 0 ? -num : num;

   if (num == 0) {
      buf[idx++] = '0';
   }

   while (tmp != 0) {
      buf[idx++] = '0' + tmp % 10;
      tmp /= 10;
   }
   if (num < 0) {
      buf[idx++] = '-';
   }

   for (int i = 0; i < idx / 2; i++) {
      char tmp = buf[i];
      buf[i] = buf[idx - i - 1];
      buf[idx - i - 1] = tmp;
   }
   while (idx < padding) {
         buf[idx++] = ' ';
   }
   buf[idx] = 0;

   st_write_str(fd, buf);
}

static char nibble2hex(uint8_t num)
{
   if (num < 10) {
      return '0' + num;
   } else if (num < 16) {
      return 'a' + num - 10;
   }
   return '?';
}

static void st_write_num_hex(int fd, uint64_t num, size_t size, bool nopad=false)
{
   char buf[19] = "0x";
   bool nonzero_seen = false;
   size_t idx = 2;

   for (int i = 0; i < (int) size; i++) {
      uint8_t bits2shift = (size - i - 1) * size;
      uint8_t byte = (num >> bits2shift) & 0xFF;
      if (byte == 0 && nopad && !nonzero_seen) {
         continue;
      }
      buf[idx]     = nibble2hex(byte >> 4);
      buf[idx + 1] = nibble2hex(byte & 0x0F);
      idx += 2;
      nonzero_seen = true;
   }
   buf[idx] = 0;
   st_write_str(fd, buf);
}

static void st_write_word(int fd, unw_word_t num, bool nopad=false)
{
   st_write_num_hex(fd, num, sizeof(num), nopad);
}

void st_dump(int fd, int sig)
{
   int framenum = 0;
   unw_context_t ctx;
   unw_cursor_t cursor;

   unw_getcontext(&ctx);
   unw_init_local(&cursor, &ctx);

   st_write_str(fd, "stacktrace dump of " PACKAGE_NAME " " PACKAGE_VERSION "\n");
   st_write_str(fd, "uid: ");
   st_write_num(fd, getuid());
   st_write_str(fd, " pid: ");
   st_write_num(fd, getpid());
#ifdef SYS_gettid
   st_write_str(fd, " tid: ");
   st_write_num(fd, syscall(SYS_gettid));
#endif
   st_write_str(fd, "\n");

   st_write_str(fd, "received signal: ");
   st_write_num(fd, sig);
   st_write_str(fd, "\n");


   while (unw_step(&cursor) > 0) {
      unw_word_t offset;
      unw_word_t pc;
      unw_word_t sp;

      st_write_str(fd, "#");
      st_write_num(fd, framenum, 2);
      st_write_str(fd, " ");
      if (unw_get_reg(&cursor, UNW_REG_IP, &pc) == 0) {
         if (pc == 0) {
            break;
         }

         st_write_word(fd, pc);
      } else {
         st_write_str(fd, "???");
      }
      st_write_str(fd, " ");
      if (unw_get_reg(&cursor, UNW_REG_SP, &sp) == 0) {
         st_write_word(fd, sp);
      } else {
         st_write_str(fd, "???");
      }

      framenum++;
      st_write_str(fd, ": ");

      char sym[256];
      if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
         st_write_str(fd, sym);
         st_write_str(fd, "+");
         st_write_word(fd, offset, true);
         if (unw_is_signal_frame(&cursor)) {
            st_write_str(fd, " <-");
         }
         st_write_str(fd, "\n");
      } else {
         st_write_str(fd, "???\n");
      }
   }
}

#endif