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 import logging 6 import platform 7 import os 8 import signal 9 import subprocess 10 import sys 11 import time 12 13 14 class NotImplementedError(Exception): 15 pass 16 17 18 class TimeoutError(Exception): 19 pass 20 21 22 def RunSubprocessInBackground(proc): 23 """Runs a subprocess in the background. Returns a handle to the process.""" 24 logging.info("running %s in the background" % " ".join(proc)) 25 return subprocess.Popen(proc) 26 27 28 def RunSubprocess(proc, timeout=0): 29 """ Runs a subprocess, until it finishes or |timeout| is exceeded and the 30 process is killed with taskkill. A |timeout| <= 0 means no timeout. 31 32 Args: 33 proc: list of process components (exe + args) 34 timeout: how long to wait before killing, <= 0 means wait forever 35 """ 36 37 logging.info("running %s, timeout %d sec" % (" ".join(proc), timeout)) 38 sys.stdout.flush() 39 sys.stderr.flush() 40 41 # Manually read and print out stdout and stderr. 42 # By default, the subprocess is supposed to inherit these from its parent, 43 # however when run under buildbot, it seems unable to read data from a 44 # grandchild process, so we have to read the child and print the data as if 45 # it came from us for buildbot to read it. We're not sure why this is 46 # necessary. 47 # TODO(erikkay): should we buffer stderr and stdout separately? 48 p = subprocess.Popen(proc, universal_newlines=True, 49 bufsize=0, # unbuffered 50 stdout=subprocess.PIPE, stderr=subprocess.STDOUT) 51 52 logging.info("started subprocess") 53 54 did_timeout = False 55 if timeout > 0: 56 wait_until = time.time() + timeout 57 while p.poll() is None and not did_timeout: 58 # Have to use readline rather than readlines() or "for line in p.stdout:", 59 # otherwise we get buffered even with bufsize=0. 60 line = p.stdout.readline() 61 while line and not did_timeout: 62 sys.stdout.write(line) 63 sys.stdout.flush() 64 line = p.stdout.readline() 65 if timeout > 0: 66 did_timeout = time.time() > wait_until 67 68 if did_timeout: 69 logging.info("process timed out") 70 else: 71 logging.info("process ended, did not time out") 72 73 if did_timeout: 74 if IsWindows(): 75 subprocess.call(["taskkill", "/T", "/F", "/PID", str(p.pid)]) 76 else: 77 # Does this kill all children, too? 78 os.kill(p.pid, signal.SIGINT) 79 logging.error("KILLED %d" % p.pid) 80 # Give the process a chance to actually die before continuing 81 # so that cleanup can happen safely. 82 time.sleep(1.0) 83 logging.error("TIMEOUT waiting for %s" % proc[0]) 84 raise TimeoutError(proc[0]) 85 else: 86 for line in p.stdout: 87 sys.stdout.write(line) 88 if not IsMac(): # stdout flush fails on Mac 89 logging.info("flushing stdout") 90 sys.stdout.flush() 91 92 logging.info("collecting result code") 93 result = p.poll() 94 if result: 95 logging.error("%s exited with non-zero result code %d" % (proc[0], result)) 96 return result 97 98 99 def IsLinux(): 100 return sys.platform.startswith('linux') 101 102 103 def IsMac(): 104 return sys.platform.startswith('darwin') 105 106 107 def IsWindows(): 108 return sys.platform == 'cygwin' or sys.platform.startswith('win') 109 110 111 def WindowsVersionName(): 112 """Returns the name of the Windows version if it is known, or None. 113 114 Possible return values are: xp, vista, 7, 8, or None 115 """ 116 if sys.platform == 'cygwin': 117 # Windows version number is hiding in system name. Looks like: 118 # CYGWIN_NT-6.1-WOW64 119 try: 120 version_str = platform.uname()[0].split('-')[1] 121 except: 122 return None 123 elif sys.platform.startswith('win'): 124 # Normal Windows version string. Mine: 6.1.7601 125 version_str = platform.version() 126 else: 127 return None 128 129 parts = version_str.split('.') 130 try: 131 major = int(parts[0]) 132 minor = int(parts[1]) 133 except: 134 return None # Can't parse, unknown version. 135 136 if major == 5: 137 return 'xp' 138 elif major == 6 and minor == 0: 139 return 'vista' 140 elif major == 6 and minor == 1: 141 return '7' 142 elif major == 6 and minor == 2: 143 return '8' # Future proof. ;) 144 return None 145 146 147 def PlatformNames(): 148 """Return an array of string to be used in paths for the platform 149 (e.g. suppressions, gtest filters, ignore files etc.) 150 The first element of the array describes the 'main' platform 151 """ 152 if IsLinux(): 153 return ['linux'] 154 if IsMac(): 155 return ['mac'] 156 if IsWindows(): 157 names = ['win32'] 158 version_name = WindowsVersionName() 159 if version_name is not None: 160 names.append('win-%s' % version_name) 161 return names 162 raise NotImplementedError('Unknown platform "%s".' % sys.platform) 163 164 165 def PutEnvAndLog(env_name, env_value): 166 os.putenv(env_name, env_value) 167 logging.info('export %s=%s', env_name, env_value) 168 169 def BoringCallers(mangled, use_re_wildcards): 170 """Return a list of 'boring' function names (optinally mangled) 171 with */? wildcards (optionally .*/.). 172 Boring = we drop off the bottom of stack traces below such functions. 173 """ 174 175 need_mangling = [ 176 # Don't show our testing framework: 177 ("testing::Test::Run", "_ZN7testing4Test3RunEv"), 178 ("testing::TestInfo::Run", "_ZN7testing8TestInfo3RunEv"), 179 ("testing::internal::Handle*ExceptionsInMethodIfSupported*", 180 "_ZN7testing8internal3?Handle*ExceptionsInMethodIfSupported*"), 181 182 # Depend on scheduling: 183 ("MessageLoop::Run", "_ZN11MessageLoop3RunEv"), 184 ("MessageLoop::RunTask", "_ZN11MessageLoop7RunTask*"), 185 ("RunnableMethod*", "_ZN14RunnableMethod*"), 186 ("DispatchToMethod*", "_Z*16DispatchToMethod*"), 187 ("base::internal::Invoker*::DoInvoke*", 188 "_ZN4base8internal8Invoker*DoInvoke*"), # Invoker{1,2,3} 189 ("base::internal::RunnableAdapter*::Run*", 190 "_ZN4base8internal15RunnableAdapter*Run*"), 191 ] 192 193 ret = [] 194 for pair in need_mangling: 195 ret.append(pair[1 if mangled else 0]) 196 197 ret += [ 198 # Also don't show the internals of libc/pthread. 199 "start_thread", 200 "main", 201 "BaseThreadInitThunk", 202 ] 203 204 if use_re_wildcards: 205 for i in range(0, len(ret)): 206 ret[i] = ret[i].replace('*', '.*').replace('?', '.') 207 208 return ret 209 210 def NormalizeWindowsPath(path): 211 """If we're using Cygwin Python, turn the path into a Windows path. 212 213 Don't turn forward slashes into backslashes for easier copy-pasting and 214 escaping. 215 216 TODO(rnk): If we ever want to cut out the subprocess invocation, we can use 217 _winreg to get the root Cygwin directory from the registry key: 218 HKEY_LOCAL_MACHINE\SOFTWARE\Cygwin\setup\rootdir. 219 """ 220 if sys.platform.startswith("cygwin"): 221 p = subprocess.Popen(["cygpath", "-m", path], 222 stdout=subprocess.PIPE, 223 stderr=subprocess.PIPE) 224 (out, err) = p.communicate() 225 if err: 226 logging.warning("WARNING: cygpath error: %s", err) 227 return out.strip() 228 else: 229 return path 230 231 ############################ 232 # Common output format code 233 234 def PrintUsedSuppressionsList(suppcounts): 235 """ Prints out the list of used suppressions in a format common to all the 236 memory tools. If the list is empty, prints nothing and returns False, 237 otherwise True. 238 239 suppcounts: a dictionary of used suppression counts, 240 Key -> name, Value -> count. 241 """ 242 if not suppcounts: 243 return False 244 245 print "-----------------------------------------------------" 246 print "Suppressions used:" 247 print " count name" 248 for (name, count) in sorted(suppcounts.items(), key=lambda (k,v): (v,k)): 249 print "%7d %s" % (count, name) 250 print "-----------------------------------------------------" 251 sys.stdout.flush() 252 return True 253
