|
14 | 14 | * limitations under the License. |
15 | 15 | */ |
16 | 16 |
|
| 17 | +#include <algorithm> |
17 | 18 | #include <array> |
18 | 19 | #include <atomic> |
| 20 | +#include <cerrno> |
| 21 | +#include <csignal> |
19 | 22 | #include <cstdint> |
20 | 23 | #include <cstring> |
21 | 24 | #include <limits> |
@@ -651,31 +654,66 @@ void foo2() { |
651 | 654 | verifyStackTraces(); |
652 | 655 | } |
653 | 656 |
|
654 | | -volatile bool handled = false; |
655 | | -void handler(int /* num */, siginfo_t* /* info */, void* /* ctx */) { |
656 | | - // Yes, getStackTrace and VLOG aren't async-signal-safe, but signals |
657 | | - // raised with raise() aren't "async" signals. |
| 657 | +TEST(StackTraceTest, Simple) { |
658 | 658 | foo1(); |
659 | | - handled = true; |
660 | 659 | } |
661 | 660 |
|
662 | | -TEST(StackTraceTest, Simple) { |
663 | | - foo1(); |
| 661 | +namespace { |
| 662 | + |
| 663 | +// NOLINTNEXTLINE |
| 664 | +std::array<uintptr_t, 100> signalAddresses{}; |
| 665 | +std::atomic<ssize_t> signalFrameCount{-1}; |
| 666 | +static_assert(decltype(signalFrameCount)::is_always_lock_free); |
| 667 | + |
| 668 | +FOLLY_NOINLINE void captureSignalStackTrace(int) { |
| 669 | + const int savedErrno = errno; |
| 670 | + signalFrameCount.store( |
| 671 | + getStackTraceSafe(signalAddresses.data(), signalAddresses.size()), |
| 672 | + std::memory_order_release); |
| 673 | + errno = savedErrno; |
| 674 | +} |
| 675 | + |
| 676 | +FOLLY_NOINLINE int raiseSignalForStackTrace() { |
| 677 | + const int result = raise(SIGUSR1); |
| 678 | + compiler_must_not_elide(result); |
| 679 | + return result; |
664 | 680 | } |
665 | 681 |
|
| 682 | +} // namespace |
| 683 | + |
666 | 684 | TEST(StackTraceTest, Signal) { |
667 | | - if (folly::kIsSanitizeThread) { |
668 | | - // TSAN doesn't like signal-unsafe functions in a signal handler regardless |
669 | | - // of how the signal is raised. So skip the test in that case. |
670 | | - SKIP() << "Not supported for TSAN"; |
671 | | - } |
672 | | - struct sigaction sa; |
673 | | - memset(&sa, 0, sizeof(sa)); |
674 | | - sa.sa_sigaction = handler; |
675 | | - sa.sa_flags = SA_RESETHAND | SA_SIGINFO; |
676 | | - CHECK_ERR(sigaction(SIGUSR1, &sa, nullptr)); |
677 | | - raise(SIGUSR1); |
678 | | - EXPECT_TRUE(handled); |
| 685 | + struct sigaction sa{}; |
| 686 | + sa.sa_handler = captureSignalStackTrace; |
| 687 | + sigemptyset(&sa.sa_mask); |
| 688 | + struct sigaction previous{}; |
| 689 | + ASSERT_EQ(sigaction(SIGUSR1, &sa, &previous), 0); |
| 690 | + SCOPE_EXIT { |
| 691 | + CHECK_ERR(sigaction(SIGUSR1, &previous, nullptr)); |
| 692 | + }; |
| 693 | + |
| 694 | + signalFrameCount.store(-1, std::memory_order_relaxed); |
| 695 | + errno = EDOM; |
| 696 | + const int result = raiseSignalForStackTrace(); |
| 697 | + const int signalErrno = errno; |
| 698 | + ASSERT_EQ(result, 0); |
| 699 | + EXPECT_EQ(signalErrno, EDOM); |
| 700 | + const auto count = signalFrameCount.load(std::memory_order_acquire); |
| 701 | + ASSERT_GT(count, 0); |
| 702 | + ASSERT_LE(count, static_cast<ssize_t>(signalAddresses.size())); |
| 703 | + |
| 704 | + FrameArray<signalAddresses.size()> frames; |
| 705 | + frames.frameCount = static_cast<size_t>(count); |
| 706 | + std::copy_n(signalAddresses.begin(), frames.frameCount, frames.addresses); |
| 707 | + Symbolizer symbolizer; |
| 708 | + symbolizer.symbolize(frames); |
| 709 | + StringSymbolizePrinter printer; |
| 710 | + printer.println(frames); |
| 711 | + const auto stackTrace = printer.str(); |
| 712 | + const auto handler = stackTrace.find("captureSignalStackTrace"); |
| 713 | + const auto caller = stackTrace.find("raiseSignalForStackTrace"); |
| 714 | + ASSERT_NE(handler, std::string::npos) << stackTrace; |
| 715 | + ASSERT_NE(caller, std::string::npos) << stackTrace; |
| 716 | + EXPECT_LT(handler, caller) << stackTrace; |
679 | 717 | } |
680 | 718 |
|
681 | 719 | ssize_t read_all(int fd, uint8_t* buffer, size_t size) { |
|
0 commit comments