From 043a98c4941cccafb5a2de0c653a798cc80f8121 Mon Sep 17 00:00:00 2001 From: Ben Noordhuis Date: Tue, 8 Nov 2016 22:07:16 +0100 Subject: [PATCH 1/3] tools: copy run-valgrind.py to tools/ It was a symbolic link to deps/v8/tools/run-valgrind.py before. We are going to make changes to it and we don't want to carry the patch forward so make a copy. PR-URL: https://github.com/nodejs/node/pull/9520 Reviewed By: Sakthipriyan Vairamani Reviewed-By: Anna Henningsen Reviewed-By: Michael Dawson --- tools/run-valgrind.py | 103 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 102 insertions(+), 1 deletion(-) mode change 120000 => 100755 tools/run-valgrind.py diff --git a/tools/run-valgrind.py b/tools/run-valgrind.py deleted file mode 120000 index 07935ad7d4fc08..00000000000000 --- a/tools/run-valgrind.py +++ /dev/null @@ -1 +0,0 @@ -../deps/v8/tools/run-valgrind.py \ No newline at end of file diff --git a/tools/run-valgrind.py b/tools/run-valgrind.py new file mode 100755 index 00000000000000..e3f84f58fed3fc --- /dev/null +++ b/tools/run-valgrind.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python +# +# Copyright 2009 the V8 project authors. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * 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. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "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 COPYRIGHT +# OWNER 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. + +# Simple wrapper for running valgrind and checking the output on +# stderr for memory leaks. +# Uses valgrind from third_party/valgrind. Assumes the executable is passed +# with a path relative to the v8 root. + + +from os import path +import platform +import re +import subprocess +import sys + +V8_ROOT = path.dirname(path.dirname(path.abspath(__file__))) +MACHINE = 'linux_x64' if platform.machine() == 'x86_64' else 'linux_x86' +VALGRIND_ROOT = path.join(V8_ROOT, 'third_party', 'valgrind', MACHINE) +VALGRIND_BIN = path.join(VALGRIND_ROOT, 'bin', 'valgrind') +VALGRIND_LIB = path.join(VALGRIND_ROOT, 'lib', 'valgrind') + +VALGRIND_ARGUMENTS = [ + VALGRIND_BIN, + '--error-exitcode=1', + '--leak-check=full', + '--smc-check=all', +] + +if len(sys.argv) < 2: + print 'Please provide an executable to analyze.' + sys.exit(1) + +executable = path.join(V8_ROOT, sys.argv[1]) +if not path.exists(executable): + print 'Cannot find the file specified: %s' % executable + sys.exit(1) + +# Compute the command line. +command = VALGRIND_ARGUMENTS + [executable] + sys.argv[2:] + +# Run valgrind. +process = subprocess.Popen( + command, + stderr=subprocess.PIPE, + env={'VALGRIND_LIB': VALGRIND_LIB} +) +code = process.wait(); +errors = process.stderr.readlines(); + +# If valgrind produced an error, we report that to the user. +if code != 0: + sys.stderr.writelines(errors) + sys.exit(code) + +# Look through the leak details and make sure that we don't +# have any definitely, indirectly, and possibly lost bytes. +LEAK_RE = r"(?:definitely|indirectly|possibly) lost: " +LEAK_LINE_MATCHER = re.compile(LEAK_RE) +LEAK_OKAY_MATCHER = re.compile(r"lost: 0 bytes in 0 blocks") +leaks = [] +for line in errors: + if LEAK_LINE_MATCHER.search(line): + leaks.append(line) + if not LEAK_OKAY_MATCHER.search(line): + sys.stderr.writelines(errors) + sys.exit(1) + +# Make sure we found between 2 and 3 leak lines. +if len(leaks) < 2 or len(leaks) > 3: + sys.stderr.writelines(errors) + sys.stderr.write('\n\n#### Malformed valgrind output.\n#### Exiting.\n') + sys.exit(1) + +# No leaks found. +sys.stderr.writelines(errors) +sys.exit(0) From e762ca0060dcce3e047cacc7824ba07e0fb045f3 Mon Sep 17 00:00:00 2001 From: Ben Noordhuis Date: Tue, 8 Nov 2016 22:07:17 +0100 Subject: [PATCH 2/3] tools: fix run-valgrind.py script The script had a dependency on the copy of valgrind that is bundled with V8 but that only gets checked out when doing a full depot_tools checkout. Use the system-provided valgrind. PR-URL: https://github.com/nodejs/node/pull/9520 Reviewed By: Sakthipriyan Vairamani Reviewed-By: Anna Henningsen Reviewed-By: Michael Dawson --- tools/run-valgrind.py | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/tools/run-valgrind.py b/tools/run-valgrind.py index e3f84f58fed3fc..9e26dbed8ed53a 100755 --- a/tools/run-valgrind.py +++ b/tools/run-valgrind.py @@ -40,13 +40,9 @@ import sys V8_ROOT = path.dirname(path.dirname(path.abspath(__file__))) -MACHINE = 'linux_x64' if platform.machine() == 'x86_64' else 'linux_x86' -VALGRIND_ROOT = path.join(V8_ROOT, 'third_party', 'valgrind', MACHINE) -VALGRIND_BIN = path.join(VALGRIND_ROOT, 'bin', 'valgrind') -VALGRIND_LIB = path.join(VALGRIND_ROOT, 'lib', 'valgrind') VALGRIND_ARGUMENTS = [ - VALGRIND_BIN, + 'valgrind', '--error-exitcode=1', '--leak-check=full', '--smc-check=all', @@ -65,11 +61,7 @@ command = VALGRIND_ARGUMENTS + [executable] + sys.argv[2:] # Run valgrind. -process = subprocess.Popen( - command, - stderr=subprocess.PIPE, - env={'VALGRIND_LIB': VALGRIND_LIB} -) +process = subprocess.Popen(command, stderr=subprocess.PIPE) code = process.wait(); errors = process.stderr.readlines(); From a804627837c69920f34dcfa6d2331e16c64f8fd6 Mon Sep 17 00:00:00 2001 From: Ben Noordhuis Date: Tue, 8 Nov 2016 22:07:34 +0100 Subject: [PATCH 3/3] tools: make run-valgrind.py useful Node.js does not clean up on exit so don't complain about memory leaks but do complain about invalid memory access. In the future we may want to add a cleanup-on-exit flag or put together a suppression list. PR-URL: https://github.com/nodejs/node/pull/9520 Reviewed By: Sakthipriyan Vairamani Reviewed-By: Anna Henningsen Reviewed-By: Michael Dawson --- tools/run-valgrind.py | 43 +++++++------------------------------------ 1 file changed, 7 insertions(+), 36 deletions(-) diff --git a/tools/run-valgrind.py b/tools/run-valgrind.py index 9e26dbed8ed53a..ae1a3194cac4a6 100755 --- a/tools/run-valgrind.py +++ b/tools/run-valgrind.py @@ -27,32 +27,26 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# Simple wrapper for running valgrind and checking the output on -# stderr for memory leaks. -# Uses valgrind from third_party/valgrind. Assumes the executable is passed -# with a path relative to the v8 root. - - from os import path -import platform -import re import subprocess import sys -V8_ROOT = path.dirname(path.dirname(path.abspath(__file__))) +NODE_ROOT = path.dirname(path.dirname(path.abspath(__file__))) VALGRIND_ARGUMENTS = [ 'valgrind', '--error-exitcode=1', - '--leak-check=full', '--smc-check=all', + # Node.js does not clean up on exit so don't complain about + # memory leaks but do complain about invalid memory access. + '--quiet', ] if len(sys.argv) < 2: print 'Please provide an executable to analyze.' sys.exit(1) -executable = path.join(V8_ROOT, sys.argv[1]) +executable = path.join(NODE_ROOT, sys.argv[1]) if not path.exists(executable): print 'Cannot find the file specified: %s' % executable sys.exit(1) @@ -62,33 +56,10 @@ # Run valgrind. process = subprocess.Popen(command, stderr=subprocess.PIPE) -code = process.wait(); -errors = process.stderr.readlines(); +code = process.wait() +errors = process.stderr.readlines() # If valgrind produced an error, we report that to the user. if code != 0: sys.stderr.writelines(errors) sys.exit(code) - -# Look through the leak details and make sure that we don't -# have any definitely, indirectly, and possibly lost bytes. -LEAK_RE = r"(?:definitely|indirectly|possibly) lost: " -LEAK_LINE_MATCHER = re.compile(LEAK_RE) -LEAK_OKAY_MATCHER = re.compile(r"lost: 0 bytes in 0 blocks") -leaks = [] -for line in errors: - if LEAK_LINE_MATCHER.search(line): - leaks.append(line) - if not LEAK_OKAY_MATCHER.search(line): - sys.stderr.writelines(errors) - sys.exit(1) - -# Make sure we found between 2 and 3 leak lines. -if len(leaks) < 2 or len(leaks) > 3: - sys.stderr.writelines(errors) - sys.stderr.write('\n\n#### Malformed valgrind output.\n#### Exiting.\n') - sys.exit(1) - -# No leaks found. -sys.stderr.writelines(errors) -sys.exit(0)