From patchwork Mon Aug 22 17:58:08 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Buettner X-Patchwork-Id: 14849 Received: (qmail 44980 invoked by alias); 22 Aug 2016 17:58:24 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 44971 invoked by uid 89); 22 Aug 2016 17:58:23 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.9 required=5.0 tests=BAYES_00, KAM_LAZY_DOMAIN_SECURITY, RCVD_IN_DNSWL_NONE autolearn=no version=3.3.2 spammy=herein, ccc, Starting, sentinel X-HELO: emailserver1.aplushosting.com Received: from emailserver1.asdf456.com (HELO emailserver1.aplushosting.com) (72.18.207.136) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with SMTP; Mon, 22 Aug 2016 17:58:13 +0000 Received: (qmail 3742 invoked by uid 0); 22 Aug 2016 17:58:11 -0000 Received: from unknown (HELO pinnacle.lan) (70.176.31.165) by emailserver1.asdf456.com with SMTP; Mon, 22 Aug 2016 17:58:11 +0000 Date: Mon, 22 Aug 2016 10:58:08 -0700 From: Kevin Buettner To: gdb-patches@sourceware.org Subject: [PATCH] Test case to detect recursive unwinding in Python-based unwinders Message-ID: <20160822105808.6b37787a@pinnacle.lan> MIME-Version: 1.0 This test case verifies that GDB will not attempt to invoke a python unwinder recursively. At the moment, the behavior exhibited by GDB looks like this: (gdb) source py-recurse-unwind.py Python script imported (gdb) b ccc Breakpoint 1 at 0x4004bd: file py-recurse-unwind.c, line 23. (gdb) run Starting program: py-recurse-unwind TestUnwinder: Recursion detected - returning early. TestUnwinder: Recursion detected - returning early. TestUnwinder: Recursion detected - returning early. TestUnwinder: Recursion detected - returning early. Breakpoint 1, ccc (arg=) at py-recurse-unwind.c:23 23 } (gdb) bt #-1 ccc (arg=) at py-recurse-unwind.c:23 Backtrace stopped: previous frame identical to this frame (corrupt stack?) [I've shortened pathnames for easier reading.] The desired / expected behavior looks like this: (gdb) source py-recurse-unwind.py Python script imported (gdb) b ccc Breakpoint 1 at 0x4004bd: file py-recurse-unwind.c, line 23. (gdb) run Starting program: py-recurse-unwind Breakpoint 1, ccc (arg=789) at py-recurse-unwind.c:23 23 } (gdb) bt #0 ccc (arg=789) at py-recurse-unwind.c:23 #1 0x00000000004004d5 in bbb (arg=456) at py-recurse-unwind.c:28 #2 0x00000000004004ed in aaa (arg=123) at py-recurse-unwind.c:34 #3 0x00000000004004fe in main () at py-recurse-unwind.c:40 Note that GDB's problems go well beyond the fact that it invokes the unwinder recursively. In the process it messes up some internal state (the frame stash) leading to display of (only) the sentinel frame in the backtrace. gdb/testsuite/ChangeLog: * gdb.python/py-recurse-unwind.c: New file. * gdb.python/py-recurse-unwind.py: New file. * gdb.python/py-recurse-unwind.exp: New file. --- gdb/testsuite/gdb.python/py-recurse-unwind.c | 42 +++++++++++++++ gdb/testsuite/gdb.python/py-recurse-unwind.exp | 73 ++++++++++++++++++++++++++ gdb/testsuite/gdb.python/py-recurse-unwind.py | 68 ++++++++++++++++++++++++ 3 files changed, 183 insertions(+) diff --git a/gdb/testsuite/gdb.python/py-recurse-unwind.c b/gdb/testsuite/gdb.python/py-recurse-unwind.c new file mode 100644 index 0000000..02a835a --- /dev/null +++ b/gdb/testsuite/gdb.python/py-recurse-unwind.c @@ -0,0 +1,42 @@ +/* This test program is part of GDB, the GNU debugger. + + Copyright 2016 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* This is the test program loaded into GDB by the py-recurse-unwind test. */ + +void +ccc (int arg) +{ +} + +void +bbb (int arg) +{ + ccc (789); +} + +void +aaa (int arg) +{ + bbb (456); +} + +int +main () +{ + aaa (123); + return 0; +} diff --git a/gdb/testsuite/gdb.python/py-recurse-unwind.exp b/gdb/testsuite/gdb.python/py-recurse-unwind.exp new file mode 100644 index 0000000..9629a97 --- /dev/null +++ b/gdb/testsuite/gdb.python/py-recurse-unwind.exp @@ -0,0 +1,73 @@ +# Copyright (C) 2016 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# This file is part of the GDB testsuite. It is used to verify that +# GDB does not recurse infinitely when calling gdb.parse_and_eval() in +# the course of sniffing a frame in a Python unwinder. + +# The unwinder has been constructed so that, should recursion occur, +# it will be detected in the unwinder so that we won't need to wait +# for a timeout. + + +load_lib gdb-python.exp + +standard_testfile + +if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } { + return -1 +} + +# Skip all tests if Python scripting is not enabled. +if { [skip_python_tests] } { continue } + +set pyfile [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py] + +gdb_test "source ${pyfile}" "Python script imported" \ + "import python scripts" + +# The following tests require execution. + +if ![runto_main] then { + fail "Can't run to main" + return 0 +} + +gdb_breakpoint "ccc" + +gdb_continue_to_breakpoint "ccc" + +# If the unwinder is active, the usage count will increment while +# running to the breakpoint. Reset it prior to doing the backtrace. +gdb_test_no_output "python TestUnwinder.reset_count()" + +# The python based unwinder should be called a number of times while +# generating the backtrace, but its sniffer always returns None. So +# it doesn't really contribute to generating any of the frames below. +# +# But that's okay. Our goal here is to make sure that GDB doesn't +# get hung up in potentially infinite recursion when invoking the +# Python-based unwinder. + +gdb_test_sequence "bt" "backtrace" { + "\\r\\n#0 .* ccc \\(arg=789\\) at " + "\\r\\n#1 .* bbb \\(arg=456\\) at " + "\\r\\n#2 .* aaa \\(arg=123\\) at " + "\\r\\n#3 .* main \\(.*\\) at" +} + +# Test that the python-based unwinder / sniffer was actually called +# during generation of the backtrace. +gdb_test "python print(TestUnwinder.count > 0)" "True" diff --git a/gdb/testsuite/gdb.python/py-recurse-unwind.py b/gdb/testsuite/gdb.python/py-recurse-unwind.py new file mode 100644 index 0000000..1da7aca --- /dev/null +++ b/gdb/testsuite/gdb.python/py-recurse-unwind.py @@ -0,0 +1,68 @@ +# Copyright (C) 2016 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# This unwinder never does any unwinding. It'll (pretend to) "sniff" +# the frame and ultimately return None, indicating that actual unwinding +# should be performed by some other unwinder. +# +# But, prior to returning None, it will attempt to obtain the value +# associated with a symbol via a call to gdb.parse_and_eval(). In +# the course of doing this evaluation, GDB will potentially access +# some frames, leading to the possibility of a recursive invocation of +# this unwinder. If that should happen, code contained herein detects +# that and prints a message which will cause some of the associated +# tests to FAIL. + +import gdb +from gdb.unwinder import Unwinder + +class TestUnwinder(Unwinder): + + count = 0 + + @classmethod + def reset_count (cls): + cls.count = 0 + + @classmethod + def inc_count (cls): + cls.count += 1 + + def __init__(self): + Unwinder.__init__(self, "test unwinder") + self.recurse_level = 0 + + def __call__(self, pending_frame): + + + if self.recurse_level > 0: + gdb.write("TestUnwinder: Recursion detected - returning early.\n") + return None + + self.recurse_level += 1 + TestUnwinder.inc_count() + + try: + val = gdb.parse_and_eval("undefined_symbol") + + except Exception as arg: + pass + + self.recurse_level -= 1 + + return None + +gdb.unwinder.register_unwinder(None, TestUnwinder(), True) +gdb.write("Python script imported\n")