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) 251
