| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 # Use of this source code is governed by a BSD-style license that can be | |
| 3 # found in the LICENSE file. | |
| 4 | |
| 5 """Wrapper for running the test under heapchecker and analyzing the output.""" | |
| 6 | |
| 7 import datetime | |
| 8 import logging | |
| 9 import os | |
| 10 import re | |
| 11 | |
| 12 import common | |
| 13 import path_utils | |
| 14 import suppressions | |
| 15 | |
| 16 | |
| 17 class HeapcheckWrapper(object): | |
| 18 TMP_FILE = 'heapcheck.log' | |
| 19 SANITY_TEST_SUPPRESSION = "Heapcheck sanity test" | |
| 20 LEAK_REPORT_RE = re.compile( | |
| 21 'Leak of ([0-9]*) bytes in ([0-9]*) objects allocated from:') | |
| 22 # Workaround for http://crbug.com/132867, see below. | |
| 23 HOOKED_ALLOCATOR_RE = re.compile( | |
| 24 'Hooked allocator frame not found, returning empty trace') | |
| 25 STACK_LINE_RE = re.compile('\s*@\s*(?:0x)?[0-9a-fA-F]+\s*([^\n]*)') | |
| 26 BORING_CALLERS = common.BoringCallers(mangled=False, use_re_wildcards=True) | |
| 27 | |
| 28 def __init__(self, supp_files): | |
| 29 self._mode = 'strict' | |
| 30 self._timeout = 3600 | |
| 31 self._nocleanup_on_exit = False | |
| 32 self._suppressions = [] | |
| 33 for fname in supp_files: | |
| 34 self._suppressions.extend(suppressions.ReadSuppressionsFromFile(fname)) | |
| 35 if os.path.exists(self.TMP_FILE): | |
| 36 os.remove(self.TMP_FILE) | |
| 37 | |
| 38 def PutEnvAndLog(self, env_name, env_value): | |
| 39 """Sets the env var |env_name| to |env_value| and writes to logging.info. | |
| 40 """ | |
| 41 os.putenv(env_name, env_value) | |
| 42 logging.info('export %s=%s', env_name, env_value) | |
| 43 | |
| 44 def Execute(self): | |
| 45 """Executes the app to be tested.""" | |
| 46 logging.info('starting execution...') | |
| 47 proc = ['sh', path_utils.ScriptDir() + '/heapcheck_std.sh'] | |
| 48 proc += self._args | |
| 49 self.PutEnvAndLog('G_SLICE', 'always-malloc') | |
| 50 self.PutEnvAndLog('NSS_DISABLE_ARENA_FREE_LIST', '1') | |
| 51 self.PutEnvAndLog('NSS_DISABLE_UNLOAD', '1') | |
| 52 self.PutEnvAndLog('GTEST_DEATH_TEST_USE_FORK', '1') | |
| 53 self.PutEnvAndLog('HEAPCHECK', self._mode) | |
| 54 self.PutEnvAndLog('HEAP_CHECK_ERROR_EXIT_CODE', '0') | |
| 55 self.PutEnvAndLog('HEAP_CHECK_MAX_LEAKS', '-1') | |
| 56 self.PutEnvAndLog('KEEP_SHADOW_STACKS', '1') | |
| 57 self.PutEnvAndLog('PPROF_PATH', | |
| 58 path_utils.ScriptDir() + | |
| 59 '/../../third_party/tcmalloc/chromium/src/pprof') | |
| 60 self.PutEnvAndLog('LD_LIBRARY_PATH', | |
| 61 '/usr/lib/debug/:/usr/lib32/debug/') | |
| 62 # CHROME_DEVEL_SANDBOX causes problems with heapcheck | |
| 63 self.PutEnvAndLog('CHROME_DEVEL_SANDBOX', ''); | |
| 64 | |
| 65 return common.RunSubprocess(proc, self._timeout) | |
| 66 | |
| 67 def Analyze(self, log_lines, check_sanity=False): | |
| 68 """Analyzes the app's output and applies suppressions to the reports. | |
| 69 | |
| 70 Analyze() searches the logs for leak reports and tries to apply | |
| 71 suppressions to them. Unsuppressed reports and other log messages are | |
| 72 dumped as is. | |
| 73 | |
| 74 If |check_sanity| is True, the list of suppressed reports is searched for a | |
| 75 report starting with SANITY_TEST_SUPPRESSION. If there isn't one, Analyze | |
| 76 returns 2 regardless of the unsuppressed reports. | |
| 77 | |
| 78 Args: | |
| 79 log_lines: An iterator over the app's log lines. | |
| 80 check_sanity: A flag that determines whether we should check the tool's | |
| 81 sanity. | |
| 82 Returns: | |
| 83 2, if the sanity check fails, | |
| 84 1, if unsuppressed reports remain in the output and the sanity check | |
| 85 passes, | |
| 86 0, if all the errors are suppressed and the sanity check passes. | |
| 87 """ | |
| 88 return_code = 0 | |
| 89 # leak signature: [number of bytes, number of objects] | |
| 90 cur_leak_signature = None | |
| 91 cur_stack = [] | |
| 92 cur_report = [] | |
| 93 reported_hashes = {} | |
| 94 # Statistics grouped by suppression description: | |
| 95 # [hit count, bytes, objects]. | |
| 96 used_suppressions = {} | |
| 97 hooked_allocator_line_encountered = False | |
| 98 for line in log_lines: | |
| 99 line = line.rstrip() # remove the trailing \n | |
| 100 match = self.STACK_LINE_RE.match(line) | |
| 101 if match: | |
| 102 cur_stack.append(match.groups()[0]) | |
| 103 cur_report.append(line) | |
| 104 continue | |
| 105 else: | |
| 106 if cur_stack: | |
| 107 # Try to find the suppression that applies to the current leak stack. | |
| 108 description = '' | |
| 109 for supp in self._suppressions: | |
| 110 if supp.Match(cur_stack): | |
| 111 cur_stack = [] | |
| 112 description = supp.description | |
| 113 break | |
| 114 if cur_stack: | |
| 115 if not cur_leak_signature: | |
| 116 print 'Missing leak signature for the following stack: ' | |
| 117 for frame in cur_stack: | |
| 118 print ' ' + frame | |
| 119 print 'Aborting...' | |
| 120 return 3 | |
| 121 | |
| 122 # Drop boring callers from the stack to get less redundant info | |
| 123 # and fewer unique reports. | |
| 124 found_boring = False | |
| 125 for i in range(1, len(cur_stack)): | |
| 126 for j in self.BORING_CALLERS: | |
| 127 if re.match(j, cur_stack[i]): | |
| 128 cur_stack = cur_stack[:i] | |
| 129 cur_report = cur_report[:i] | |
| 130 found_boring = True | |
| 131 break | |
| 132 if found_boring: | |
| 133 break | |
| 134 | |
| 135 error_hash = hash("".join(cur_stack)) & 0xffffffffffffffff | |
| 136 if error_hash not in reported_hashes: | |
| 137 reported_hashes[error_hash] = 1 | |
| 138 # Print the report and set the return code to 1. | |
| 139 print ('Leak of %d bytes in %d objects allocated from:' | |
| 140 % tuple(cur_leak_signature)) | |
| 141 print '\n'.join(cur_report) | |
| 142 return_code = 1 | |
| 143 # Generate the suppression iff the stack contains more than one | |
| 144 # frame (otherwise it's likely to be broken) | |
| 145 if len(cur_stack) > 1 or found_boring: | |
| 146 print '\nSuppression (error hash=#%016X#):\n{' % (error_hash) | |
| 147 print ' <insert_a_suppression_name_here>' | |
| 148 print ' Heapcheck:Leak' | |
| 149 for frame in cur_stack: | |
| 150 print ' fun:' + frame | |
| 151 print '}\n\n' | |
| 152 else: | |
| 153 print ('This stack may be broken due to omitted frame pointers.' | |
| 154 ' It is not recommended to suppress it.\n') | |
| 155 else: | |
| 156 # Update the suppressions histogram. | |
| 157 if description in used_suppressions: | |
| 158 hits, bytes, objects = used_suppressions[description] | |
| 159 hits += 1 | |
| 160 bytes += cur_leak_signature[0] | |
| 161 objects += cur_leak_signature[1] | |
| 162 used_suppressions[description] = [hits, bytes, objects] | |
| 163 else: | |
| 164 used_suppressions[description] = [1] + cur_leak_signature | |
| 165 cur_stack = [] | |
| 166 cur_report = [] | |
| 167 cur_leak_signature = None | |
| 168 match = self.LEAK_REPORT_RE.match(line) | |
| 169 if match: | |
| 170 cur_leak_signature = map(int, match.groups()) | |
| 171 else: | |
| 172 match = self.HOOKED_ALLOCATOR_RE.match(line) | |
| 173 if match: | |
| 174 hooked_allocator_line_encountered = True | |
| 175 else: | |
| 176 print line | |
| 177 # Print the list of suppressions used. | |
| 178 is_sane = False | |
| 179 if used_suppressions: | |
| 180 print | |
| 181 print '-----------------------------------------------------' | |
| 182 print 'Suppressions used:' | |
| 183 print ' count bytes objects name' | |
| 184 histo = {} | |
| 185 for description in used_suppressions: | |
| 186 if description.startswith(HeapcheckWrapper.SANITY_TEST_SUPPRESSION): | |
| 187 is_sane = True | |
| 188 hits, bytes, objects = used_suppressions[description] | |
| 189 line = '%8d %8d %8d %s' % (hits, bytes, objects, description) | |
| 190 if hits in histo: | |
| 191 histo[hits].append(line) | |
| 192 else: | |
| 193 histo[hits] = [line] | |
| 194 keys = histo.keys() | |
| 195 keys.sort() | |
| 196 for count in keys: | |
| 197 for line in histo[count]: | |
| 198 print line | |
| 199 print '-----------------------------------------------------' | |
| 200 if hooked_allocator_line_encountered: | |
| 201 print ('WARNING: Workaround for http://crbug.com/132867 (tons of ' | |
| 202 '"Hooked allocator frame not found, returning empty trace") ' | |
| 203 'in effect.') | |
| 204 if check_sanity and not is_sane: | |
| 205 logging.error("Sanity check failed") | |
| 206 return 2 | |
| 207 else: | |
| 208 return return_code | |
| 209 | |
| 210 def RunTestsAndAnalyze(self, check_sanity): | |
| 211 exec_retcode = self.Execute() | |
| 212 log_file = file(self.TMP_FILE, 'r') | |
| 213 analyze_retcode = self.Analyze(log_file, check_sanity) | |
| 214 log_file.close() | |
| 215 | |
| 216 if analyze_retcode: | |
| 217 logging.error("Analyze failed.") | |
| 218 return analyze_retcode | |
| 219 | |
| 220 if exec_retcode: | |
| 221 logging.error("Test execution failed.") | |
| 222 return exec_retcode | |
| 223 else: | |
| 224 logging.info("Test execution completed successfully.") | |
| 225 | |
| 226 return 0 | |
| 227 | |
| 228 def Main(self, args, check_sanity=False): | |
| 229 self._args = args | |
| 230 start = datetime.datetime.now() | |
| 231 retcode = -1 | |
| 232 retcode = self.RunTestsAndAnalyze(check_sanity) | |
| 233 end = datetime.datetime.now() | |
| 234 seconds = (end - start).seconds | |
| 235 hours = seconds / 3600 | |
| 236 seconds %= 3600 | |
| 237 minutes = seconds / 60 | |
| 238 seconds %= 60 | |
| 239 logging.info('elapsed time: %02d:%02d:%02d', hours, minutes, seconds) | |
| 240 logging.info('For more information on the Heapcheck bot see ' | |
| 241 'http://dev.chromium.org/developers/how-tos/' | |
| 242 'using-the-heap-leak-checker') | |
| 243 return retcode | |
| 244 | |
| 245 | |
| 246 def RunTool(args, supp_files, module): | |
| 247 tool = HeapcheckWrapper(supp_files) | |
| 248 MODULES_TO_SANITY_CHECK = ["base"] | |
| 249 check_sanity = module in MODULES_TO_SANITY_CHECK | |
| 250 return tool.Main(args[1:], check_sanity) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 113193008:
Remove heapcheck support. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src