| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Wrapper for running the test under heapchecker and analyzing the output.""" |
| |
| import datetime |
| import logging |
| import os |
| import re |
| |
| import common |
| import path_utils |
| import suppressions |
| |
| |
| class HeapcheckWrapper(object): |
| TMP_FILE = 'heapcheck.log' |
| SANITY_TEST_SUPPRESSION = "Heapcheck sanity test" |
| LEAK_REPORT_RE = re.compile( |
| 'Leak of ([0-9]*) bytes in ([0-9]*) objects allocated from:') |
| # Workaround for http://crbug.com/132867, see below. |
| HOOKED_ALLOCATOR_RE = re.compile( |
| 'Hooked allocator frame not found, returning empty trace') |
| STACK_LINE_RE = re.compile('\s*@\s*(?:0x)?[0-9a-fA-F]+\s*([^\n]*)') |
| BORING_CALLERS = common.BoringCallers(mangled=False, use_re_wildcards=True) |
| |
| def __init__(self, supp_files): |
| self._mode = 'strict' |
| self._timeout = 3600 |
| self._nocleanup_on_exit = False |
| self._suppressions = [] |
| for fname in supp_files: |
| self._suppressions.extend(suppressions.ReadSuppressionsFromFile(fname)) |
| if os.path.exists(self.TMP_FILE): |
| os.remove(self.TMP_FILE) |
| |
| def PutEnvAndLog(self, env_name, env_value): |
| """Sets the env var |env_name| to |env_value| and writes to logging.info. |
| """ |
| os.putenv(env_name, env_value) |
| logging.info('export %s=%s', env_name, env_value) |
| |
| def Execute(self): |
| """Executes the app to be tested.""" |
| logging.info('starting execution...') |
| proc = ['sh', path_utils.ScriptDir() + '/heapcheck_std.sh'] |
| proc += self._args |
| self.PutEnvAndLog('G_SLICE', 'always-malloc') |
| self.PutEnvAndLog('NSS_DISABLE_ARENA_FREE_LIST', '1') |
| self.PutEnvAndLog('NSS_DISABLE_UNLOAD', '1') |
| self.PutEnvAndLog('GTEST_DEATH_TEST_USE_FORK', '1') |
| self.PutEnvAndLog('HEAPCHECK', self._mode) |
| self.PutEnvAndLog('HEAP_CHECK_ERROR_EXIT_CODE', '0') |
| self.PutEnvAndLog('HEAP_CHECK_MAX_LEAKS', '-1') |
| self.PutEnvAndLog('KEEP_SHADOW_STACKS', '1') |
| self.PutEnvAndLog('PPROF_PATH', |
| path_utils.ScriptDir() + |
| '/../../third_party/tcmalloc/chromium/src/pprof') |
| self.PutEnvAndLog('LD_LIBRARY_PATH', |
| '/usr/lib/debug/:/usr/lib32/debug/') |
| # CHROME_DEVEL_SANDBOX causes problems with heapcheck |
| self.PutEnvAndLog('CHROME_DEVEL_SANDBOX', ''); |
| |
| return common.RunSubprocess(proc, self._timeout) |
| |
| def Analyze(self, log_lines, check_sanity=False): |
| """Analyzes the app's output and applies suppressions to the reports. |
| |
| Analyze() searches the logs for leak reports and tries to apply |
| suppressions to them. Unsuppressed reports and other log messages are |
| dumped as is. |
| |
| If |check_sanity| is True, the list of suppressed reports is searched for a |
| report starting with SANITY_TEST_SUPPRESSION. If there isn't one, Analyze |
| returns 2 regardless of the unsuppressed reports. |
| |
| Args: |
| log_lines: An iterator over the app's log lines. |
| check_sanity: A flag that determines whether we should check the tool's |
| sanity. |
| Returns: |
| 2, if the sanity check fails, |
| 1, if unsuppressed reports remain in the output and the sanity check |
| passes, |
| 0, if all the errors are suppressed and the sanity check passes. |
| """ |
| return_code = 0 |
| # leak signature: [number of bytes, number of objects] |
| cur_leak_signature = None |
| cur_stack = [] |
| cur_report = [] |
| reported_hashes = {} |
| # Statistics grouped by suppression description: |
| # [hit count, bytes, objects]. |
| used_suppressions = {} |
| hooked_allocator_line_encountered = False |
| for line in log_lines: |
| line = line.rstrip() # remove the trailing \n |
| match = self.STACK_LINE_RE.match(line) |
| if match: |
| cur_stack.append(match.groups()[0]) |
| cur_report.append(line) |
| continue |
| else: |
| if cur_stack: |
| # Try to find the suppression that applies to the current leak stack. |
| description = '' |
| for supp in self._suppressions: |
| if supp.Match(cur_stack): |
| cur_stack = [] |
| description = supp.description |
| break |
| if cur_stack: |
| if not cur_leak_signature: |
| print 'Missing leak signature for the following stack: ' |
| for frame in cur_stack: |
| print ' ' + frame |
| print 'Aborting...' |
| return 3 |
| |
| # Drop boring callers from the stack to get less redundant info |
| # and fewer unique reports. |
| found_boring = False |
| for i in range(1, len(cur_stack)): |
| for j in self.BORING_CALLERS: |
| if re.match(j, cur_stack[i]): |
| cur_stack = cur_stack[:i] |
| cur_report = cur_report[:i] |
| found_boring = True |
| break |
| if found_boring: |
| break |
| |
| error_hash = hash("".join(cur_stack)) & 0xffffffffffffffff |
| if error_hash not in reported_hashes: |
| reported_hashes[error_hash] = 1 |
| # Print the report and set the return code to 1. |
| print ('Leak of %d bytes in %d objects allocated from:' |
| % tuple(cur_leak_signature)) |
| print '\n'.join(cur_report) |
| return_code = 1 |
| # Generate the suppression iff the stack contains more than one |
| # frame (otherwise it's likely to be broken) |
| if len(cur_stack) > 1 or found_boring: |
| print '\nSuppression (error hash=#%016X#):\n{' % (error_hash) |
| print ' <insert_a_suppression_name_here>' |
| print ' Heapcheck:Leak' |
| for frame in cur_stack: |
| print ' fun:' + frame |
| print '}\n\n' |
| else: |
| print ('This stack may be broken due to omitted frame pointers.' |
| ' It is not recommended to suppress it.\n') |
| else: |
| # Update the suppressions histogram. |
| if description in used_suppressions: |
| hits, bytes, objects = used_suppressions[description] |
| hits += 1 |
| bytes += cur_leak_signature[0] |
| objects += cur_leak_signature[1] |
| used_suppressions[description] = [hits, bytes, objects] |
| else: |
| used_suppressions[description] = [1] + cur_leak_signature |
| cur_stack = [] |
| cur_report = [] |
| cur_leak_signature = None |
| match = self.LEAK_REPORT_RE.match(line) |
| if match: |
| cur_leak_signature = map(int, match.groups()) |
| else: |
| match = self.HOOKED_ALLOCATOR_RE.match(line) |
| if match: |
| hooked_allocator_line_encountered = True |
| else: |
| print line |
| # Print the list of suppressions used. |
| is_sane = False |
| if used_suppressions: |
| print |
| print '-----------------------------------------------------' |
| print 'Suppressions used:' |
| print ' count bytes objects name' |
| histo = {} |
| for description in used_suppressions: |
| if description.startswith(HeapcheckWrapper.SANITY_TEST_SUPPRESSION): |
| is_sane = True |
| hits, bytes, objects = used_suppressions[description] |
| line = '%8d %8d %8d %s' % (hits, bytes, objects, description) |
| if hits in histo: |
| histo[hits].append(line) |
| else: |
| histo[hits] = [line] |
| keys = histo.keys() |
| keys.sort() |
| for count in keys: |
| for line in histo[count]: |
| print line |
| print '-----------------------------------------------------' |
| if hooked_allocator_line_encountered: |
| print ('WARNING: Workaround for http://crbug.com/132867 (tons of ' |
| '"Hooked allocator frame not found, returning empty trace") ' |
| 'in effect.') |
| if check_sanity and not is_sane: |
| logging.error("Sanity check failed") |
| return 2 |
| else: |
| return return_code |
| |
| def RunTestsAndAnalyze(self, check_sanity): |
| exec_retcode = self.Execute() |
| log_file = file(self.TMP_FILE, 'r') |
| analyze_retcode = self.Analyze(log_file, check_sanity) |
| log_file.close() |
| |
| if analyze_retcode: |
| logging.error("Analyze failed.") |
| return analyze_retcode |
| |
| if exec_retcode: |
| logging.error("Test execution failed.") |
| return exec_retcode |
| else: |
| logging.info("Test execution completed successfully.") |
| |
| return 0 |
| |
| def Main(self, args, check_sanity=False): |
| self._args = args |
| start = datetime.datetime.now() |
| retcode = -1 |
| retcode = self.RunTestsAndAnalyze(check_sanity) |
| end = datetime.datetime.now() |
| seconds = (end - start).seconds |
| hours = seconds / 3600 |
| seconds %= 3600 |
| minutes = seconds / 60 |
| seconds %= 60 |
| logging.info('elapsed time: %02d:%02d:%02d', hours, minutes, seconds) |
| logging.info('For more information on the Heapcheck bot see ' |
| 'http://dev.chromium.org/developers/how-tos/' |
| 'using-the-heap-leak-checker') |
| return retcode |
| |
| |
| def RunTool(args, supp_files, module): |
| tool = HeapcheckWrapper(supp_files) |
| MODULES_TO_SANITY_CHECK = ["base"] |
| check_sanity = module in MODULES_TO_SANITY_CHECK |
| return tool.Main(args[1:], check_sanity) |
