Home | History | Annotate | Download | only in tests
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*
     18  * Contributed by: Intel Corporation
     19  */
     20 
     21 #include <gtest/gtest.h>
     22 
     23 #include <dlfcn.h>
     24 #include <signal.h>
     25 #include <stdio.h>
     26 #include <stdlib.h>
     27 #include <string.h>
     28 #include <sys/types.h>
     29 #include <unistd.h>
     30 #include <unwind.h>
     31 
     32 #include "SignalUtils.h"
     33 
     34 #define noinline __attribute__((__noinline__))
     35 #define __unused __attribute__((__unused__))
     36 
     37 _Unwind_Reason_Code FrameCounter(_Unwind_Context* ctx __unused, void* arg) {
     38   int* count_ptr = reinterpret_cast<int*>(arg);
     39 
     40 #if SHOW_FRAME_LOCATIONS
     41   void* ip = reinterpret_cast<void*>(_Unwind_GetIP(ctx));
     42 
     43   const char* symbol = "<unknown>";
     44   int offset = 0;
     45 
     46   Dl_info info;
     47   memset(&info, 0, sizeof(info));
     48   if (dladdr(ip, &info) != 0) {
     49     symbol = info.dli_sname;
     50     if (info.dli_saddr != nullptr) {
     51       offset = static_cast<int>(reinterpret_cast<char*>(ip) - reinterpret_cast<char*>(info.dli_saddr));
     52     }
     53   }
     54 
     55   fprintf(stderr, " #%02d %p %s%+d (%s)\n", *count_ptr, ip, symbol, offset, info.dli_fname ? info.dli_fname : "??");
     56   fflush(stderr);
     57 #endif
     58 
     59   ++*count_ptr;
     60   return _URC_NO_REASON;
     61 }
     62 
     63 static int noinline unwind_one_frame_deeper() {
     64   int count = 0;
     65   _Unwind_Backtrace(FrameCounter, &count);
     66   return count;
     67 }
     68 
     69 TEST(stack_unwinding, easy) {
     70   int count = 0;
     71   _Unwind_Backtrace(FrameCounter, &count);
     72   int deeper_count = unwind_one_frame_deeper();
     73   ASSERT_EQ(count + 1, deeper_count);
     74 }
     75 
     76 struct UnwindData {
     77   volatile bool signal_handler_complete = false;
     78   int expected_frame_count = 0;
     79   int handler_frame_count = 0;
     80   int handler_one_deeper_frame_count = 0;
     81 };
     82 
     83 static UnwindData g_unwind_data;
     84 
     85 static void noinline UnwindSignalHandler(int) {
     86   _Unwind_Backtrace(FrameCounter, &g_unwind_data.handler_frame_count);
     87 
     88   g_unwind_data.handler_one_deeper_frame_count = unwind_one_frame_deeper();
     89   g_unwind_data.signal_handler_complete = true;
     90 }
     91 
     92 static void verify_unwind_data(const UnwindData& unwind_data) {
     93   // In order to avoid a false positive, the caller must have at least 2 frames
     94   // outside of the signal handler. This avoids a case where the only frame
     95   // right after the signal handler winds up being garbage.
     96   EXPECT_GT(unwind_data.handler_frame_count, unwind_data.expected_frame_count + 1);
     97 
     98   EXPECT_EQ(unwind_data.handler_frame_count + 1, unwind_data.handler_one_deeper_frame_count);
     99 }
    100 
    101 static void noinline UnwindTest() {
    102   g_unwind_data = {};
    103 
    104   _Unwind_Backtrace(FrameCounter, &g_unwind_data.expected_frame_count);
    105   ASSERT_LE(2, g_unwind_data.expected_frame_count)
    106       << "The current call must contain at least 2 frames for the test to be valid.";
    107 
    108   ASSERT_EQ(0, kill(getpid(), SIGUSR1));
    109   while (!g_unwind_data.signal_handler_complete) {}
    110 
    111   verify_unwind_data(g_unwind_data);
    112 }
    113 
    114 TEST(stack_unwinding, unwind_through_signal_frame) {
    115 #if defined(__i386__)
    116   GTEST_SKIP() << "Temporarily skip test since it fails on x86 see b/132763120.";
    117 #endif
    118 
    119   ScopedSignalHandler ssh(SIGUSR1, UnwindSignalHandler);
    120 
    121   UnwindTest();
    122 }
    123 
    124 // On LP32, the SA_SIGINFO flag gets you __restore_rt instead of __restore.
    125 TEST(stack_unwinding, unwind_through_signal_frame_SA_SIGINFO) {
    126 #if defined(__i386__)
    127   GTEST_SKIP() << "Temporarily skip test since it fails on x86 see b/132763120.";
    128 #endif
    129 
    130   ScopedSignalHandler ssh(SIGUSR1, UnwindSignalHandler, SA_SIGINFO);
    131 
    132   UnwindTest();
    133 }
    134