1#!/usr/bin/env python3 2# SPDX-License-Identifier: GPL-2.0-only 3# 4# Tool for analyzing suspend/resume timing 5# Copyright (c) 2013, Intel Corporation. 6# 7# This program is free software; you can redistribute it and/or modify it 8# under the terms and conditions of the GNU General Public License, 9# version 2, as published by the Free Software Foundation. 10# 11# This program is distributed in the hope it will be useful, but WITHOUT 12# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14# more details. 15# 16# Authors: 17# Todd Brandt <todd.e.brandt@linux.intel.com> 18# 19# Links: 20# Home Page 21# https://01.org/pm-graph 22# Source repo 23# git@github.com:intel/pm-graph 24# 25# Description: 26# This tool is designed to assist kernel and OS developers in optimizing 27# their linux stack's suspend/resume time. Using a kernel image built 28# with a few extra options enabled, the tool will execute a suspend and 29# will capture dmesg and ftrace data until resume is complete. This data 30# is transformed into a device timeline and a callgraph to give a quick 31# and detailed view of which devices and callbacks are taking the most 32# time in suspend/resume. The output is a single html file which can be 33# viewed in firefox or chrome. 34# 35# The following kernel build options are required: 36# CONFIG_DEVMEM=y 37# CONFIG_PM_DEBUG=y 38# CONFIG_PM_SLEEP_DEBUG=y 39# CONFIG_FTRACE=y 40# CONFIG_FUNCTION_TRACER=y 41# CONFIG_FUNCTION_GRAPH_TRACER=y 42# CONFIG_KPROBES=y 43# CONFIG_KPROBES_ON_FTRACE=y 44# 45# For kernel versions older than 3.15: 46# The following additional kernel parameters are required: 47# (e.g. in file /etc/default/grub) 48# GRUB_CMDLINE_LINUX_DEFAULT="... initcall_debug log_buf_len=16M ..." 49# 50 51# ----------------- LIBRARIES -------------------- 52 53import sys 54import time 55import os 56import string 57import re 58import platform 59import signal 60import codecs 61from datetime import datetime, timedelta 62import struct 63import configparser 64import gzip 65from threading import Thread 66from subprocess import call, Popen, PIPE 67import base64 68 69def pprint(msg): 70 print(msg) 71 sys.stdout.flush() 72 73def ascii(text): 74 return text.decode('ascii', 'ignore') 75 76# ----------------- CLASSES -------------------- 77 78# Class: SystemValues 79# Description: 80# A global, single-instance container used to 81# store system values and test parameters 82class SystemValues: 83 title = 'SleepGraph' 84 version = '5.7' 85 ansi = False 86 rs = 0 87 display = '' 88 gzip = False 89 sync = False 90 wifi = False 91 verbose = False 92 testlog = True 93 dmesglog = True 94 ftracelog = False 95 tstat = True 96 mindevlen = 0.0 97 mincglen = 0.0 98 cgphase = '' 99 cgtest = -1 100 cgskip = '' 101 maxfail = 0 102 multitest = {'run': False, 'count': 1000000, 'delay': 0} 103 max_graph_depth = 0 104 callloopmaxgap = 0.0001 105 callloopmaxlen = 0.005 106 bufsize = 0 107 cpucount = 0 108 memtotal = 204800 109 memfree = 204800 110 srgap = 0 111 cgexp = False 112 testdir = '' 113 outdir = '' 114 tpath = '/sys/kernel/debug/tracing/' 115 fpdtpath = '/sys/firmware/acpi/tables/FPDT' 116 epath = '/sys/kernel/debug/tracing/events/power/' 117 pmdpath = '/sys/power/pm_debug_messages' 118 traceevents = [ 119 'suspend_resume', 120 'wakeup_source_activate', 121 'wakeup_source_deactivate', 122 'device_pm_callback_end', 123 'device_pm_callback_start' 124 ] 125 logmsg = '' 126 testcommand = '' 127 mempath = '/dev/mem' 128 powerfile = '/sys/power/state' 129 mempowerfile = '/sys/power/mem_sleep' 130 diskpowerfile = '/sys/power/disk' 131 suspendmode = 'mem' 132 memmode = '' 133 diskmode = '' 134 hostname = 'localhost' 135 prefix = 'test' 136 teststamp = '' 137 sysstamp = '' 138 dmesgstart = 0.0 139 dmesgfile = '' 140 ftracefile = '' 141 htmlfile = 'output.html' 142 result = '' 143 rtcwake = True 144 rtcwaketime = 15 145 rtcpath = '' 146 devicefilter = [] 147 cgfilter = [] 148 stamp = 0 149 execcount = 1 150 x2delay = 0 151 skiphtml = False 152 usecallgraph = False 153 ftopfunc = 'pm_suspend' 154 ftop = False 155 usetraceevents = False 156 usetracemarkers = True 157 usekprobes = True 158 usedevsrc = False 159 useprocmon = False 160 notestrun = False 161 cgdump = False 162 devdump = False 163 mixedphaseheight = True 164 devprops = dict() 165 platinfo = [] 166 predelay = 0 167 postdelay = 0 168 pmdebug = '' 169 tmstart = 'SUSPEND START %Y%m%d-%H:%M:%S.%f' 170 tmend = 'RESUME COMPLETE %Y%m%d-%H:%M:%S.%f' 171 tracefuncs = { 172 'sys_sync': {}, 173 'ksys_sync': {}, 174 'pm_notifier_call_chain_robust': {}, 175 'pm_prepare_console': {}, 176 'pm_notifier_call_chain': {}, 177 'freeze_processes': {}, 178 'freeze_kernel_threads': {}, 179 'pm_restrict_gfp_mask': {}, 180 'acpi_suspend_begin': {}, 181 'acpi_hibernation_begin': {}, 182 'acpi_hibernation_enter': {}, 183 'acpi_hibernation_leave': {}, 184 'acpi_pm_freeze': {}, 185 'acpi_pm_thaw': {}, 186 'acpi_s2idle_end': {}, 187 'acpi_s2idle_sync': {}, 188 'acpi_s2idle_begin': {}, 189 'acpi_s2idle_prepare': {}, 190 'acpi_s2idle_prepare_late': {}, 191 'acpi_s2idle_wake': {}, 192 'acpi_s2idle_wakeup': {}, 193 'acpi_s2idle_restore': {}, 194 'acpi_s2idle_restore_early': {}, 195 'hibernate_preallocate_memory': {}, 196 'create_basic_memory_bitmaps': {}, 197 'swsusp_write': {}, 198 'suspend_console': {}, 199 'acpi_pm_prepare': {}, 200 'syscore_suspend': {}, 201 'arch_enable_nonboot_cpus_end': {}, 202 'syscore_resume': {}, 203 'acpi_pm_finish': {}, 204 'resume_console': {}, 205 'acpi_pm_end': {}, 206 'pm_restore_gfp_mask': {}, 207 'thaw_processes': {}, 208 'pm_restore_console': {}, 209 'CPU_OFF': { 210 'func':'_cpu_down', 211 'args_x86_64': {'cpu':'%di:s32'}, 212 'format': 'CPU_OFF[{cpu}]' 213 }, 214 'CPU_ON': { 215 'func':'_cpu_up', 216 'args_x86_64': {'cpu':'%di:s32'}, 217 'format': 'CPU_ON[{cpu}]' 218 }, 219 } 220 dev_tracefuncs = { 221 # general wait/delay/sleep 222 'msleep': { 'args_x86_64': {'time':'%di:s32'}, 'ub': 1 }, 223 'schedule_timeout': { 'args_x86_64': {'timeout':'%di:s32'}, 'ub': 1 }, 224 'udelay': { 'func':'__const_udelay', 'args_x86_64': {'loops':'%di:s32'}, 'ub': 1 }, 225 'usleep_range': { 'args_x86_64': {'min':'%di:s32', 'max':'%si:s32'}, 'ub': 1 }, 226 'mutex_lock_slowpath': { 'func':'__mutex_lock_slowpath', 'ub': 1 }, 227 'acpi_os_stall': {'ub': 1}, 228 'rt_mutex_slowlock': {'ub': 1}, 229 # ACPI 230 'acpi_resume_power_resources': {}, 231 'acpi_ps_execute_method': { 'args_x86_64': { 232 'fullpath':'+0(+40(%di)):string', 233 }}, 234 # mei_me 235 'mei_reset': {}, 236 # filesystem 237 'ext4_sync_fs': {}, 238 # 80211 239 'ath10k_bmi_read_memory': { 'args_x86_64': {'length':'%cx:s32'} }, 240 'ath10k_bmi_write_memory': { 'args_x86_64': {'length':'%cx:s32'} }, 241 'ath10k_bmi_fast_download': { 'args_x86_64': {'length':'%cx:s32'} }, 242 'iwlagn_mac_start': {}, 243 'iwlagn_alloc_bcast_station': {}, 244 'iwl_trans_pcie_start_hw': {}, 245 'iwl_trans_pcie_start_fw': {}, 246 'iwl_run_init_ucode': {}, 247 'iwl_load_ucode_wait_alive': {}, 248 'iwl_alive_start': {}, 249 'iwlagn_mac_stop': {}, 250 'iwlagn_mac_suspend': {}, 251 'iwlagn_mac_resume': {}, 252 'iwlagn_mac_add_interface': {}, 253 'iwlagn_mac_remove_interface': {}, 254 'iwlagn_mac_change_interface': {}, 255 'iwlagn_mac_config': {}, 256 'iwlagn_configure_filter': {}, 257 'iwlagn_mac_hw_scan': {}, 258 'iwlagn_bss_info_changed': {}, 259 'iwlagn_mac_channel_switch': {}, 260 'iwlagn_mac_flush': {}, 261 # ATA 262 'ata_eh_recover': { 'args_x86_64': {'port':'+36(%di):s32'} }, 263 # i915 264 'i915_gem_resume': {}, 265 'i915_restore_state': {}, 266 'intel_opregion_setup': {}, 267 'g4x_pre_enable_dp': {}, 268 'vlv_pre_enable_dp': {}, 269 'chv_pre_enable_dp': {}, 270 'g4x_enable_dp': {}, 271 'vlv_enable_dp': {}, 272 'intel_hpd_init': {}, 273 'intel_opregion_register': {}, 274 'intel_dp_detect': {}, 275 'intel_hdmi_detect': {}, 276 'intel_opregion_init': {}, 277 'intel_fbdev_set_suspend': {}, 278 } 279 infocmds = [ 280 [0, 'kparams', 'cat', '/proc/cmdline'], 281 [0, 'mcelog', 'mcelog'], 282 [0, 'pcidevices', 'lspci', '-tv'], 283 [0, 'usbdevices', 'lsusb', '-t'], 284 [1, 'interrupts', 'cat', '/proc/interrupts'], 285 [1, 'wakeups', 'cat', '/sys/kernel/debug/wakeup_sources'], 286 [2, 'gpecounts', 'sh', '-c', 'grep -v invalid /sys/firmware/acpi/interrupts/*'], 287 [2, 'suspendstats', 'sh', '-c', 'grep -v invalid /sys/power/suspend_stats/*'], 288 [2, 'cpuidle', 'sh', '-c', 'grep -v invalid /sys/devices/system/cpu/cpu*/cpuidle/state*/s2idle/*'], 289 [2, 'battery', 'sh', '-c', 'grep -v invalid /sys/class/power_supply/*/*'], 290 ] 291 cgblacklist = [] 292 kprobes = dict() 293 timeformat = '%.3f' 294 cmdline = '%s %s' % \ 295 (os.path.basename(sys.argv[0]), ' '.join(sys.argv[1:])) 296 sudouser = '' 297 def __init__(self): 298 self.archargs = 'args_'+platform.machine() 299 self.hostname = platform.node() 300 if(self.hostname == ''): 301 self.hostname = 'localhost' 302 rtc = "rtc0" 303 if os.path.exists('/dev/rtc'): 304 rtc = os.readlink('/dev/rtc') 305 rtc = '/sys/class/rtc/'+rtc 306 if os.path.exists(rtc) and os.path.exists(rtc+'/date') and \ 307 os.path.exists(rtc+'/time') and os.path.exists(rtc+'/wakealarm'): 308 self.rtcpath = rtc 309 if (hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()): 310 self.ansi = True 311 self.testdir = datetime.now().strftime('suspend-%y%m%d-%H%M%S') 312 if os.getuid() == 0 and 'SUDO_USER' in os.environ and \ 313 os.environ['SUDO_USER']: 314 self.sudouser = os.environ['SUDO_USER'] 315 def resetlog(self): 316 self.logmsg = '' 317 self.platinfo = [] 318 def vprint(self, msg): 319 self.logmsg += msg+'\n' 320 if self.verbose or msg.startswith('WARNING:'): 321 pprint(msg) 322 def signalHandler(self, signum, frame): 323 if not self.result: 324 return 325 signame = self.signames[signum] if signum in self.signames else 'UNKNOWN' 326 msg = 'Signal %s caused a tool exit, line %d' % (signame, frame.f_lineno) 327 self.outputResult({'error':msg}) 328 sys.exit(3) 329 def signalHandlerInit(self): 330 capture = ['BUS', 'SYS', 'XCPU', 'XFSZ', 'PWR', 'HUP', 'INT', 'QUIT', 331 'ILL', 'ABRT', 'FPE', 'SEGV', 'TERM'] 332 self.signames = dict() 333 for i in capture: 334 s = 'SIG'+i 335 try: 336 signum = getattr(signal, s) 337 signal.signal(signum, self.signalHandler) 338 except: 339 continue 340 self.signames[signum] = s 341 def rootCheck(self, fatal=True): 342 if(os.access(self.powerfile, os.W_OK)): 343 return True 344 if fatal: 345 msg = 'This command requires sysfs mount and root access' 346 pprint('ERROR: %s\n' % msg) 347 self.outputResult({'error':msg}) 348 sys.exit(1) 349 return False 350 def rootUser(self, fatal=False): 351 if 'USER' in os.environ and os.environ['USER'] == 'root': 352 return True 353 if fatal: 354 msg = 'This command must be run as root' 355 pprint('ERROR: %s\n' % msg) 356 self.outputResult({'error':msg}) 357 sys.exit(1) 358 return False 359 def usable(self, file): 360 return (os.path.exists(file) and os.path.getsize(file) > 0) 361 def getExec(self, cmd): 362 try: 363 fp = Popen(['which', cmd], stdout=PIPE, stderr=PIPE).stdout 364 out = ascii(fp.read()).strip() 365 fp.close() 366 except: 367 out = '' 368 if out: 369 return out 370 for path in ['/sbin', '/bin', '/usr/sbin', '/usr/bin', 371 '/usr/local/sbin', '/usr/local/bin']: 372 cmdfull = os.path.join(path, cmd) 373 if os.path.exists(cmdfull): 374 return cmdfull 375 return out 376 def setPrecision(self, num): 377 if num < 0 or num > 6: 378 return 379 self.timeformat = '%.{0}f'.format(num) 380 def setOutputFolder(self, value): 381 args = dict() 382 n = datetime.now() 383 args['date'] = n.strftime('%y%m%d') 384 args['time'] = n.strftime('%H%M%S') 385 args['hostname'] = args['host'] = self.hostname 386 args['mode'] = self.suspendmode 387 return value.format(**args) 388 def setOutputFile(self): 389 if self.dmesgfile != '': 390 m = re.match('(?P<name>.*)_dmesg\.txt.*', self.dmesgfile) 391 if(m): 392 self.htmlfile = m.group('name')+'.html' 393 if self.ftracefile != '': 394 m = re.match('(?P<name>.*)_ftrace\.txt.*', self.ftracefile) 395 if(m): 396 self.htmlfile = m.group('name')+'.html' 397 def systemInfo(self, info): 398 p = m = '' 399 if 'baseboard-manufacturer' in info: 400 m = info['baseboard-manufacturer'] 401 elif 'system-manufacturer' in info: 402 m = info['system-manufacturer'] 403 if 'system-product-name' in info: 404 p = info['system-product-name'] 405 elif 'baseboard-product-name' in info: 406 p = info['baseboard-product-name'] 407 if m[:5].lower() == 'intel' and 'baseboard-product-name' in info: 408 p = info['baseboard-product-name'] 409 c = info['processor-version'] if 'processor-version' in info else '' 410 b = info['bios-version'] if 'bios-version' in info else '' 411 r = info['bios-release-date'] if 'bios-release-date' in info else '' 412 self.sysstamp = '# sysinfo | man:%s | plat:%s | cpu:%s | bios:%s | biosdate:%s | numcpu:%d | memsz:%d | memfr:%d' % \ 413 (m, p, c, b, r, self.cpucount, self.memtotal, self.memfree) 414 def printSystemInfo(self, fatal=False): 415 self.rootCheck(True) 416 out = dmidecode(self.mempath, fatal) 417 if len(out) < 1: 418 return 419 fmt = '%-24s: %s' 420 for name in sorted(out): 421 print(fmt % (name, out[name])) 422 print(fmt % ('cpucount', ('%d' % self.cpucount))) 423 print(fmt % ('memtotal', ('%d kB' % self.memtotal))) 424 print(fmt % ('memfree', ('%d kB' % self.memfree))) 425 def cpuInfo(self): 426 self.cpucount = 0 427 fp = open('/proc/cpuinfo', 'r') 428 for line in fp: 429 if re.match('^processor[ \t]*:[ \t]*[0-9]*', line): 430 self.cpucount += 1 431 fp.close() 432 fp = open('/proc/meminfo', 'r') 433 for line in fp: 434 m = re.match('^MemTotal:[ \t]*(?P<sz>[0-9]*) *kB', line) 435 if m: 436 self.memtotal = int(m.group('sz')) 437 m = re.match('^MemFree:[ \t]*(?P<sz>[0-9]*) *kB', line) 438 if m: 439 self.memfree = int(m.group('sz')) 440 fp.close() 441 def initTestOutput(self, name): 442 self.prefix = self.hostname 443 v = open('/proc/version', 'r').read().strip() 444 kver = v.split()[2] 445 fmt = name+'-%m%d%y-%H%M%S' 446 testtime = datetime.now().strftime(fmt) 447 self.teststamp = \ 448 '# '+testtime+' '+self.prefix+' '+self.suspendmode+' '+kver 449 ext = '' 450 if self.gzip: 451 ext = '.gz' 452 self.dmesgfile = \ 453 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_dmesg.txt'+ext 454 self.ftracefile = \ 455 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_ftrace.txt'+ext 456 self.htmlfile = \ 457 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'.html' 458 if not os.path.isdir(self.testdir): 459 os.makedirs(self.testdir) 460 self.sudoUserchown(self.testdir) 461 def getValueList(self, value): 462 out = [] 463 for i in value.split(','): 464 if i.strip(): 465 out.append(i.strip()) 466 return out 467 def setDeviceFilter(self, value): 468 self.devicefilter = self.getValueList(value) 469 def setCallgraphFilter(self, value): 470 self.cgfilter = self.getValueList(value) 471 def skipKprobes(self, value): 472 for k in self.getValueList(value): 473 if k in self.tracefuncs: 474 del self.tracefuncs[k] 475 if k in self.dev_tracefuncs: 476 del self.dev_tracefuncs[k] 477 def setCallgraphBlacklist(self, file): 478 self.cgblacklist = self.listFromFile(file) 479 def rtcWakeAlarmOn(self): 480 call('echo 0 > '+self.rtcpath+'/wakealarm', shell=True) 481 nowtime = open(self.rtcpath+'/since_epoch', 'r').read().strip() 482 if nowtime: 483 nowtime = int(nowtime) 484 else: 485 # if hardware time fails, use the software time 486 nowtime = int(datetime.now().strftime('%s')) 487 alarm = nowtime + self.rtcwaketime 488 call('echo %d > %s/wakealarm' % (alarm, self.rtcpath), shell=True) 489 def rtcWakeAlarmOff(self): 490 call('echo 0 > %s/wakealarm' % self.rtcpath, shell=True) 491 def initdmesg(self): 492 # get the latest time stamp from the dmesg log 493 fp = Popen('dmesg', stdout=PIPE).stdout 494 ktime = '0' 495 for line in fp: 496 line = ascii(line).replace('\r\n', '') 497 idx = line.find('[') 498 if idx > 1: 499 line = line[idx:] 500 m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line) 501 if(m): 502 ktime = m.group('ktime') 503 fp.close() 504 self.dmesgstart = float(ktime) 505 def getdmesg(self, testdata): 506 op = self.writeDatafileHeader(self.dmesgfile, testdata) 507 # store all new dmesg lines since initdmesg was called 508 fp = Popen('dmesg', stdout=PIPE).stdout 509 for line in fp: 510 line = ascii(line).replace('\r\n', '') 511 idx = line.find('[') 512 if idx > 1: 513 line = line[idx:] 514 m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line) 515 if(not m): 516 continue 517 ktime = float(m.group('ktime')) 518 if ktime > self.dmesgstart: 519 op.write(line) 520 fp.close() 521 op.close() 522 def listFromFile(self, file): 523 list = [] 524 fp = open(file) 525 for i in fp.read().split('\n'): 526 i = i.strip() 527 if i and i[0] != '#': 528 list.append(i) 529 fp.close() 530 return list 531 def addFtraceFilterFunctions(self, file): 532 for i in self.listFromFile(file): 533 if len(i) < 2: 534 continue 535 self.tracefuncs[i] = dict() 536 def getFtraceFilterFunctions(self, current): 537 self.rootCheck(True) 538 if not current: 539 call('cat '+self.tpath+'available_filter_functions', shell=True) 540 return 541 master = self.listFromFile(self.tpath+'available_filter_functions') 542 for i in sorted(self.tracefuncs): 543 if 'func' in self.tracefuncs[i]: 544 i = self.tracefuncs[i]['func'] 545 if i in master: 546 print(i) 547 else: 548 print(self.colorText(i)) 549 def setFtraceFilterFunctions(self, list): 550 master = self.listFromFile(self.tpath+'available_filter_functions') 551 flist = '' 552 for i in list: 553 if i not in master: 554 continue 555 if ' [' in i: 556 flist += i.split(' ')[0]+'\n' 557 else: 558 flist += i+'\n' 559 fp = open(self.tpath+'set_graph_function', 'w') 560 fp.write(flist) 561 fp.close() 562 def basicKprobe(self, name): 563 self.kprobes[name] = {'name': name,'func': name,'args': dict(),'format': name} 564 def defaultKprobe(self, name, kdata): 565 k = kdata 566 for field in ['name', 'format', 'func']: 567 if field not in k: 568 k[field] = name 569 if self.archargs in k: 570 k['args'] = k[self.archargs] 571 else: 572 k['args'] = dict() 573 k['format'] = name 574 self.kprobes[name] = k 575 def kprobeColor(self, name): 576 if name not in self.kprobes or 'color' not in self.kprobes[name]: 577 return '' 578 return self.kprobes[name]['color'] 579 def kprobeDisplayName(self, name, dataraw): 580 if name not in self.kprobes: 581 self.basicKprobe(name) 582 data = '' 583 quote=0 584 # first remvoe any spaces inside quotes, and the quotes 585 for c in dataraw: 586 if c == '"': 587 quote = (quote + 1) % 2 588 if quote and c == ' ': 589 data += '_' 590 elif c != '"': 591 data += c 592 fmt, args = self.kprobes[name]['format'], self.kprobes[name]['args'] 593 arglist = dict() 594 # now process the args 595 for arg in sorted(args): 596 arglist[arg] = '' 597 m = re.match('.* '+arg+'=(?P<arg>.*) ', data); 598 if m: 599 arglist[arg] = m.group('arg') 600 else: 601 m = re.match('.* '+arg+'=(?P<arg>.*)', data); 602 if m: 603 arglist[arg] = m.group('arg') 604 out = fmt.format(**arglist) 605 out = out.replace(' ', '_').replace('"', '') 606 return out 607 def kprobeText(self, kname, kprobe): 608 name = fmt = func = kname 609 args = dict() 610 if 'name' in kprobe: 611 name = kprobe['name'] 612 if 'format' in kprobe: 613 fmt = kprobe['format'] 614 if 'func' in kprobe: 615 func = kprobe['func'] 616 if self.archargs in kprobe: 617 args = kprobe[self.archargs] 618 if 'args' in kprobe: 619 args = kprobe['args'] 620 if re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', func): 621 doError('Kprobe "%s" has format info in the function name "%s"' % (name, func)) 622 for arg in re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', fmt): 623 if arg not in args: 624 doError('Kprobe "%s" is missing argument "%s"' % (name, arg)) 625 val = 'p:%s_cal %s' % (name, func) 626 for i in sorted(args): 627 val += ' %s=%s' % (i, args[i]) 628 val += '\nr:%s_ret %s $retval\n' % (name, func) 629 return val 630 def addKprobes(self, output=False): 631 if len(self.kprobes) < 1: 632 return 633 if output: 634 pprint(' kprobe functions in this kernel:') 635 # first test each kprobe 636 rejects = [] 637 # sort kprobes: trace, ub-dev, custom, dev 638 kpl = [[], [], [], []] 639 linesout = len(self.kprobes) 640 for name in sorted(self.kprobes): 641 res = self.colorText('YES', 32) 642 if not self.testKprobe(name, self.kprobes[name]): 643 res = self.colorText('NO') 644 rejects.append(name) 645 else: 646 if name in self.tracefuncs: 647 kpl[0].append(name) 648 elif name in self.dev_tracefuncs: 649 if 'ub' in self.dev_tracefuncs[name]: 650 kpl[1].append(name) 651 else: 652 kpl[3].append(name) 653 else: 654 kpl[2].append(name) 655 if output: 656 pprint(' %s: %s' % (name, res)) 657 kplist = kpl[0] + kpl[1] + kpl[2] + kpl[3] 658 # remove all failed ones from the list 659 for name in rejects: 660 self.kprobes.pop(name) 661 # set the kprobes all at once 662 self.fsetVal('', 'kprobe_events') 663 kprobeevents = '' 664 for kp in kplist: 665 kprobeevents += self.kprobeText(kp, self.kprobes[kp]) 666 self.fsetVal(kprobeevents, 'kprobe_events') 667 if output: 668 check = self.fgetVal('kprobe_events') 669 linesack = (len(check.split('\n')) - 1) // 2 670 pprint(' kprobe functions enabled: %d/%d' % (linesack, linesout)) 671 self.fsetVal('1', 'events/kprobes/enable') 672 def testKprobe(self, kname, kprobe): 673 self.fsetVal('0', 'events/kprobes/enable') 674 kprobeevents = self.kprobeText(kname, kprobe) 675 if not kprobeevents: 676 return False 677 try: 678 self.fsetVal(kprobeevents, 'kprobe_events') 679 check = self.fgetVal('kprobe_events') 680 except: 681 return False 682 linesout = len(kprobeevents.split('\n')) 683 linesack = len(check.split('\n')) 684 if linesack < linesout: 685 return False 686 return True 687 def setVal(self, val, file): 688 if not os.path.exists(file): 689 return False 690 try: 691 fp = open(file, 'wb', 0) 692 fp.write(val.encode()) 693 fp.flush() 694 fp.close() 695 except: 696 return False 697 return True 698 def fsetVal(self, val, path): 699 return self.setVal(val, self.tpath+path) 700 def getVal(self, file): 701 res = '' 702 if not os.path.exists(file): 703 return res 704 try: 705 fp = open(file, 'r') 706 res = fp.read() 707 fp.close() 708 except: 709 pass 710 return res 711 def fgetVal(self, path): 712 return self.getVal(self.tpath+path) 713 def cleanupFtrace(self): 714 if(self.usecallgraph or self.usetraceevents or self.usedevsrc): 715 self.fsetVal('0', 'events/kprobes/enable') 716 self.fsetVal('', 'kprobe_events') 717 self.fsetVal('1024', 'buffer_size_kb') 718 if self.pmdebug: 719 self.setVal(self.pmdebug, self.pmdpath) 720 def setupAllKprobes(self): 721 for name in self.tracefuncs: 722 self.defaultKprobe(name, self.tracefuncs[name]) 723 for name in self.dev_tracefuncs: 724 self.defaultKprobe(name, self.dev_tracefuncs[name]) 725 def isCallgraphFunc(self, name): 726 if len(self.tracefuncs) < 1 and self.suspendmode == 'command': 727 return True 728 for i in self.tracefuncs: 729 if 'func' in self.tracefuncs[i]: 730 f = self.tracefuncs[i]['func'] 731 else: 732 f = i 733 if name == f: 734 return True 735 return False 736 def initFtrace(self, quiet=False): 737 if not quiet: 738 sysvals.printSystemInfo(False) 739 pprint('INITIALIZING FTRACE...') 740 # turn trace off 741 self.fsetVal('0', 'tracing_on') 742 self.cleanupFtrace() 743 # pm debug messages 744 pv = self.getVal(self.pmdpath) 745 if pv != '1': 746 self.setVal('1', self.pmdpath) 747 self.pmdebug = pv 748 # set the trace clock to global 749 self.fsetVal('global', 'trace_clock') 750 self.fsetVal('nop', 'current_tracer') 751 # set trace buffer to an appropriate value 752 cpus = max(1, self.cpucount) 753 if self.bufsize > 0: 754 tgtsize = self.bufsize 755 elif self.usecallgraph or self.usedevsrc: 756 bmax = (1*1024*1024) if self.suspendmode in ['disk', 'command'] \ 757 else (3*1024*1024) 758 tgtsize = min(self.memfree, bmax) 759 else: 760 tgtsize = 65536 761 while not self.fsetVal('%d' % (tgtsize // cpus), 'buffer_size_kb'): 762 # if the size failed to set, lower it and keep trying 763 tgtsize -= 65536 764 if tgtsize < 65536: 765 tgtsize = int(self.fgetVal('buffer_size_kb')) * cpus 766 break 767 self.vprint('Setting trace buffers to %d kB (%d kB per cpu)' % (tgtsize, tgtsize/cpus)) 768 # initialize the callgraph trace 769 if(self.usecallgraph): 770 # set trace type 771 self.fsetVal('function_graph', 'current_tracer') 772 self.fsetVal('', 'set_ftrace_filter') 773 # set trace format options 774 self.fsetVal('print-parent', 'trace_options') 775 self.fsetVal('funcgraph-abstime', 'trace_options') 776 self.fsetVal('funcgraph-cpu', 'trace_options') 777 self.fsetVal('funcgraph-duration', 'trace_options') 778 self.fsetVal('funcgraph-proc', 'trace_options') 779 self.fsetVal('funcgraph-tail', 'trace_options') 780 self.fsetVal('nofuncgraph-overhead', 'trace_options') 781 self.fsetVal('context-info', 'trace_options') 782 self.fsetVal('graph-time', 'trace_options') 783 self.fsetVal('%d' % self.max_graph_depth, 'max_graph_depth') 784 cf = ['dpm_run_callback'] 785 if(self.usetraceevents): 786 cf += ['dpm_prepare', 'dpm_complete'] 787 for fn in self.tracefuncs: 788 if 'func' in self.tracefuncs[fn]: 789 cf.append(self.tracefuncs[fn]['func']) 790 else: 791 cf.append(fn) 792 if self.ftop: 793 self.setFtraceFilterFunctions([self.ftopfunc]) 794 else: 795 self.setFtraceFilterFunctions(cf) 796 # initialize the kprobe trace 797 elif self.usekprobes: 798 for name in self.tracefuncs: 799 self.defaultKprobe(name, self.tracefuncs[name]) 800 if self.usedevsrc: 801 for name in self.dev_tracefuncs: 802 self.defaultKprobe(name, self.dev_tracefuncs[name]) 803 if not quiet: 804 pprint('INITIALIZING KPROBES...') 805 self.addKprobes(self.verbose) 806 if(self.usetraceevents): 807 # turn trace events on 808 events = iter(self.traceevents) 809 for e in events: 810 self.fsetVal('1', 'events/power/'+e+'/enable') 811 # clear the trace buffer 812 self.fsetVal('', 'trace') 813 def verifyFtrace(self): 814 # files needed for any trace data 815 files = ['buffer_size_kb', 'current_tracer', 'trace', 'trace_clock', 816 'trace_marker', 'trace_options', 'tracing_on'] 817 # files needed for callgraph trace data 818 tp = self.tpath 819 if(self.usecallgraph): 820 files += [ 821 'available_filter_functions', 822 'set_ftrace_filter', 823 'set_graph_function' 824 ] 825 for f in files: 826 if(os.path.exists(tp+f) == False): 827 return False 828 return True 829 def verifyKprobes(self): 830 # files needed for kprobes to work 831 files = ['kprobe_events', 'events'] 832 tp = self.tpath 833 for f in files: 834 if(os.path.exists(tp+f) == False): 835 return False 836 return True 837 def colorText(self, str, color=31): 838 if not self.ansi: 839 return str 840 return '\x1B[%d;40m%s\x1B[m' % (color, str) 841 def writeDatafileHeader(self, filename, testdata): 842 fp = self.openlog(filename, 'w') 843 fp.write('%s\n%s\n# command | %s\n' % (self.teststamp, self.sysstamp, self.cmdline)) 844 for test in testdata: 845 if 'fw' in test: 846 fw = test['fw'] 847 if(fw): 848 fp.write('# fwsuspend %u fwresume %u\n' % (fw[0], fw[1])) 849 if 'turbo' in test: 850 fp.write('# turbostat %s\n' % test['turbo']) 851 if 'wifi' in test: 852 fp.write('# wifi %s\n' % test['wifi']) 853 if test['error'] or len(testdata) > 1: 854 fp.write('# enter_sleep_error %s\n' % test['error']) 855 return fp 856 def sudoUserchown(self, dir): 857 if os.path.exists(dir) and self.sudouser: 858 cmd = 'chown -R {0}:{0} {1} > /dev/null 2>&1' 859 call(cmd.format(self.sudouser, dir), shell=True) 860 def outputResult(self, testdata, num=0): 861 if not self.result: 862 return 863 n = '' 864 if num > 0: 865 n = '%d' % num 866 fp = open(self.result, 'a') 867 if 'error' in testdata: 868 fp.write('result%s: fail\n' % n) 869 fp.write('error%s: %s\n' % (n, testdata['error'])) 870 else: 871 fp.write('result%s: pass\n' % n) 872 for v in ['suspend', 'resume', 'boot', 'lastinit']: 873 if v in testdata: 874 fp.write('%s%s: %.3f\n' % (v, n, testdata[v])) 875 for v in ['fwsuspend', 'fwresume']: 876 if v in testdata: 877 fp.write('%s%s: %.3f\n' % (v, n, testdata[v] / 1000000.0)) 878 if 'bugurl' in testdata: 879 fp.write('url%s: %s\n' % (n, testdata['bugurl'])) 880 fp.close() 881 self.sudoUserchown(self.result) 882 def configFile(self, file): 883 dir = os.path.dirname(os.path.realpath(__file__)) 884 if os.path.exists(file): 885 return file 886 elif os.path.exists(dir+'/'+file): 887 return dir+'/'+file 888 elif os.path.exists(dir+'/config/'+file): 889 return dir+'/config/'+file 890 return '' 891 def openlog(self, filename, mode): 892 isgz = self.gzip 893 if mode == 'r': 894 try: 895 with gzip.open(filename, mode+'t') as fp: 896 test = fp.read(64) 897 isgz = True 898 except: 899 isgz = False 900 if isgz: 901 return gzip.open(filename, mode+'t') 902 return open(filename, mode) 903 def b64unzip(self, data): 904 try: 905 out = codecs.decode(base64.b64decode(data), 'zlib').decode() 906 except: 907 out = data 908 return out 909 def b64zip(self, data): 910 out = base64.b64encode(codecs.encode(data.encode(), 'zlib')).decode() 911 return out 912 def platforminfo(self, cmdafter): 913 # add platform info on to a completed ftrace file 914 if not os.path.exists(self.ftracefile): 915 return False 916 footer = '#\n' 917 918 # add test command string line if need be 919 if self.suspendmode == 'command' and self.testcommand: 920 footer += '# platform-testcmd: %s\n' % (self.testcommand) 921 922 # get a list of target devices from the ftrace file 923 props = dict() 924 tp = TestProps() 925 tf = self.openlog(self.ftracefile, 'r') 926 for line in tf: 927 if tp.stampInfo(line, self): 928 continue 929 # parse only valid lines, if this is not one move on 930 m = re.match(tp.ftrace_line_fmt, line) 931 if(not m or 'device_pm_callback_start' not in line): 932 continue 933 m = re.match('.*: (?P<drv>.*) (?P<d>.*), parent: *(?P<p>.*), .*', m.group('msg')); 934 if(not m): 935 continue 936 dev = m.group('d') 937 if dev not in props: 938 props[dev] = DevProps() 939 tf.close() 940 941 # now get the syspath for each target device 942 for dirname, dirnames, filenames in os.walk('/sys/devices'): 943 if(re.match('.*/power', dirname) and 'async' in filenames): 944 dev = dirname.split('/')[-2] 945 if dev in props and (not props[dev].syspath or len(dirname) < len(props[dev].syspath)): 946 props[dev].syspath = dirname[:-6] 947 948 # now fill in the properties for our target devices 949 for dev in sorted(props): 950 dirname = props[dev].syspath 951 if not dirname or not os.path.exists(dirname): 952 continue 953 with open(dirname+'/power/async') as fp: 954 text = fp.read() 955 props[dev].isasync = False 956 if 'enabled' in text: 957 props[dev].isasync = True 958 fields = os.listdir(dirname) 959 if 'product' in fields: 960 with open(dirname+'/product', 'rb') as fp: 961 props[dev].altname = ascii(fp.read()) 962 elif 'name' in fields: 963 with open(dirname+'/name', 'rb') as fp: 964 props[dev].altname = ascii(fp.read()) 965 elif 'model' in fields: 966 with open(dirname+'/model', 'rb') as fp: 967 props[dev].altname = ascii(fp.read()) 968 elif 'description' in fields: 969 with open(dirname+'/description', 'rb') as fp: 970 props[dev].altname = ascii(fp.read()) 971 elif 'id' in fields: 972 with open(dirname+'/id', 'rb') as fp: 973 props[dev].altname = ascii(fp.read()) 974 elif 'idVendor' in fields and 'idProduct' in fields: 975 idv, idp = '', '' 976 with open(dirname+'/idVendor', 'rb') as fp: 977 idv = ascii(fp.read()).strip() 978 with open(dirname+'/idProduct', 'rb') as fp: 979 idp = ascii(fp.read()).strip() 980 props[dev].altname = '%s:%s' % (idv, idp) 981 if props[dev].altname: 982 out = props[dev].altname.strip().replace('\n', ' ')\ 983 .replace(',', ' ').replace(';', ' ') 984 props[dev].altname = out 985 986 # add a devinfo line to the bottom of ftrace 987 out = '' 988 for dev in sorted(props): 989 out += props[dev].out(dev) 990 footer += '# platform-devinfo: %s\n' % self.b64zip(out) 991 992 # add a line for each of these commands with their outputs 993 for name, cmdline, info in cmdafter: 994 footer += '# platform-%s: %s | %s\n' % (name, cmdline, self.b64zip(info)) 995 996 with self.openlog(self.ftracefile, 'a') as fp: 997 fp.write(footer) 998 return True 999 def commonPrefix(self, list): 1000 if len(list) < 2: 1001 return '' 1002 prefix = list[0] 1003 for s in list[1:]: 1004 while s[:len(prefix)] != prefix and prefix: 1005 prefix = prefix[:len(prefix)-1] 1006 if not prefix: 1007 break 1008 if '/' in prefix and prefix[-1] != '/': 1009 prefix = prefix[0:prefix.rfind('/')+1] 1010 return prefix 1011 def dictify(self, text, format): 1012 out = dict() 1013 header = True if format == 1 else False 1014 delim = ' ' if format == 1 else ':' 1015 for line in text.split('\n'): 1016 if header: 1017 header, out['@'] = False, line 1018 continue 1019 line = line.strip() 1020 if delim in line: 1021 data = line.split(delim, 1) 1022 num = re.search(r'[\d]+', data[1]) 1023 if format == 2 and num: 1024 out[data[0].strip()] = num.group() 1025 else: 1026 out[data[0].strip()] = data[1] 1027 return out 1028 def cmdinfo(self, begin, debug=False): 1029 out = [] 1030 if begin: 1031 self.cmd1 = dict() 1032 for cargs in self.infocmds: 1033 delta, name = cargs[0], cargs[1] 1034 cmdline, cmdpath = ' '.join(cargs[2:]), self.getExec(cargs[2]) 1035 if not cmdpath or (begin and not delta): 1036 continue 1037 try: 1038 fp = Popen([cmdpath]+cargs[3:], stdout=PIPE, stderr=PIPE).stdout 1039 info = ascii(fp.read()).strip() 1040 fp.close() 1041 except: 1042 continue 1043 if not debug and begin: 1044 self.cmd1[name] = self.dictify(info, delta) 1045 elif not debug and delta and name in self.cmd1: 1046 before, after = self.cmd1[name], self.dictify(info, delta) 1047 dinfo = ('\t%s\n' % before['@']) if '@' in before else '' 1048 prefix = self.commonPrefix(list(before.keys())) 1049 for key in sorted(before): 1050 if key in after and before[key] != after[key]: 1051 title = key.replace(prefix, '') 1052 if delta == 2: 1053 dinfo += '\t%s : %s -> %s\n' % \ 1054 (title, before[key].strip(), after[key].strip()) 1055 else: 1056 dinfo += '%10s (start) : %s\n%10s (after) : %s\n' % \ 1057 (title, before[key], title, after[key]) 1058 dinfo = '\tnothing changed' if not dinfo else dinfo.rstrip() 1059 out.append((name, cmdline, dinfo)) 1060 else: 1061 out.append((name, cmdline, '\tnothing' if not info else info)) 1062 return out 1063 def haveTurbostat(self): 1064 if not self.tstat: 1065 return False 1066 cmd = self.getExec('turbostat') 1067 if not cmd: 1068 return False 1069 fp = Popen([cmd, '-v'], stdout=PIPE, stderr=PIPE).stderr 1070 out = ascii(fp.read()).strip() 1071 fp.close() 1072 if re.match('turbostat version .*', out): 1073 self.vprint(out) 1074 return True 1075 return False 1076 def turbostat(self): 1077 cmd = self.getExec('turbostat') 1078 rawout = keyline = valline = '' 1079 fullcmd = '%s -q -S echo freeze > %s' % (cmd, self.powerfile) 1080 fp = Popen(['sh', '-c', fullcmd], stdout=PIPE, stderr=PIPE).stderr 1081 for line in fp: 1082 line = ascii(line) 1083 rawout += line 1084 if keyline and valline: 1085 continue 1086 if re.match('(?i)Avg_MHz.*', line): 1087 keyline = line.strip().split() 1088 elif keyline: 1089 valline = line.strip().split() 1090 fp.close() 1091 if not keyline or not valline or len(keyline) != len(valline): 1092 errmsg = 'unrecognized turbostat output:\n'+rawout.strip() 1093 self.vprint(errmsg) 1094 if not self.verbose: 1095 pprint(errmsg) 1096 return '' 1097 if self.verbose: 1098 pprint(rawout.strip()) 1099 out = [] 1100 for key in keyline: 1101 idx = keyline.index(key) 1102 val = valline[idx] 1103 out.append('%s=%s' % (key, val)) 1104 return '|'.join(out) 1105 def wifiDetails(self, dev): 1106 try: 1107 info = open('/sys/class/net/%s/device/uevent' % dev, 'r').read().strip() 1108 except: 1109 return dev 1110 vals = [dev] 1111 for prop in info.split('\n'): 1112 if prop.startswith('DRIVER=') or prop.startswith('PCI_ID='): 1113 vals.append(prop.split('=')[-1]) 1114 return ':'.join(vals) 1115 def checkWifi(self, dev=''): 1116 try: 1117 w = open('/proc/net/wireless', 'r').read().strip() 1118 except: 1119 return '' 1120 for line in reversed(w.split('\n')): 1121 m = re.match(' *(?P<dev>.*): (?P<stat>[0-9a-f]*) .*', w.split('\n')[-1]) 1122 if not m or (dev and dev != m.group('dev')): 1123 continue 1124 return m.group('dev') 1125 return '' 1126 def pollWifi(self, dev, timeout=60): 1127 start = time.time() 1128 while (time.time() - start) < timeout: 1129 w = self.checkWifi(dev) 1130 if w: 1131 return '%s reconnected %.2f' % \ 1132 (self.wifiDetails(dev), max(0, time.time() - start)) 1133 time.sleep(0.01) 1134 return '%s timeout %d' % (self.wifiDetails(dev), timeout) 1135 def errorSummary(self, errinfo, msg): 1136 found = False 1137 for entry in errinfo: 1138 if re.match(entry['match'], msg): 1139 entry['count'] += 1 1140 if self.hostname not in entry['urls']: 1141 entry['urls'][self.hostname] = [self.htmlfile] 1142 elif self.htmlfile not in entry['urls'][self.hostname]: 1143 entry['urls'][self.hostname].append(self.htmlfile) 1144 found = True 1145 break 1146 if found: 1147 return 1148 arr = msg.split() 1149 for j in range(len(arr)): 1150 if re.match('^[0-9,\-\.]*$', arr[j]): 1151 arr[j] = '[0-9,\-\.]*' 1152 else: 1153 arr[j] = arr[j]\ 1154 .replace('\\', '\\\\').replace(']', '\]').replace('[', '\[')\ 1155 .replace('.', '\.').replace('+', '\+').replace('*', '\*')\ 1156 .replace('(', '\(').replace(')', '\)').replace('}', '\}')\ 1157 .replace('{', '\{') 1158 mstr = ' *'.join(arr) 1159 entry = { 1160 'line': msg, 1161 'match': mstr, 1162 'count': 1, 1163 'urls': {self.hostname: [self.htmlfile]} 1164 } 1165 errinfo.append(entry) 1166 def multistat(self, start, idx, finish): 1167 if 'time' in self.multitest: 1168 id = '%d Duration=%dmin' % (idx+1, self.multitest['time']) 1169 else: 1170 id = '%d/%d' % (idx+1, self.multitest['count']) 1171 t = time.time() 1172 if 'start' not in self.multitest: 1173 self.multitest['start'] = self.multitest['last'] = t 1174 self.multitest['total'] = 0.0 1175 pprint('TEST (%s) START' % id) 1176 return 1177 dt = t - self.multitest['last'] 1178 if not start: 1179 if idx == 0 and self.multitest['delay'] > 0: 1180 self.multitest['total'] += self.multitest['delay'] 1181 pprint('TEST (%s) COMPLETE -- Duration %.1fs' % (id, dt)) 1182 return 1183 self.multitest['total'] += dt 1184 self.multitest['last'] = t 1185 avg = self.multitest['total'] / idx 1186 if 'time' in self.multitest: 1187 left = finish - datetime.now() 1188 left -= timedelta(microseconds=left.microseconds) 1189 else: 1190 left = timedelta(seconds=((self.multitest['count'] - idx) * int(avg))) 1191 pprint('TEST (%s) START - Avg Duration %.1fs, Time left %s' % \ 1192 (id, avg, str(left))) 1193 def multiinit(self, c, d): 1194 sz, unit = 'count', 'm' 1195 if c.endswith('d') or c.endswith('h') or c.endswith('m'): 1196 sz, unit, c = 'time', c[-1], c[:-1] 1197 self.multitest['run'] = True 1198 self.multitest[sz] = getArgInt('multi: n d (exec count)', c, 1, 1000000, False) 1199 self.multitest['delay'] = getArgInt('multi: n d (delay between tests)', d, 0, 3600, False) 1200 if unit == 'd': 1201 self.multitest[sz] *= 1440 1202 elif unit == 'h': 1203 self.multitest[sz] *= 60 1204 1205sysvals = SystemValues() 1206switchvalues = ['enable', 'disable', 'on', 'off', 'true', 'false', '1', '0'] 1207switchoff = ['disable', 'off', 'false', '0'] 1208suspendmodename = { 1209 'freeze': 'Freeze (S0)', 1210 'standby': 'Standby (S1)', 1211 'mem': 'Suspend (S3)', 1212 'disk': 'Hibernate (S4)' 1213} 1214 1215# Class: DevProps 1216# Description: 1217# Simple class which holds property values collected 1218# for all the devices used in the timeline. 1219class DevProps: 1220 def __init__(self): 1221 self.syspath = '' 1222 self.altname = '' 1223 self.isasync = True 1224 self.xtraclass = '' 1225 self.xtrainfo = '' 1226 def out(self, dev): 1227 return '%s,%s,%d;' % (dev, self.altname, self.isasync) 1228 def debug(self, dev): 1229 pprint('%s:\n\taltname = %s\n\t async = %s' % (dev, self.altname, self.isasync)) 1230 def altName(self, dev): 1231 if not self.altname or self.altname == dev: 1232 return dev 1233 return '%s [%s]' % (self.altname, dev) 1234 def xtraClass(self): 1235 if self.xtraclass: 1236 return ' '+self.xtraclass 1237 if not self.isasync: 1238 return ' sync' 1239 return '' 1240 def xtraInfo(self): 1241 if self.xtraclass: 1242 return ' '+self.xtraclass 1243 if self.isasync: 1244 return ' (async)' 1245 return ' (sync)' 1246 1247# Class: DeviceNode 1248# Description: 1249# A container used to create a device hierachy, with a single root node 1250# and a tree of child nodes. Used by Data.deviceTopology() 1251class DeviceNode: 1252 def __init__(self, nodename, nodedepth): 1253 self.name = nodename 1254 self.children = [] 1255 self.depth = nodedepth 1256 1257# Class: Data 1258# Description: 1259# The primary container for suspend/resume test data. There is one for 1260# each test run. The data is organized into a cronological hierarchy: 1261# Data.dmesg { 1262# phases { 1263# 10 sequential, non-overlapping phases of S/R 1264# contents: times for phase start/end, order/color data for html 1265# devlist { 1266# device callback or action list for this phase 1267# device { 1268# a single device callback or generic action 1269# contents: start/stop times, pid/cpu/driver info 1270# parents/children, html id for timeline/callgraph 1271# optionally includes an ftrace callgraph 1272# optionally includes dev/ps data 1273# } 1274# } 1275# } 1276# } 1277# 1278class Data: 1279 phasedef = { 1280 'suspend_prepare': {'order': 0, 'color': '#CCFFCC'}, 1281 'suspend': {'order': 1, 'color': '#88FF88'}, 1282 'suspend_late': {'order': 2, 'color': '#00AA00'}, 1283 'suspend_noirq': {'order': 3, 'color': '#008888'}, 1284 'suspend_machine': {'order': 4, 'color': '#0000FF'}, 1285 'resume_machine': {'order': 5, 'color': '#FF0000'}, 1286 'resume_noirq': {'order': 6, 'color': '#FF9900'}, 1287 'resume_early': {'order': 7, 'color': '#FFCC00'}, 1288 'resume': {'order': 8, 'color': '#FFFF88'}, 1289 'resume_complete': {'order': 9, 'color': '#FFFFCC'}, 1290 } 1291 errlist = { 1292 'HWERROR' : r'.*\[ *Hardware Error *\].*', 1293 'FWBUG' : r'.*\[ *Firmware Bug *\].*', 1294 'BUG' : r'(?i).*\bBUG\b.*', 1295 'ERROR' : r'(?i).*\bERROR\b.*', 1296 'WARNING' : r'(?i).*\bWARNING\b.*', 1297 'FAULT' : r'(?i).*\bFAULT\b.*', 1298 'FAIL' : r'(?i).*\bFAILED\b.*', 1299 'INVALID' : r'(?i).*\bINVALID\b.*', 1300 'CRASH' : r'(?i).*\bCRASHED\b.*', 1301 'TIMEOUT' : r'(?i).*\bTIMEOUT\b.*', 1302 'IRQ' : r'.*\bgenirq: .*', 1303 'TASKFAIL': r'.*Freezing of tasks *.*', 1304 'ACPI' : r'.*\bACPI *(?P<b>[A-Za-z]*) *Error[: ].*', 1305 'DISKFULL': r'.*\bNo space left on device.*', 1306 'USBERR' : r'.*usb .*device .*, error [0-9-]*', 1307 'ATAERR' : r' *ata[0-9\.]*: .*failed.*', 1308 'MEIERR' : r' *mei.*: .*failed.*', 1309 'TPMERR' : r'(?i) *tpm *tpm[0-9]*: .*error.*', 1310 } 1311 def __init__(self, num): 1312 idchar = 'abcdefghij' 1313 self.start = 0.0 # test start 1314 self.end = 0.0 # test end 1315 self.hwstart = 0 # rtc test start 1316 self.hwend = 0 # rtc test end 1317 self.tSuspended = 0.0 # low-level suspend start 1318 self.tResumed = 0.0 # low-level resume start 1319 self.tKernSus = 0.0 # kernel level suspend start 1320 self.tKernRes = 0.0 # kernel level resume end 1321 self.fwValid = False # is firmware data available 1322 self.fwSuspend = 0 # time spent in firmware suspend 1323 self.fwResume = 0 # time spent in firmware resume 1324 self.html_device_id = 0 1325 self.stamp = 0 1326 self.outfile = '' 1327 self.kerror = False 1328 self.wifi = dict() 1329 self.turbostat = 0 1330 self.enterfail = '' 1331 self.currphase = '' 1332 self.pstl = dict() # process timeline 1333 self.testnumber = num 1334 self.idstr = idchar[num] 1335 self.dmesgtext = [] # dmesg text file in memory 1336 self.dmesg = dict() # root data structure 1337 self.errorinfo = {'suspend':[],'resume':[]} 1338 self.tLow = [] # time spent in low-level suspends (standby/freeze) 1339 self.devpids = [] 1340 self.devicegroups = 0 1341 def sortedPhases(self): 1342 return sorted(self.dmesg, key=lambda k:self.dmesg[k]['order']) 1343 def initDevicegroups(self): 1344 # called when phases are all finished being added 1345 for phase in sorted(self.dmesg.keys()): 1346 if '*' in phase: 1347 p = phase.split('*') 1348 pnew = '%s%d' % (p[0], len(p)) 1349 self.dmesg[pnew] = self.dmesg.pop(phase) 1350 self.devicegroups = [] 1351 for phase in self.sortedPhases(): 1352 self.devicegroups.append([phase]) 1353 def nextPhase(self, phase, offset): 1354 order = self.dmesg[phase]['order'] + offset 1355 for p in self.dmesg: 1356 if self.dmesg[p]['order'] == order: 1357 return p 1358 return '' 1359 def lastPhase(self, depth=1): 1360 plist = self.sortedPhases() 1361 if len(plist) < depth: 1362 return '' 1363 return plist[-1*depth] 1364 def turbostatInfo(self): 1365 tp = TestProps() 1366 out = {'syslpi':'N/A','pkgpc10':'N/A'} 1367 for line in self.dmesgtext: 1368 m = re.match(tp.tstatfmt, line) 1369 if not m: 1370 continue 1371 for i in m.group('t').split('|'): 1372 if 'SYS%LPI' in i: 1373 out['syslpi'] = i.split('=')[-1]+'%' 1374 elif 'pc10' in i: 1375 out['pkgpc10'] = i.split('=')[-1]+'%' 1376 break 1377 return out 1378 def extractErrorInfo(self): 1379 lf = self.dmesgtext 1380 if len(self.dmesgtext) < 1 and sysvals.dmesgfile: 1381 lf = sysvals.openlog(sysvals.dmesgfile, 'r') 1382 i = 0 1383 tp = TestProps() 1384 list = [] 1385 for line in lf: 1386 i += 1 1387 if tp.stampInfo(line, sysvals): 1388 continue 1389 m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line) 1390 if not m: 1391 continue 1392 t = float(m.group('ktime')) 1393 if t < self.start or t > self.end: 1394 continue 1395 dir = 'suspend' if t < self.tSuspended else 'resume' 1396 msg = m.group('msg') 1397 if re.match('capability: warning: .*', msg): 1398 continue 1399 for err in self.errlist: 1400 if re.match(self.errlist[err], msg): 1401 list.append((msg, err, dir, t, i, i)) 1402 self.kerror = True 1403 break 1404 tp.msglist = [] 1405 for msg, type, dir, t, idx1, idx2 in list: 1406 tp.msglist.append(msg) 1407 self.errorinfo[dir].append((type, t, idx1, idx2)) 1408 if self.kerror: 1409 sysvals.dmesglog = True 1410 if len(self.dmesgtext) < 1 and sysvals.dmesgfile: 1411 lf.close() 1412 return tp 1413 def setStart(self, time, msg=''): 1414 self.start = time 1415 if msg: 1416 try: 1417 self.hwstart = datetime.strptime(msg, sysvals.tmstart) 1418 except: 1419 self.hwstart = 0 1420 def setEnd(self, time, msg=''): 1421 self.end = time 1422 if msg: 1423 try: 1424 self.hwend = datetime.strptime(msg, sysvals.tmend) 1425 except: 1426 self.hwend = 0 1427 def isTraceEventOutsideDeviceCalls(self, pid, time): 1428 for phase in self.sortedPhases(): 1429 list = self.dmesg[phase]['list'] 1430 for dev in list: 1431 d = list[dev] 1432 if(d['pid'] == pid and time >= d['start'] and 1433 time < d['end']): 1434 return False 1435 return True 1436 def sourcePhase(self, start): 1437 for phase in self.sortedPhases(): 1438 if 'machine' in phase: 1439 continue 1440 pend = self.dmesg[phase]['end'] 1441 if start <= pend: 1442 return phase 1443 return 'resume_complete' 1444 def sourceDevice(self, phaselist, start, end, pid, type): 1445 tgtdev = '' 1446 for phase in phaselist: 1447 list = self.dmesg[phase]['list'] 1448 for devname in list: 1449 dev = list[devname] 1450 # pid must match 1451 if dev['pid'] != pid: 1452 continue 1453 devS = dev['start'] 1454 devE = dev['end'] 1455 if type == 'device': 1456 # device target event is entirely inside the source boundary 1457 if(start < devS or start >= devE or end <= devS or end > devE): 1458 continue 1459 elif type == 'thread': 1460 # thread target event will expand the source boundary 1461 if start < devS: 1462 dev['start'] = start 1463 if end > devE: 1464 dev['end'] = end 1465 tgtdev = dev 1466 break 1467 return tgtdev 1468 def addDeviceFunctionCall(self, displayname, kprobename, proc, pid, start, end, cdata, rdata): 1469 # try to place the call in a device 1470 phases = self.sortedPhases() 1471 tgtdev = self.sourceDevice(phases, start, end, pid, 'device') 1472 # calls with device pids that occur outside device bounds are dropped 1473 # TODO: include these somehow 1474 if not tgtdev and pid in self.devpids: 1475 return False 1476 # try to place the call in a thread 1477 if not tgtdev: 1478 tgtdev = self.sourceDevice(phases, start, end, pid, 'thread') 1479 # create new thread blocks, expand as new calls are found 1480 if not tgtdev: 1481 if proc == '<...>': 1482 threadname = 'kthread-%d' % (pid) 1483 else: 1484 threadname = '%s-%d' % (proc, pid) 1485 tgtphase = self.sourcePhase(start) 1486 self.newAction(tgtphase, threadname, pid, '', start, end, '', ' kth', '') 1487 return self.addDeviceFunctionCall(displayname, kprobename, proc, pid, start, end, cdata, rdata) 1488 # this should not happen 1489 if not tgtdev: 1490 sysvals.vprint('[%f - %f] %s-%d %s %s %s' % \ 1491 (start, end, proc, pid, kprobename, cdata, rdata)) 1492 return False 1493 # place the call data inside the src element of the tgtdev 1494 if('src' not in tgtdev): 1495 tgtdev['src'] = [] 1496 dtf = sysvals.dev_tracefuncs 1497 ubiquitous = False 1498 if kprobename in dtf and 'ub' in dtf[kprobename]: 1499 ubiquitous = True 1500 title = cdata+' '+rdata 1501 mstr = '\(.*\) *(?P<args>.*) *\((?P<caller>.*)\+.* arg1=(?P<ret>.*)' 1502 m = re.match(mstr, title) 1503 if m: 1504 c = m.group('caller') 1505 a = m.group('args').strip() 1506 r = m.group('ret') 1507 if len(r) > 6: 1508 r = '' 1509 else: 1510 r = 'ret=%s ' % r 1511 if ubiquitous and c in dtf and 'ub' in dtf[c]: 1512 return False 1513 color = sysvals.kprobeColor(kprobename) 1514 e = DevFunction(displayname, a, c, r, start, end, ubiquitous, proc, pid, color) 1515 tgtdev['src'].append(e) 1516 return True 1517 def overflowDevices(self): 1518 # get a list of devices that extend beyond the end of this test run 1519 devlist = [] 1520 for phase in self.sortedPhases(): 1521 list = self.dmesg[phase]['list'] 1522 for devname in list: 1523 dev = list[devname] 1524 if dev['end'] > self.end: 1525 devlist.append(dev) 1526 return devlist 1527 def mergeOverlapDevices(self, devlist): 1528 # merge any devices that overlap devlist 1529 for dev in devlist: 1530 devname = dev['name'] 1531 for phase in self.sortedPhases(): 1532 list = self.dmesg[phase]['list'] 1533 if devname not in list: 1534 continue 1535 tdev = list[devname] 1536 o = min(dev['end'], tdev['end']) - max(dev['start'], tdev['start']) 1537 if o <= 0: 1538 continue 1539 dev['end'] = tdev['end'] 1540 if 'src' not in dev or 'src' not in tdev: 1541 continue 1542 dev['src'] += tdev['src'] 1543 del list[devname] 1544 def usurpTouchingThread(self, name, dev): 1545 # the caller test has priority of this thread, give it to him 1546 for phase in self.sortedPhases(): 1547 list = self.dmesg[phase]['list'] 1548 if name in list: 1549 tdev = list[name] 1550 if tdev['start'] - dev['end'] < 0.1: 1551 dev['end'] = tdev['end'] 1552 if 'src' not in dev: 1553 dev['src'] = [] 1554 if 'src' in tdev: 1555 dev['src'] += tdev['src'] 1556 del list[name] 1557 break 1558 def stitchTouchingThreads(self, testlist): 1559 # merge any threads between tests that touch 1560 for phase in self.sortedPhases(): 1561 list = self.dmesg[phase]['list'] 1562 for devname in list: 1563 dev = list[devname] 1564 if 'htmlclass' not in dev or 'kth' not in dev['htmlclass']: 1565 continue 1566 for data in testlist: 1567 data.usurpTouchingThread(devname, dev) 1568 def optimizeDevSrc(self): 1569 # merge any src call loops to reduce timeline size 1570 for phase in self.sortedPhases(): 1571 list = self.dmesg[phase]['list'] 1572 for dev in list: 1573 if 'src' not in list[dev]: 1574 continue 1575 src = list[dev]['src'] 1576 p = 0 1577 for e in sorted(src, key=lambda event: event.time): 1578 if not p or not e.repeat(p): 1579 p = e 1580 continue 1581 # e is another iteration of p, move it into p 1582 p.end = e.end 1583 p.length = p.end - p.time 1584 p.count += 1 1585 src.remove(e) 1586 def trimTimeVal(self, t, t0, dT, left): 1587 if left: 1588 if(t > t0): 1589 if(t - dT < t0): 1590 return t0 1591 return t - dT 1592 else: 1593 return t 1594 else: 1595 if(t < t0 + dT): 1596 if(t > t0): 1597 return t0 + dT 1598 return t + dT 1599 else: 1600 return t 1601 def trimTime(self, t0, dT, left): 1602 self.tSuspended = self.trimTimeVal(self.tSuspended, t0, dT, left) 1603 self.tResumed = self.trimTimeVal(self.tResumed, t0, dT, left) 1604 self.start = self.trimTimeVal(self.start, t0, dT, left) 1605 self.tKernSus = self.trimTimeVal(self.tKernSus, t0, dT, left) 1606 self.tKernRes = self.trimTimeVal(self.tKernRes, t0, dT, left) 1607 self.end = self.trimTimeVal(self.end, t0, dT, left) 1608 for phase in self.sortedPhases(): 1609 p = self.dmesg[phase] 1610 p['start'] = self.trimTimeVal(p['start'], t0, dT, left) 1611 p['end'] = self.trimTimeVal(p['end'], t0, dT, left) 1612 list = p['list'] 1613 for name in list: 1614 d = list[name] 1615 d['start'] = self.trimTimeVal(d['start'], t0, dT, left) 1616 d['end'] = self.trimTimeVal(d['end'], t0, dT, left) 1617 d['length'] = d['end'] - d['start'] 1618 if('ftrace' in d): 1619 cg = d['ftrace'] 1620 cg.start = self.trimTimeVal(cg.start, t0, dT, left) 1621 cg.end = self.trimTimeVal(cg.end, t0, dT, left) 1622 for line in cg.list: 1623 line.time = self.trimTimeVal(line.time, t0, dT, left) 1624 if('src' in d): 1625 for e in d['src']: 1626 e.time = self.trimTimeVal(e.time, t0, dT, left) 1627 e.end = self.trimTimeVal(e.end, t0, dT, left) 1628 e.length = e.end - e.time 1629 for dir in ['suspend', 'resume']: 1630 list = [] 1631 for e in self.errorinfo[dir]: 1632 type, tm, idx1, idx2 = e 1633 tm = self.trimTimeVal(tm, t0, dT, left) 1634 list.append((type, tm, idx1, idx2)) 1635 self.errorinfo[dir] = list 1636 def trimFreezeTime(self, tZero): 1637 # trim out any standby or freeze clock time 1638 lp = '' 1639 for phase in self.sortedPhases(): 1640 if 'resume_machine' in phase and 'suspend_machine' in lp: 1641 tS, tR = self.dmesg[lp]['end'], self.dmesg[phase]['start'] 1642 tL = tR - tS 1643 if tL > 0: 1644 left = True if tR > tZero else False 1645 self.trimTime(tS, tL, left) 1646 if 'trying' in self.dmesg[lp] and self.dmesg[lp]['trying'] >= 0.001: 1647 tTry = round(self.dmesg[lp]['trying'] * 1000) 1648 text = '%.0f (-%.0f waking)' % (tL * 1000, tTry) 1649 else: 1650 text = '%.0f' % (tL * 1000) 1651 self.tLow.append(text) 1652 lp = phase 1653 def getMemTime(self): 1654 if not self.hwstart or not self.hwend: 1655 return 1656 stime = (self.tSuspended - self.start) * 1000000 1657 rtime = (self.end - self.tResumed) * 1000000 1658 hws = self.hwstart + timedelta(microseconds=stime) 1659 hwr = self.hwend - timedelta(microseconds=rtime) 1660 self.tLow.append('%.0f'%((hwr - hws).total_seconds() * 1000)) 1661 def getTimeValues(self): 1662 sktime = (self.tSuspended - self.tKernSus) * 1000 1663 rktime = (self.tKernRes - self.tResumed) * 1000 1664 return (sktime, rktime) 1665 def setPhase(self, phase, ktime, isbegin, order=-1): 1666 if(isbegin): 1667 # phase start over current phase 1668 if self.currphase: 1669 if 'resume_machine' not in self.currphase: 1670 sysvals.vprint('WARNING: phase %s failed to end' % self.currphase) 1671 self.dmesg[self.currphase]['end'] = ktime 1672 phases = self.dmesg.keys() 1673 color = self.phasedef[phase]['color'] 1674 count = len(phases) if order < 0 else order 1675 # create unique name for every new phase 1676 while phase in phases: 1677 phase += '*' 1678 self.dmesg[phase] = {'list': dict(), 'start': -1.0, 'end': -1.0, 1679 'row': 0, 'color': color, 'order': count} 1680 self.dmesg[phase]['start'] = ktime 1681 self.currphase = phase 1682 else: 1683 # phase end without a start 1684 if phase not in self.currphase: 1685 if self.currphase: 1686 sysvals.vprint('WARNING: %s ended instead of %s, ftrace corruption?' % (phase, self.currphase)) 1687 else: 1688 sysvals.vprint('WARNING: %s ended without a start, ftrace corruption?' % phase) 1689 return phase 1690 phase = self.currphase 1691 self.dmesg[phase]['end'] = ktime 1692 self.currphase = '' 1693 return phase 1694 def sortedDevices(self, phase): 1695 list = self.dmesg[phase]['list'] 1696 return sorted(list, key=lambda k:list[k]['start']) 1697 def fixupInitcalls(self, phase): 1698 # if any calls never returned, clip them at system resume end 1699 phaselist = self.dmesg[phase]['list'] 1700 for devname in phaselist: 1701 dev = phaselist[devname] 1702 if(dev['end'] < 0): 1703 for p in self.sortedPhases(): 1704 if self.dmesg[p]['end'] > dev['start']: 1705 dev['end'] = self.dmesg[p]['end'] 1706 break 1707 sysvals.vprint('%s (%s): callback didnt return' % (devname, phase)) 1708 def deviceFilter(self, devicefilter): 1709 for phase in self.sortedPhases(): 1710 list = self.dmesg[phase]['list'] 1711 rmlist = [] 1712 for name in list: 1713 keep = False 1714 for filter in devicefilter: 1715 if filter in name or \ 1716 ('drv' in list[name] and filter in list[name]['drv']): 1717 keep = True 1718 if not keep: 1719 rmlist.append(name) 1720 for name in rmlist: 1721 del list[name] 1722 def fixupInitcallsThatDidntReturn(self): 1723 # if any calls never returned, clip them at system resume end 1724 for phase in self.sortedPhases(): 1725 self.fixupInitcalls(phase) 1726 def phaseOverlap(self, phases): 1727 rmgroups = [] 1728 newgroup = [] 1729 for group in self.devicegroups: 1730 for phase in phases: 1731 if phase not in group: 1732 continue 1733 for p in group: 1734 if p not in newgroup: 1735 newgroup.append(p) 1736 if group not in rmgroups: 1737 rmgroups.append(group) 1738 for group in rmgroups: 1739 self.devicegroups.remove(group) 1740 self.devicegroups.append(newgroup) 1741 def newActionGlobal(self, name, start, end, pid=-1, color=''): 1742 # which phase is this device callback or action in 1743 phases = self.sortedPhases() 1744 targetphase = 'none' 1745 htmlclass = '' 1746 overlap = 0.0 1747 myphases = [] 1748 for phase in phases: 1749 pstart = self.dmesg[phase]['start'] 1750 pend = self.dmesg[phase]['end'] 1751 # see if the action overlaps this phase 1752 o = max(0, min(end, pend) - max(start, pstart)) 1753 if o > 0: 1754 myphases.append(phase) 1755 # set the target phase to the one that overlaps most 1756 if o > overlap: 1757 if overlap > 0 and phase == 'post_resume': 1758 continue 1759 targetphase = phase 1760 overlap = o 1761 # if no target phase was found, pin it to the edge 1762 if targetphase == 'none': 1763 p0start = self.dmesg[phases[0]]['start'] 1764 if start <= p0start: 1765 targetphase = phases[0] 1766 else: 1767 targetphase = phases[-1] 1768 if pid == -2: 1769 htmlclass = ' bg' 1770 elif pid == -3: 1771 htmlclass = ' ps' 1772 if len(myphases) > 1: 1773 htmlclass = ' bg' 1774 self.phaseOverlap(myphases) 1775 if targetphase in phases: 1776 newname = self.newAction(targetphase, name, pid, '', start, end, '', htmlclass, color) 1777 return (targetphase, newname) 1778 return False 1779 def newAction(self, phase, name, pid, parent, start, end, drv, htmlclass='', color=''): 1780 # new device callback for a specific phase 1781 self.html_device_id += 1 1782 devid = '%s%d' % (self.idstr, self.html_device_id) 1783 list = self.dmesg[phase]['list'] 1784 length = -1.0 1785 if(start >= 0 and end >= 0): 1786 length = end - start 1787 if pid == -2 or name not in sysvals.tracefuncs.keys(): 1788 i = 2 1789 origname = name 1790 while(name in list): 1791 name = '%s[%d]' % (origname, i) 1792 i += 1 1793 list[name] = {'name': name, 'start': start, 'end': end, 'pid': pid, 1794 'par': parent, 'length': length, 'row': 0, 'id': devid, 'drv': drv } 1795 if htmlclass: 1796 list[name]['htmlclass'] = htmlclass 1797 if color: 1798 list[name]['color'] = color 1799 return name 1800 def findDevice(self, phase, name): 1801 list = self.dmesg[phase]['list'] 1802 mydev = '' 1803 for devname in sorted(list): 1804 if name == devname or re.match('^%s\[(?P<num>[0-9]*)\]$' % name, devname): 1805 mydev = devname 1806 if mydev: 1807 return list[mydev] 1808 return False 1809 def deviceChildren(self, devname, phase): 1810 devlist = [] 1811 list = self.dmesg[phase]['list'] 1812 for child in list: 1813 if(list[child]['par'] == devname): 1814 devlist.append(child) 1815 return devlist 1816 def maxDeviceNameSize(self, phase): 1817 size = 0 1818 for name in self.dmesg[phase]['list']: 1819 if len(name) > size: 1820 size = len(name) 1821 return size 1822 def printDetails(self): 1823 sysvals.vprint('Timeline Details:') 1824 sysvals.vprint(' test start: %f' % self.start) 1825 sysvals.vprint('kernel suspend start: %f' % self.tKernSus) 1826 tS = tR = False 1827 for phase in self.sortedPhases(): 1828 devlist = self.dmesg[phase]['list'] 1829 dc, ps, pe = len(devlist), self.dmesg[phase]['start'], self.dmesg[phase]['end'] 1830 if not tS and ps >= self.tSuspended: 1831 sysvals.vprint(' machine suspended: %f' % self.tSuspended) 1832 tS = True 1833 if not tR and ps >= self.tResumed: 1834 sysvals.vprint(' machine resumed: %f' % self.tResumed) 1835 tR = True 1836 sysvals.vprint('%20s: %f - %f (%d devices)' % (phase, ps, pe, dc)) 1837 if sysvals.devdump: 1838 sysvals.vprint(''.join('-' for i in range(80))) 1839 maxname = '%d' % self.maxDeviceNameSize(phase) 1840 fmt = '%3d) %'+maxname+'s - %f - %f' 1841 c = 1 1842 for name in sorted(devlist): 1843 s = devlist[name]['start'] 1844 e = devlist[name]['end'] 1845 sysvals.vprint(fmt % (c, name, s, e)) 1846 c += 1 1847 sysvals.vprint(''.join('-' for i in range(80))) 1848 sysvals.vprint(' kernel resume end: %f' % self.tKernRes) 1849 sysvals.vprint(' test end: %f' % self.end) 1850 def deviceChildrenAllPhases(self, devname): 1851 devlist = [] 1852 for phase in self.sortedPhases(): 1853 list = self.deviceChildren(devname, phase) 1854 for dev in sorted(list): 1855 if dev not in devlist: 1856 devlist.append(dev) 1857 return devlist 1858 def masterTopology(self, name, list, depth): 1859 node = DeviceNode(name, depth) 1860 for cname in list: 1861 # avoid recursions 1862 if name == cname: 1863 continue 1864 clist = self.deviceChildrenAllPhases(cname) 1865 cnode = self.masterTopology(cname, clist, depth+1) 1866 node.children.append(cnode) 1867 return node 1868 def printTopology(self, node): 1869 html = '' 1870 if node.name: 1871 info = '' 1872 drv = '' 1873 for phase in self.sortedPhases(): 1874 list = self.dmesg[phase]['list'] 1875 if node.name in list: 1876 s = list[node.name]['start'] 1877 e = list[node.name]['end'] 1878 if list[node.name]['drv']: 1879 drv = ' {'+list[node.name]['drv']+'}' 1880 info += ('<li>%s: %.3fms</li>' % (phase, (e-s)*1000)) 1881 html += '<li><b>'+node.name+drv+'</b>' 1882 if info: 1883 html += '<ul>'+info+'</ul>' 1884 html += '</li>' 1885 if len(node.children) > 0: 1886 html += '<ul>' 1887 for cnode in node.children: 1888 html += self.printTopology(cnode) 1889 html += '</ul>' 1890 return html 1891 def rootDeviceList(self): 1892 # list of devices graphed 1893 real = [] 1894 for phase in self.sortedPhases(): 1895 list = self.dmesg[phase]['list'] 1896 for dev in sorted(list): 1897 if list[dev]['pid'] >= 0 and dev not in real: 1898 real.append(dev) 1899 # list of top-most root devices 1900 rootlist = [] 1901 for phase in self.sortedPhases(): 1902 list = self.dmesg[phase]['list'] 1903 for dev in sorted(list): 1904 pdev = list[dev]['par'] 1905 pid = list[dev]['pid'] 1906 if(pid < 0 or re.match('[0-9]*-[0-9]*\.[0-9]*[\.0-9]*\:[\.0-9]*$', pdev)): 1907 continue 1908 if pdev and pdev not in real and pdev not in rootlist: 1909 rootlist.append(pdev) 1910 return rootlist 1911 def deviceTopology(self): 1912 rootlist = self.rootDeviceList() 1913 master = self.masterTopology('', rootlist, 0) 1914 return self.printTopology(master) 1915 def selectTimelineDevices(self, widfmt, tTotal, mindevlen): 1916 # only select devices that will actually show up in html 1917 self.tdevlist = dict() 1918 for phase in self.dmesg: 1919 devlist = [] 1920 list = self.dmesg[phase]['list'] 1921 for dev in list: 1922 length = (list[dev]['end'] - list[dev]['start']) * 1000 1923 width = widfmt % (((list[dev]['end']-list[dev]['start'])*100)/tTotal) 1924 if width != '0.000000' and length >= mindevlen: 1925 devlist.append(dev) 1926 self.tdevlist[phase] = devlist 1927 def addHorizontalDivider(self, devname, devend): 1928 phase = 'suspend_prepare' 1929 self.newAction(phase, devname, -2, '', \ 1930 self.start, devend, '', ' sec', '') 1931 if phase not in self.tdevlist: 1932 self.tdevlist[phase] = [] 1933 self.tdevlist[phase].append(devname) 1934 d = DevItem(0, phase, self.dmesg[phase]['list'][devname]) 1935 return d 1936 def addProcessUsageEvent(self, name, times): 1937 # get the start and end times for this process 1938 maxC = 0 1939 tlast = 0 1940 start = -1 1941 end = -1 1942 for t in sorted(times): 1943 if tlast == 0: 1944 tlast = t 1945 continue 1946 if name in self.pstl[t]: 1947 if start == -1 or tlast < start: 1948 start = tlast 1949 if end == -1 or t > end: 1950 end = t 1951 tlast = t 1952 if start == -1 or end == -1: 1953 return 0 1954 # add a new action for this process and get the object 1955 out = self.newActionGlobal(name, start, end, -3) 1956 if not out: 1957 return 0 1958 phase, devname = out 1959 dev = self.dmesg[phase]['list'][devname] 1960 # get the cpu exec data 1961 tlast = 0 1962 clast = 0 1963 cpuexec = dict() 1964 for t in sorted(times): 1965 if tlast == 0 or t <= start or t > end: 1966 tlast = t 1967 continue 1968 list = self.pstl[t] 1969 c = 0 1970 if name in list: 1971 c = list[name] 1972 if c > maxC: 1973 maxC = c 1974 if c != clast: 1975 key = (tlast, t) 1976 cpuexec[key] = c 1977 tlast = t 1978 clast = c 1979 dev['cpuexec'] = cpuexec 1980 return maxC 1981 def createProcessUsageEvents(self): 1982 # get an array of process names 1983 proclist = [] 1984 for t in sorted(self.pstl): 1985 pslist = self.pstl[t] 1986 for ps in sorted(pslist): 1987 if ps not in proclist: 1988 proclist.append(ps) 1989 # get a list of data points for suspend and resume 1990 tsus = [] 1991 tres = [] 1992 for t in sorted(self.pstl): 1993 if t < self.tSuspended: 1994 tsus.append(t) 1995 else: 1996 tres.append(t) 1997 # process the events for suspend and resume 1998 if len(proclist) > 0: 1999 sysvals.vprint('Process Execution:') 2000 for ps in proclist: 2001 c = self.addProcessUsageEvent(ps, tsus) 2002 if c > 0: 2003 sysvals.vprint('%25s (sus): %d' % (ps, c)) 2004 c = self.addProcessUsageEvent(ps, tres) 2005 if c > 0: 2006 sysvals.vprint('%25s (res): %d' % (ps, c)) 2007 def handleEndMarker(self, time, msg=''): 2008 dm = self.dmesg 2009 self.setEnd(time, msg) 2010 self.initDevicegroups() 2011 # give suspend_prepare an end if needed 2012 if 'suspend_prepare' in dm and dm['suspend_prepare']['end'] < 0: 2013 dm['suspend_prepare']['end'] = time 2014 # assume resume machine ends at next phase start 2015 if 'resume_machine' in dm and dm['resume_machine']['end'] < 0: 2016 np = self.nextPhase('resume_machine', 1) 2017 if np: 2018 dm['resume_machine']['end'] = dm[np]['start'] 2019 # if kernel resume end not found, assume its the end marker 2020 if self.tKernRes == 0.0: 2021 self.tKernRes = time 2022 # if kernel suspend start not found, assume its the end marker 2023 if self.tKernSus == 0.0: 2024 self.tKernSus = time 2025 # set resume complete to end at end marker 2026 if 'resume_complete' in dm: 2027 dm['resume_complete']['end'] = time 2028 def debugPrint(self): 2029 for p in self.sortedPhases(): 2030 list = self.dmesg[p]['list'] 2031 for devname in sorted(list): 2032 dev = list[devname] 2033 if 'ftrace' in dev: 2034 dev['ftrace'].debugPrint(' [%s]' % devname) 2035 2036# Class: DevFunction 2037# Description: 2038# A container for kprobe function data we want in the dev timeline 2039class DevFunction: 2040 def __init__(self, name, args, caller, ret, start, end, u, proc, pid, color): 2041 self.row = 0 2042 self.count = 1 2043 self.name = name 2044 self.args = args 2045 self.caller = caller 2046 self.ret = ret 2047 self.time = start 2048 self.length = end - start 2049 self.end = end 2050 self.ubiquitous = u 2051 self.proc = proc 2052 self.pid = pid 2053 self.color = color 2054 def title(self): 2055 cnt = '' 2056 if self.count > 1: 2057 cnt = '(x%d)' % self.count 2058 l = '%0.3fms' % (self.length * 1000) 2059 if self.ubiquitous: 2060 title = '%s(%s)%s <- %s, %s(%s)' % \ 2061 (self.name, self.args, cnt, self.caller, self.ret, l) 2062 else: 2063 title = '%s(%s) %s%s(%s)' % (self.name, self.args, self.ret, cnt, l) 2064 return title.replace('"', '') 2065 def text(self): 2066 if self.count > 1: 2067 text = '%s(x%d)' % (self.name, self.count) 2068 else: 2069 text = self.name 2070 return text 2071 def repeat(self, tgt): 2072 # is the tgt call just a repeat of this call (e.g. are we in a loop) 2073 dt = self.time - tgt.end 2074 # only combine calls if -all- attributes are identical 2075 if tgt.caller == self.caller and \ 2076 tgt.name == self.name and tgt.args == self.args and \ 2077 tgt.proc == self.proc and tgt.pid == self.pid and \ 2078 tgt.ret == self.ret and dt >= 0 and \ 2079 dt <= sysvals.callloopmaxgap and \ 2080 self.length < sysvals.callloopmaxlen: 2081 return True 2082 return False 2083 2084# Class: FTraceLine 2085# Description: 2086# A container for a single line of ftrace data. There are six basic types: 2087# callgraph line: 2088# call: " dpm_run_callback() {" 2089# return: " }" 2090# leaf: " dpm_run_callback();" 2091# trace event: 2092# tracing_mark_write: SUSPEND START or RESUME COMPLETE 2093# suspend_resume: phase or custom exec block data 2094# device_pm_callback: device callback info 2095class FTraceLine: 2096 def __init__(self, t, m='', d=''): 2097 self.length = 0.0 2098 self.fcall = False 2099 self.freturn = False 2100 self.fevent = False 2101 self.fkprobe = False 2102 self.depth = 0 2103 self.name = '' 2104 self.type = '' 2105 self.time = float(t) 2106 if not m and not d: 2107 return 2108 # is this a trace event 2109 if(d == 'traceevent' or re.match('^ *\/\* *(?P<msg>.*) \*\/ *$', m)): 2110 if(d == 'traceevent'): 2111 # nop format trace event 2112 msg = m 2113 else: 2114 # function_graph format trace event 2115 em = re.match('^ *\/\* *(?P<msg>.*) \*\/ *$', m) 2116 msg = em.group('msg') 2117 2118 emm = re.match('^(?P<call>.*?): (?P<msg>.*)', msg) 2119 if(emm): 2120 self.name = emm.group('msg') 2121 self.type = emm.group('call') 2122 else: 2123 self.name = msg 2124 km = re.match('^(?P<n>.*)_cal$', self.type) 2125 if km: 2126 self.fcall = True 2127 self.fkprobe = True 2128 self.type = km.group('n') 2129 return 2130 km = re.match('^(?P<n>.*)_ret$', self.type) 2131 if km: 2132 self.freturn = True 2133 self.fkprobe = True 2134 self.type = km.group('n') 2135 return 2136 self.fevent = True 2137 return 2138 # convert the duration to seconds 2139 if(d): 2140 self.length = float(d)/1000000 2141 # the indentation determines the depth 2142 match = re.match('^(?P<d> *)(?P<o>.*)$', m) 2143 if(not match): 2144 return 2145 self.depth = self.getDepth(match.group('d')) 2146 m = match.group('o') 2147 # function return 2148 if(m[0] == '}'): 2149 self.freturn = True 2150 if(len(m) > 1): 2151 # includes comment with function name 2152 match = re.match('^} *\/\* *(?P<n>.*) *\*\/$', m) 2153 if(match): 2154 self.name = match.group('n').strip() 2155 # function call 2156 else: 2157 self.fcall = True 2158 # function call with children 2159 if(m[-1] == '{'): 2160 match = re.match('^(?P<n>.*) *\(.*', m) 2161 if(match): 2162 self.name = match.group('n').strip() 2163 # function call with no children (leaf) 2164 elif(m[-1] == ';'): 2165 self.freturn = True 2166 match = re.match('^(?P<n>.*) *\(.*', m) 2167 if(match): 2168 self.name = match.group('n').strip() 2169 # something else (possibly a trace marker) 2170 else: 2171 self.name = m 2172 def isCall(self): 2173 return self.fcall and not self.freturn 2174 def isReturn(self): 2175 return self.freturn and not self.fcall 2176 def isLeaf(self): 2177 return self.fcall and self.freturn 2178 def getDepth(self, str): 2179 return len(str)/2 2180 def debugPrint(self, info=''): 2181 if self.isLeaf(): 2182 pprint(' -- %12.6f (depth=%02d): %s(); (%.3f us) %s' % (self.time, \ 2183 self.depth, self.name, self.length*1000000, info)) 2184 elif self.freturn: 2185 pprint(' -- %12.6f (depth=%02d): %s} (%.3f us) %s' % (self.time, \ 2186 self.depth, self.name, self.length*1000000, info)) 2187 else: 2188 pprint(' -- %12.6f (depth=%02d): %s() { (%.3f us) %s' % (self.time, \ 2189 self.depth, self.name, self.length*1000000, info)) 2190 def startMarker(self): 2191 # Is this the starting line of a suspend? 2192 if not self.fevent: 2193 return False 2194 if sysvals.usetracemarkers: 2195 if(self.name.startswith('SUSPEND START')): 2196 return True 2197 return False 2198 else: 2199 if(self.type == 'suspend_resume' and 2200 re.match('suspend_enter\[.*\] begin', self.name)): 2201 return True 2202 return False 2203 def endMarker(self): 2204 # Is this the ending line of a resume? 2205 if not self.fevent: 2206 return False 2207 if sysvals.usetracemarkers: 2208 if(self.name.startswith('RESUME COMPLETE')): 2209 return True 2210 return False 2211 else: 2212 if(self.type == 'suspend_resume' and 2213 re.match('thaw_processes\[.*\] end', self.name)): 2214 return True 2215 return False 2216 2217# Class: FTraceCallGraph 2218# Description: 2219# A container for the ftrace callgraph of a single recursive function. 2220# This can be a dpm_run_callback, dpm_prepare, or dpm_complete callgraph 2221# Each instance is tied to a single device in a single phase, and is 2222# comprised of an ordered list of FTraceLine objects 2223class FTraceCallGraph: 2224 vfname = 'missing_function_name' 2225 def __init__(self, pid, sv): 2226 self.id = '' 2227 self.invalid = False 2228 self.name = '' 2229 self.partial = False 2230 self.ignore = False 2231 self.start = -1.0 2232 self.end = -1.0 2233 self.list = [] 2234 self.depth = 0 2235 self.pid = pid 2236 self.sv = sv 2237 def addLine(self, line): 2238 # if this is already invalid, just leave 2239 if(self.invalid): 2240 if(line.depth == 0 and line.freturn): 2241 return 1 2242 return 0 2243 # invalidate on bad depth 2244 if(self.depth < 0): 2245 self.invalidate(line) 2246 return 0 2247 # ignore data til we return to the current depth 2248 if self.ignore: 2249 if line.depth > self.depth: 2250 return 0 2251 else: 2252 self.list[-1].freturn = True 2253 self.list[-1].length = line.time - self.list[-1].time 2254 self.ignore = False 2255 # if this is a return at self.depth, no more work is needed 2256 if line.depth == self.depth and line.isReturn(): 2257 if line.depth == 0: 2258 self.end = line.time 2259 return 1 2260 return 0 2261 # compare current depth with this lines pre-call depth 2262 prelinedep = line.depth 2263 if line.isReturn(): 2264 prelinedep += 1 2265 last = 0 2266 lasttime = line.time 2267 if len(self.list) > 0: 2268 last = self.list[-1] 2269 lasttime = last.time 2270 if last.isLeaf(): 2271 lasttime += last.length 2272 # handle low misalignments by inserting returns 2273 mismatch = prelinedep - self.depth 2274 warning = self.sv.verbose and abs(mismatch) > 1 2275 info = [] 2276 if mismatch < 0: 2277 idx = 0 2278 # add return calls to get the depth down 2279 while prelinedep < self.depth: 2280 self.depth -= 1 2281 if idx == 0 and last and last.isCall(): 2282 # special case, turn last call into a leaf 2283 last.depth = self.depth 2284 last.freturn = True 2285 last.length = line.time - last.time 2286 if warning: 2287 info.append(('[make leaf]', last)) 2288 else: 2289 vline = FTraceLine(lasttime) 2290 vline.depth = self.depth 2291 vline.name = self.vfname 2292 vline.freturn = True 2293 self.list.append(vline) 2294 if warning: 2295 if idx == 0: 2296 info.append(('', last)) 2297 info.append(('[add return]', vline)) 2298 idx += 1 2299 if warning: 2300 info.append(('', line)) 2301 # handle high misalignments by inserting calls 2302 elif mismatch > 0: 2303 idx = 0 2304 if warning: 2305 info.append(('', last)) 2306 # add calls to get the depth up 2307 while prelinedep > self.depth: 2308 if idx == 0 and line.isReturn(): 2309 # special case, turn this return into a leaf 2310 line.fcall = True 2311 prelinedep -= 1 2312 if warning: 2313 info.append(('[make leaf]', line)) 2314 else: 2315 vline = FTraceLine(lasttime) 2316 vline.depth = self.depth 2317 vline.name = self.vfname 2318 vline.fcall = True 2319 self.list.append(vline) 2320 self.depth += 1 2321 if not last: 2322 self.start = vline.time 2323 if warning: 2324 info.append(('[add call]', vline)) 2325 idx += 1 2326 if warning and ('[make leaf]', line) not in info: 2327 info.append(('', line)) 2328 if warning: 2329 pprint('WARNING: ftrace data missing, corrections made:') 2330 for i in info: 2331 t, obj = i 2332 if obj: 2333 obj.debugPrint(t) 2334 # process the call and set the new depth 2335 skipadd = False 2336 md = self.sv.max_graph_depth 2337 if line.isCall(): 2338 # ignore blacklisted/overdepth funcs 2339 if (md and self.depth >= md - 1) or (line.name in self.sv.cgblacklist): 2340 self.ignore = True 2341 else: 2342 self.depth += 1 2343 elif line.isReturn(): 2344 self.depth -= 1 2345 # remove blacklisted/overdepth/empty funcs that slipped through 2346 if (last and last.isCall() and last.depth == line.depth) or \ 2347 (md and last and last.depth >= md) or \ 2348 (line.name in self.sv.cgblacklist): 2349 while len(self.list) > 0 and self.list[-1].depth > line.depth: 2350 self.list.pop(-1) 2351 if len(self.list) == 0: 2352 self.invalid = True 2353 return 1 2354 self.list[-1].freturn = True 2355 self.list[-1].length = line.time - self.list[-1].time 2356 self.list[-1].name = line.name 2357 skipadd = True 2358 if len(self.list) < 1: 2359 self.start = line.time 2360 # check for a mismatch that returned all the way to callgraph end 2361 res = 1 2362 if mismatch < 0 and self.list[-1].depth == 0 and self.list[-1].freturn: 2363 line = self.list[-1] 2364 skipadd = True 2365 res = -1 2366 if not skipadd: 2367 self.list.append(line) 2368 if(line.depth == 0 and line.freturn): 2369 if(self.start < 0): 2370 self.start = line.time 2371 self.end = line.time 2372 if line.fcall: 2373 self.end += line.length 2374 if self.list[0].name == self.vfname: 2375 self.invalid = True 2376 if res == -1: 2377 self.partial = True 2378 return res 2379 return 0 2380 def invalidate(self, line): 2381 if(len(self.list) > 0): 2382 first = self.list[0] 2383 self.list = [] 2384 self.list.append(first) 2385 self.invalid = True 2386 id = 'task %s' % (self.pid) 2387 window = '(%f - %f)' % (self.start, line.time) 2388 if(self.depth < 0): 2389 pprint('Data misalignment for '+id+\ 2390 ' (buffer overflow), ignoring this callback') 2391 else: 2392 pprint('Too much data for '+id+\ 2393 ' '+window+', ignoring this callback') 2394 def slice(self, dev): 2395 minicg = FTraceCallGraph(dev['pid'], self.sv) 2396 minicg.name = self.name 2397 mydepth = -1 2398 good = False 2399 for l in self.list: 2400 if(l.time < dev['start'] or l.time > dev['end']): 2401 continue 2402 if mydepth < 0: 2403 if l.name == 'mutex_lock' and l.freturn: 2404 mydepth = l.depth 2405 continue 2406 elif l.depth == mydepth and l.name == 'mutex_unlock' and l.fcall: 2407 good = True 2408 break 2409 l.depth -= mydepth 2410 minicg.addLine(l) 2411 if not good or len(minicg.list) < 1: 2412 return 0 2413 return minicg 2414 def repair(self, enddepth): 2415 # bring the depth back to 0 with additional returns 2416 fixed = False 2417 last = self.list[-1] 2418 for i in reversed(range(enddepth)): 2419 t = FTraceLine(last.time) 2420 t.depth = i 2421 t.freturn = True 2422 fixed = self.addLine(t) 2423 if fixed != 0: 2424 self.end = last.time 2425 return True 2426 return False 2427 def postProcess(self): 2428 if len(self.list) > 0: 2429 self.name = self.list[0].name 2430 stack = dict() 2431 cnt = 0 2432 last = 0 2433 for l in self.list: 2434 # ftrace bug: reported duration is not reliable 2435 # check each leaf and clip it at max possible length 2436 if last and last.isLeaf(): 2437 if last.length > l.time - last.time: 2438 last.length = l.time - last.time 2439 if l.isCall(): 2440 stack[l.depth] = l 2441 cnt += 1 2442 elif l.isReturn(): 2443 if(l.depth not in stack): 2444 if self.sv.verbose: 2445 pprint('Post Process Error: Depth missing') 2446 l.debugPrint() 2447 return False 2448 # calculate call length from call/return lines 2449 cl = stack[l.depth] 2450 cl.length = l.time - cl.time 2451 if cl.name == self.vfname: 2452 cl.name = l.name 2453 stack.pop(l.depth) 2454 l.length = 0 2455 cnt -= 1 2456 last = l 2457 if(cnt == 0): 2458 # trace caught the whole call tree 2459 return True 2460 elif(cnt < 0): 2461 if self.sv.verbose: 2462 pprint('Post Process Error: Depth is less than 0') 2463 return False 2464 # trace ended before call tree finished 2465 return self.repair(cnt) 2466 def deviceMatch(self, pid, data): 2467 found = '' 2468 # add the callgraph data to the device hierarchy 2469 borderphase = { 2470 'dpm_prepare': 'suspend_prepare', 2471 'dpm_complete': 'resume_complete' 2472 } 2473 if(self.name in borderphase): 2474 p = borderphase[self.name] 2475 list = data.dmesg[p]['list'] 2476 for devname in list: 2477 dev = list[devname] 2478 if(pid == dev['pid'] and 2479 self.start <= dev['start'] and 2480 self.end >= dev['end']): 2481 cg = self.slice(dev) 2482 if cg: 2483 dev['ftrace'] = cg 2484 found = devname 2485 return found 2486 for p in data.sortedPhases(): 2487 if(data.dmesg[p]['start'] <= self.start and 2488 self.start <= data.dmesg[p]['end']): 2489 list = data.dmesg[p]['list'] 2490 for devname in sorted(list, key=lambda k:list[k]['start']): 2491 dev = list[devname] 2492 if(pid == dev['pid'] and 2493 self.start <= dev['start'] and 2494 self.end >= dev['end']): 2495 dev['ftrace'] = self 2496 found = devname 2497 break 2498 break 2499 return found 2500 def newActionFromFunction(self, data): 2501 name = self.name 2502 if name in ['dpm_run_callback', 'dpm_prepare', 'dpm_complete']: 2503 return 2504 fs = self.start 2505 fe = self.end 2506 if fs < data.start or fe > data.end: 2507 return 2508 phase = '' 2509 for p in data.sortedPhases(): 2510 if(data.dmesg[p]['start'] <= self.start and 2511 self.start < data.dmesg[p]['end']): 2512 phase = p 2513 break 2514 if not phase: 2515 return 2516 out = data.newActionGlobal(name, fs, fe, -2) 2517 if out: 2518 phase, myname = out 2519 data.dmesg[phase]['list'][myname]['ftrace'] = self 2520 def debugPrint(self, info=''): 2521 pprint('%s pid=%d [%f - %f] %.3f us' % \ 2522 (self.name, self.pid, self.start, self.end, 2523 (self.end - self.start)*1000000)) 2524 for l in self.list: 2525 if l.isLeaf(): 2526 pprint('%f (%02d): %s(); (%.3f us)%s' % (l.time, \ 2527 l.depth, l.name, l.length*1000000, info)) 2528 elif l.freturn: 2529 pprint('%f (%02d): %s} (%.3f us)%s' % (l.time, \ 2530 l.depth, l.name, l.length*1000000, info)) 2531 else: 2532 pprint('%f (%02d): %s() { (%.3f us)%s' % (l.time, \ 2533 l.depth, l.name, l.length*1000000, info)) 2534 pprint(' ') 2535 2536class DevItem: 2537 def __init__(self, test, phase, dev): 2538 self.test = test 2539 self.phase = phase 2540 self.dev = dev 2541 def isa(self, cls): 2542 if 'htmlclass' in self.dev and cls in self.dev['htmlclass']: 2543 return True 2544 return False 2545 2546# Class: Timeline 2547# Description: 2548# A container for a device timeline which calculates 2549# all the html properties to display it correctly 2550class Timeline: 2551 html_tblock = '<div id="block{0}" class="tblock" style="left:{1}%;width:{2}%;"><div class="tback" style="height:{3}px"></div>\n' 2552 html_device = '<div id="{0}" title="{1}" class="thread{7}" style="left:{2}%;top:{3}px;height:{4}px;width:{5}%;{8}">{6}</div>\n' 2553 html_phase = '<div class="phase" style="left:{0}%;width:{1}%;top:{2}px;height:{3}px;background:{4}">{5}</div>\n' 2554 html_phaselet = '<div id="{0}" class="phaselet" style="left:{1}%;width:{2}%;background:{3}"></div>\n' 2555 html_legend = '<div id="p{3}" class="square" style="left:{0}%;background:{1}"> {2}</div>\n' 2556 def __init__(self, rowheight, scaleheight): 2557 self.html = '' 2558 self.height = 0 # total timeline height 2559 self.scaleH = scaleheight # timescale (top) row height 2560 self.rowH = rowheight # device row height 2561 self.bodyH = 0 # body height 2562 self.rows = 0 # total timeline rows 2563 self.rowlines = dict() 2564 self.rowheight = dict() 2565 def createHeader(self, sv, stamp): 2566 if(not stamp['time']): 2567 return 2568 self.html += '<div class="version"><a href="https://01.org/pm-graph">%s v%s</a></div>' \ 2569 % (sv.title, sv.version) 2570 if sv.logmsg and sv.testlog: 2571 self.html += '<button id="showtest" class="logbtn btnfmt">log</button>' 2572 if sv.dmesglog: 2573 self.html += '<button id="showdmesg" class="logbtn btnfmt">dmesg</button>' 2574 if sv.ftracelog: 2575 self.html += '<button id="showftrace" class="logbtn btnfmt">ftrace</button>' 2576 headline_stamp = '<div class="stamp">{0} {1} {2} {3}</div>\n' 2577 self.html += headline_stamp.format(stamp['host'], stamp['kernel'], 2578 stamp['mode'], stamp['time']) 2579 if 'man' in stamp and 'plat' in stamp and 'cpu' in stamp and \ 2580 stamp['man'] and stamp['plat'] and stamp['cpu']: 2581 headline_sysinfo = '<div class="stamp sysinfo">{0} {1} <i>with</i> {2}</div>\n' 2582 self.html += headline_sysinfo.format(stamp['man'], stamp['plat'], stamp['cpu']) 2583 2584 # Function: getDeviceRows 2585 # Description: 2586 # determine how may rows the device funcs will take 2587 # Arguments: 2588 # rawlist: the list of devices/actions for a single phase 2589 # Output: 2590 # The total number of rows needed to display this phase of the timeline 2591 def getDeviceRows(self, rawlist): 2592 # clear all rows and set them to undefined 2593 sortdict = dict() 2594 for item in rawlist: 2595 item.row = -1 2596 sortdict[item] = item.length 2597 sortlist = sorted(sortdict, key=sortdict.get, reverse=True) 2598 remaining = len(sortlist) 2599 rowdata = dict() 2600 row = 1 2601 # try to pack each row with as many ranges as possible 2602 while(remaining > 0): 2603 if(row not in rowdata): 2604 rowdata[row] = [] 2605 for i in sortlist: 2606 if(i.row >= 0): 2607 continue 2608 s = i.time 2609 e = i.time + i.length 2610 valid = True 2611 for ritem in rowdata[row]: 2612 rs = ritem.time 2613 re = ritem.time + ritem.length 2614 if(not (((s <= rs) and (e <= rs)) or 2615 ((s >= re) and (e >= re)))): 2616 valid = False 2617 break 2618 if(valid): 2619 rowdata[row].append(i) 2620 i.row = row 2621 remaining -= 1 2622 row += 1 2623 return row 2624 # Function: getPhaseRows 2625 # Description: 2626 # Organize the timeline entries into the smallest 2627 # number of rows possible, with no entry overlapping 2628 # Arguments: 2629 # devlist: the list of devices/actions in a group of contiguous phases 2630 # Output: 2631 # The total number of rows needed to display this phase of the timeline 2632 def getPhaseRows(self, devlist, row=0, sortby='length'): 2633 # clear all rows and set them to undefined 2634 remaining = len(devlist) 2635 rowdata = dict() 2636 sortdict = dict() 2637 myphases = [] 2638 # initialize all device rows to -1 and calculate devrows 2639 for item in devlist: 2640 dev = item.dev 2641 tp = (item.test, item.phase) 2642 if tp not in myphases: 2643 myphases.append(tp) 2644 dev['row'] = -1 2645 if sortby == 'start': 2646 # sort by start 1st, then length 2nd 2647 sortdict[item] = (-1*float(dev['start']), float(dev['end']) - float(dev['start'])) 2648 else: 2649 # sort by length 1st, then name 2nd 2650 sortdict[item] = (float(dev['end']) - float(dev['start']), item.dev['name']) 2651 if 'src' in dev: 2652 dev['devrows'] = self.getDeviceRows(dev['src']) 2653 # sort the devlist by length so that large items graph on top 2654 sortlist = sorted(sortdict, key=sortdict.get, reverse=True) 2655 orderedlist = [] 2656 for item in sortlist: 2657 if item.dev['pid'] == -2: 2658 orderedlist.append(item) 2659 for item in sortlist: 2660 if item not in orderedlist: 2661 orderedlist.append(item) 2662 # try to pack each row with as many devices as possible 2663 while(remaining > 0): 2664 rowheight = 1 2665 if(row not in rowdata): 2666 rowdata[row] = [] 2667 for item in orderedlist: 2668 dev = item.dev 2669 if(dev['row'] < 0): 2670 s = dev['start'] 2671 e = dev['end'] 2672 valid = True 2673 for ritem in rowdata[row]: 2674 rs = ritem.dev['start'] 2675 re = ritem.dev['end'] 2676 if(not (((s <= rs) and (e <= rs)) or 2677 ((s >= re) and (e >= re)))): 2678 valid = False 2679 break 2680 if(valid): 2681 rowdata[row].append(item) 2682 dev['row'] = row 2683 remaining -= 1 2684 if 'devrows' in dev and dev['devrows'] > rowheight: 2685 rowheight = dev['devrows'] 2686 for t, p in myphases: 2687 if t not in self.rowlines or t not in self.rowheight: 2688 self.rowlines[t] = dict() 2689 self.rowheight[t] = dict() 2690 if p not in self.rowlines[t] or p not in self.rowheight[t]: 2691 self.rowlines[t][p] = dict() 2692 self.rowheight[t][p] = dict() 2693 rh = self.rowH 2694 # section headers should use a different row height 2695 if len(rowdata[row]) == 1 and \ 2696 'htmlclass' in rowdata[row][0].dev and \ 2697 'sec' in rowdata[row][0].dev['htmlclass']: 2698 rh = 15 2699 self.rowlines[t][p][row] = rowheight 2700 self.rowheight[t][p][row] = rowheight * rh 2701 row += 1 2702 if(row > self.rows): 2703 self.rows = int(row) 2704 return row 2705 def phaseRowHeight(self, test, phase, row): 2706 return self.rowheight[test][phase][row] 2707 def phaseRowTop(self, test, phase, row): 2708 top = 0 2709 for i in sorted(self.rowheight[test][phase]): 2710 if i >= row: 2711 break 2712 top += self.rowheight[test][phase][i] 2713 return top 2714 def calcTotalRows(self): 2715 # Calculate the heights and offsets for the header and rows 2716 maxrows = 0 2717 standardphases = [] 2718 for t in self.rowlines: 2719 for p in self.rowlines[t]: 2720 total = 0 2721 for i in sorted(self.rowlines[t][p]): 2722 total += self.rowlines[t][p][i] 2723 if total > maxrows: 2724 maxrows = total 2725 if total == len(self.rowlines[t][p]): 2726 standardphases.append((t, p)) 2727 self.height = self.scaleH + (maxrows*self.rowH) 2728 self.bodyH = self.height - self.scaleH 2729 # if there is 1 line per row, draw them the standard way 2730 for t, p in standardphases: 2731 for i in sorted(self.rowheight[t][p]): 2732 self.rowheight[t][p][i] = float(self.bodyH)/len(self.rowlines[t][p]) 2733 def createZoomBox(self, mode='command', testcount=1): 2734 # Create bounding box, add buttons 2735 html_zoombox = '<center><button id="zoomin">ZOOM IN +</button><button id="zoomout">ZOOM OUT -</button><button id="zoomdef">ZOOM 1:1</button></center>\n' 2736 html_timeline = '<div id="dmesgzoombox" class="zoombox">\n<div id="{0}" class="timeline" style="height:{1}px">\n' 2737 html_devlist1 = '<button id="devlist1" class="devlist" style="float:left;">Device Detail{0}</button>' 2738 html_devlist2 = '<button id="devlist2" class="devlist" style="float:right;">Device Detail2</button>\n' 2739 if mode != 'command': 2740 if testcount > 1: 2741 self.html += html_devlist2 2742 self.html += html_devlist1.format('1') 2743 else: 2744 self.html += html_devlist1.format('') 2745 self.html += html_zoombox 2746 self.html += html_timeline.format('dmesg', self.height) 2747 # Function: createTimeScale 2748 # Description: 2749 # Create the timescale for a timeline block 2750 # Arguments: 2751 # m0: start time (mode begin) 2752 # mMax: end time (mode end) 2753 # tTotal: total timeline time 2754 # mode: suspend or resume 2755 # Output: 2756 # The html code needed to display the time scale 2757 def createTimeScale(self, m0, mMax, tTotal, mode): 2758 timescale = '<div class="t" style="right:{0}%">{1}</div>\n' 2759 rline = '<div class="t" style="left:0;border-left:1px solid black;border-right:0;">{0}</div>\n' 2760 output = '<div class="timescale">\n' 2761 # set scale for timeline 2762 mTotal = mMax - m0 2763 tS = 0.1 2764 if(tTotal <= 0): 2765 return output+'</div>\n' 2766 if(tTotal > 4): 2767 tS = 1 2768 divTotal = int(mTotal/tS) + 1 2769 divEdge = (mTotal - tS*(divTotal-1))*100/mTotal 2770 for i in range(divTotal): 2771 htmlline = '' 2772 if(mode == 'suspend'): 2773 pos = '%0.3f' % (100 - ((float(i)*tS*100)/mTotal) - divEdge) 2774 val = '%0.fms' % (float(i-divTotal+1)*tS*1000) 2775 if(i == divTotal - 1): 2776 val = mode 2777 htmlline = timescale.format(pos, val) 2778 else: 2779 pos = '%0.3f' % (100 - ((float(i)*tS*100)/mTotal)) 2780 val = '%0.fms' % (float(i)*tS*1000) 2781 htmlline = timescale.format(pos, val) 2782 if(i == 0): 2783 htmlline = rline.format(mode) 2784 output += htmlline 2785 self.html += output+'</div>\n' 2786 2787# Class: TestProps 2788# Description: 2789# A list of values describing the properties of these test runs 2790class TestProps: 2791 stampfmt = '# [a-z]*-(?P<m>[0-9]{2})(?P<d>[0-9]{2})(?P<y>[0-9]{2})-'+\ 2792 '(?P<H>[0-9]{2})(?P<M>[0-9]{2})(?P<S>[0-9]{2})'+\ 2793 ' (?P<host>.*) (?P<mode>.*) (?P<kernel>.*)$' 2794 wififmt = '^# wifi *(?P<d>\S*) *(?P<s>\S*) *(?P<t>[0-9\.]+).*' 2795 tstatfmt = '^# turbostat (?P<t>\S*)' 2796 testerrfmt = '^# enter_sleep_error (?P<e>.*)' 2797 sysinfofmt = '^# sysinfo .*' 2798 cmdlinefmt = '^# command \| (?P<cmd>.*)' 2799 kparamsfmt = '^# kparams \| (?P<kp>.*)' 2800 devpropfmt = '# Device Properties: .*' 2801 pinfofmt = '# platform-(?P<val>[a-z,A-Z,0-9]*): (?P<info>.*)' 2802 tracertypefmt = '# tracer: (?P<t>.*)' 2803 firmwarefmt = '# fwsuspend (?P<s>[0-9]*) fwresume (?P<r>[0-9]*)$' 2804 procexecfmt = 'ps - (?P<ps>.*)$' 2805 ftrace_line_fmt_fg = \ 2806 '^ *(?P<time>[0-9\.]*) *\| *(?P<cpu>[0-9]*)\)'+\ 2807 ' *(?P<proc>.*)-(?P<pid>[0-9]*) *\|'+\ 2808 '[ +!#\*@$]*(?P<dur>[0-9\.]*) .*\| (?P<msg>.*)' 2809 ftrace_line_fmt_nop = \ 2810 ' *(?P<proc>.*)-(?P<pid>[0-9]*) *\[(?P<cpu>[0-9]*)\] *'+\ 2811 '(?P<flags>\S*) *(?P<time>[0-9\.]*): *'+\ 2812 '(?P<msg>.*)' 2813 machinesuspend = 'machine_suspend\[.*' 2814 def __init__(self): 2815 self.stamp = '' 2816 self.sysinfo = '' 2817 self.cmdline = '' 2818 self.testerror = [] 2819 self.turbostat = [] 2820 self.wifi = [] 2821 self.fwdata = [] 2822 self.ftrace_line_fmt = self.ftrace_line_fmt_nop 2823 self.cgformat = False 2824 self.data = 0 2825 self.ktemp = dict() 2826 def setTracerType(self, tracer): 2827 if(tracer == 'function_graph'): 2828 self.cgformat = True 2829 self.ftrace_line_fmt = self.ftrace_line_fmt_fg 2830 elif(tracer == 'nop'): 2831 self.ftrace_line_fmt = self.ftrace_line_fmt_nop 2832 else: 2833 doError('Invalid tracer format: [%s]' % tracer) 2834 def stampInfo(self, line, sv): 2835 if re.match(self.stampfmt, line): 2836 self.stamp = line 2837 return True 2838 elif re.match(self.sysinfofmt, line): 2839 self.sysinfo = line 2840 return True 2841 elif re.match(self.tstatfmt, line): 2842 self.turbostat.append(line) 2843 return True 2844 elif re.match(self.wififmt, line): 2845 self.wifi.append(line) 2846 return True 2847 elif re.match(self.testerrfmt, line): 2848 self.testerror.append(line) 2849 return True 2850 elif re.match(self.firmwarefmt, line): 2851 self.fwdata.append(line) 2852 return True 2853 elif(re.match(self.devpropfmt, line)): 2854 self.parseDevprops(line, sv) 2855 return True 2856 elif(re.match(self.pinfofmt, line)): 2857 self.parsePlatformInfo(line, sv) 2858 return True 2859 m = re.match(self.cmdlinefmt, line) 2860 if m: 2861 self.cmdline = m.group('cmd') 2862 return True 2863 m = re.match(self.tracertypefmt, line) 2864 if(m): 2865 self.setTracerType(m.group('t')) 2866 return True 2867 return False 2868 def parseStamp(self, data, sv): 2869 # global test data 2870 m = re.match(self.stampfmt, self.stamp) 2871 if not self.stamp or not m: 2872 doError('data does not include the expected stamp') 2873 data.stamp = {'time': '', 'host': '', 'mode': ''} 2874 dt = datetime(int(m.group('y'))+2000, int(m.group('m')), 2875 int(m.group('d')), int(m.group('H')), int(m.group('M')), 2876 int(m.group('S'))) 2877 data.stamp['time'] = dt.strftime('%B %d %Y, %I:%M:%S %p') 2878 data.stamp['host'] = m.group('host') 2879 data.stamp['mode'] = m.group('mode') 2880 data.stamp['kernel'] = m.group('kernel') 2881 if re.match(self.sysinfofmt, self.sysinfo): 2882 for f in self.sysinfo.split('|'): 2883 if '#' in f: 2884 continue 2885 tmp = f.strip().split(':', 1) 2886 key = tmp[0] 2887 val = tmp[1] 2888 data.stamp[key] = val 2889 sv.hostname = data.stamp['host'] 2890 sv.suspendmode = data.stamp['mode'] 2891 if sv.suspendmode == 'freeze': 2892 self.machinesuspend = 'timekeeping_freeze\[.*' 2893 else: 2894 self.machinesuspend = 'machine_suspend\[.*' 2895 if sv.suspendmode == 'command' and sv.ftracefile != '': 2896 modes = ['on', 'freeze', 'standby', 'mem', 'disk'] 2897 fp = sv.openlog(sv.ftracefile, 'r') 2898 for line in fp: 2899 m = re.match('.* machine_suspend\[(?P<mode>.*)\]', line) 2900 if m and m.group('mode') in ['1', '2', '3', '4']: 2901 sv.suspendmode = modes[int(m.group('mode'))] 2902 data.stamp['mode'] = sv.suspendmode 2903 break 2904 fp.close() 2905 sv.cmdline = self.cmdline 2906 if not sv.stamp: 2907 sv.stamp = data.stamp 2908 # firmware data 2909 if sv.suspendmode == 'mem' and len(self.fwdata) > data.testnumber: 2910 m = re.match(self.firmwarefmt, self.fwdata[data.testnumber]) 2911 if m: 2912 data.fwSuspend, data.fwResume = int(m.group('s')), int(m.group('r')) 2913 if(data.fwSuspend > 0 or data.fwResume > 0): 2914 data.fwValid = True 2915 # turbostat data 2916 if len(self.turbostat) > data.testnumber: 2917 m = re.match(self.tstatfmt, self.turbostat[data.testnumber]) 2918 if m: 2919 data.turbostat = m.group('t') 2920 # wifi data 2921 if len(self.wifi) > data.testnumber: 2922 m = re.match(self.wififmt, self.wifi[data.testnumber]) 2923 if m: 2924 data.wifi = {'dev': m.group('d'), 'stat': m.group('s'), 2925 'time': float(m.group('t'))} 2926 data.stamp['wifi'] = m.group('d') 2927 # sleep mode enter errors 2928 if len(self.testerror) > data.testnumber: 2929 m = re.match(self.testerrfmt, self.testerror[data.testnumber]) 2930 if m: 2931 data.enterfail = m.group('e') 2932 def devprops(self, data): 2933 props = dict() 2934 devlist = data.split(';') 2935 for dev in devlist: 2936 f = dev.split(',') 2937 if len(f) < 3: 2938 continue 2939 dev = f[0] 2940 props[dev] = DevProps() 2941 props[dev].altname = f[1] 2942 if int(f[2]): 2943 props[dev].isasync = True 2944 else: 2945 props[dev].isasync = False 2946 return props 2947 def parseDevprops(self, line, sv): 2948 idx = line.index(': ') + 2 2949 if idx >= len(line): 2950 return 2951 props = self.devprops(line[idx:]) 2952 if sv.suspendmode == 'command' and 'testcommandstring' in props: 2953 sv.testcommand = props['testcommandstring'].altname 2954 sv.devprops = props 2955 def parsePlatformInfo(self, line, sv): 2956 m = re.match(self.pinfofmt, line) 2957 if not m: 2958 return 2959 name, info = m.group('val'), m.group('info') 2960 if name == 'devinfo': 2961 sv.devprops = self.devprops(sv.b64unzip(info)) 2962 return 2963 elif name == 'testcmd': 2964 sv.testcommand = info 2965 return 2966 field = info.split('|') 2967 if len(field) < 2: 2968 return 2969 cmdline = field[0].strip() 2970 output = sv.b64unzip(field[1].strip()) 2971 sv.platinfo.append([name, cmdline, output]) 2972 2973# Class: TestRun 2974# Description: 2975# A container for a suspend/resume test run. This is necessary as 2976# there could be more than one, and they need to be separate. 2977class TestRun: 2978 def __init__(self, dataobj): 2979 self.data = dataobj 2980 self.ftemp = dict() 2981 self.ttemp = dict() 2982 2983class ProcessMonitor: 2984 def __init__(self): 2985 self.proclist = dict() 2986 self.running = False 2987 def procstat(self): 2988 c = ['cat /proc/[1-9]*/stat 2>/dev/null'] 2989 process = Popen(c, shell=True, stdout=PIPE) 2990 running = dict() 2991 for line in process.stdout: 2992 data = ascii(line).split() 2993 pid = data[0] 2994 name = re.sub('[()]', '', data[1]) 2995 user = int(data[13]) 2996 kern = int(data[14]) 2997 kjiff = ujiff = 0 2998 if pid not in self.proclist: 2999 self.proclist[pid] = {'name' : name, 'user' : user, 'kern' : kern} 3000 else: 3001 val = self.proclist[pid] 3002 ujiff = user - val['user'] 3003 kjiff = kern - val['kern'] 3004 val['user'] = user 3005 val['kern'] = kern 3006 if ujiff > 0 or kjiff > 0: 3007 running[pid] = ujiff + kjiff 3008 process.wait() 3009 out = '' 3010 for pid in running: 3011 jiffies = running[pid] 3012 val = self.proclist[pid] 3013 if out: 3014 out += ',' 3015 out += '%s-%s %d' % (val['name'], pid, jiffies) 3016 return 'ps - '+out 3017 def processMonitor(self, tid): 3018 while self.running: 3019 out = self.procstat() 3020 if out: 3021 sysvals.fsetVal(out, 'trace_marker') 3022 def start(self): 3023 self.thread = Thread(target=self.processMonitor, args=(0,)) 3024 self.running = True 3025 self.thread.start() 3026 def stop(self): 3027 self.running = False 3028 3029# ----------------- FUNCTIONS -------------------- 3030 3031# Function: doesTraceLogHaveTraceEvents 3032# Description: 3033# Quickly determine if the ftrace log has all of the trace events, 3034# markers, and/or kprobes required for primary parsing. 3035def doesTraceLogHaveTraceEvents(): 3036 kpcheck = ['_cal: (', '_ret: ('] 3037 techeck = ['suspend_resume', 'device_pm_callback'] 3038 tmcheck = ['SUSPEND START', 'RESUME COMPLETE'] 3039 sysvals.usekprobes = False 3040 fp = sysvals.openlog(sysvals.ftracefile, 'r') 3041 for line in fp: 3042 # check for kprobes 3043 if not sysvals.usekprobes: 3044 for i in kpcheck: 3045 if i in line: 3046 sysvals.usekprobes = True 3047 # check for all necessary trace events 3048 check = techeck[:] 3049 for i in techeck: 3050 if i in line: 3051 check.remove(i) 3052 techeck = check 3053 # check for all necessary trace markers 3054 check = tmcheck[:] 3055 for i in tmcheck: 3056 if i in line: 3057 check.remove(i) 3058 tmcheck = check 3059 fp.close() 3060 sysvals.usetraceevents = True if len(techeck) < 2 else False 3061 sysvals.usetracemarkers = True if len(tmcheck) == 0 else False 3062 3063# Function: appendIncompleteTraceLog 3064# Description: 3065# [deprecated for kernel 3.15 or newer] 3066# Adds callgraph data which lacks trace event data. This is only 3067# for timelines generated from 3.15 or older 3068# Arguments: 3069# testruns: the array of Data objects obtained from parseKernelLog 3070def appendIncompleteTraceLog(testruns): 3071 # create TestRun vessels for ftrace parsing 3072 testcnt = len(testruns) 3073 testidx = 0 3074 testrun = [] 3075 for data in testruns: 3076 testrun.append(TestRun(data)) 3077 3078 # extract the callgraph and traceevent data 3079 sysvals.vprint('Analyzing the ftrace data (%s)...' % \ 3080 os.path.basename(sysvals.ftracefile)) 3081 tp = TestProps() 3082 tf = sysvals.openlog(sysvals.ftracefile, 'r') 3083 data = 0 3084 for line in tf: 3085 # remove any latent carriage returns 3086 line = line.replace('\r\n', '') 3087 if tp.stampInfo(line, sysvals): 3088 continue 3089 # parse only valid lines, if this is not one move on 3090 m = re.match(tp.ftrace_line_fmt, line) 3091 if(not m): 3092 continue 3093 # gather the basic message data from the line 3094 m_time = m.group('time') 3095 m_pid = m.group('pid') 3096 m_msg = m.group('msg') 3097 if(tp.cgformat): 3098 m_param3 = m.group('dur') 3099 else: 3100 m_param3 = 'traceevent' 3101 if(m_time and m_pid and m_msg): 3102 t = FTraceLine(m_time, m_msg, m_param3) 3103 pid = int(m_pid) 3104 else: 3105 continue 3106 # the line should be a call, return, or event 3107 if(not t.fcall and not t.freturn and not t.fevent): 3108 continue 3109 # look for the suspend start marker 3110 if(t.startMarker()): 3111 data = testrun[testidx].data 3112 tp.parseStamp(data, sysvals) 3113 data.setStart(t.time, t.name) 3114 continue 3115 if(not data): 3116 continue 3117 # find the end of resume 3118 if(t.endMarker()): 3119 data.setEnd(t.time, t.name) 3120 testidx += 1 3121 if(testidx >= testcnt): 3122 break 3123 continue 3124 # trace event processing 3125 if(t.fevent): 3126 continue 3127 # call/return processing 3128 elif sysvals.usecallgraph: 3129 # create a callgraph object for the data 3130 if(pid not in testrun[testidx].ftemp): 3131 testrun[testidx].ftemp[pid] = [] 3132 testrun[testidx].ftemp[pid].append(FTraceCallGraph(pid, sysvals)) 3133 # when the call is finished, see which device matches it 3134 cg = testrun[testidx].ftemp[pid][-1] 3135 res = cg.addLine(t) 3136 if(res != 0): 3137 testrun[testidx].ftemp[pid].append(FTraceCallGraph(pid, sysvals)) 3138 if(res == -1): 3139 testrun[testidx].ftemp[pid][-1].addLine(t) 3140 tf.close() 3141 3142 for test in testrun: 3143 # add the callgraph data to the device hierarchy 3144 for pid in test.ftemp: 3145 for cg in test.ftemp[pid]: 3146 if len(cg.list) < 1 or cg.invalid or (cg.end - cg.start == 0): 3147 continue 3148 if(not cg.postProcess()): 3149 id = 'task %s cpu %s' % (pid, m.group('cpu')) 3150 sysvals.vprint('Sanity check failed for '+\ 3151 id+', ignoring this callback') 3152 continue 3153 callstart = cg.start 3154 callend = cg.end 3155 for p in test.data.sortedPhases(): 3156 if(test.data.dmesg[p]['start'] <= callstart and 3157 callstart <= test.data.dmesg[p]['end']): 3158 list = test.data.dmesg[p]['list'] 3159 for devname in list: 3160 dev = list[devname] 3161 if(pid == dev['pid'] and 3162 callstart <= dev['start'] and 3163 callend >= dev['end']): 3164 dev['ftrace'] = cg 3165 break 3166 3167# Function: parseTraceLog 3168# Description: 3169# Analyze an ftrace log output file generated from this app during 3170# the execution phase. Used when the ftrace log is the primary data source 3171# and includes the suspend_resume and device_pm_callback trace events 3172# The ftrace filename is taken from sysvals 3173# Output: 3174# An array of Data objects 3175def parseTraceLog(live=False): 3176 sysvals.vprint('Analyzing the ftrace data (%s)...' % \ 3177 os.path.basename(sysvals.ftracefile)) 3178 if(os.path.exists(sysvals.ftracefile) == False): 3179 doError('%s does not exist' % sysvals.ftracefile) 3180 if not live: 3181 sysvals.setupAllKprobes() 3182 ksuscalls = ['ksys_sync', 'pm_prepare_console'] 3183 krescalls = ['pm_restore_console'] 3184 tracewatch = ['irq_wakeup'] 3185 if sysvals.usekprobes: 3186 tracewatch += ['sync_filesystems', 'freeze_processes', 'syscore_suspend', 3187 'syscore_resume', 'resume_console', 'thaw_processes', 'CPU_ON', 3188 'CPU_OFF', 'acpi_suspend'] 3189 3190 # extract the callgraph and traceevent data 3191 s2idle_enter = hwsus = False 3192 tp = TestProps() 3193 testruns, testdata = [], [] 3194 testrun, data, limbo = 0, 0, True 3195 tf = sysvals.openlog(sysvals.ftracefile, 'r') 3196 phase = 'suspend_prepare' 3197 for line in tf: 3198 # remove any latent carriage returns 3199 line = line.replace('\r\n', '') 3200 if tp.stampInfo(line, sysvals): 3201 continue 3202 # ignore all other commented lines 3203 if line[0] == '#': 3204 continue 3205 # ftrace line: parse only valid lines 3206 m = re.match(tp.ftrace_line_fmt, line) 3207 if(not m): 3208 continue 3209 # gather the basic message data from the line 3210 m_time = m.group('time') 3211 m_proc = m.group('proc') 3212 m_pid = m.group('pid') 3213 m_msg = m.group('msg') 3214 if(tp.cgformat): 3215 m_param3 = m.group('dur') 3216 else: 3217 m_param3 = 'traceevent' 3218 if(m_time and m_pid and m_msg): 3219 t = FTraceLine(m_time, m_msg, m_param3) 3220 pid = int(m_pid) 3221 else: 3222 continue 3223 # the line should be a call, return, or event 3224 if(not t.fcall and not t.freturn and not t.fevent): 3225 continue 3226 # find the start of suspend 3227 if(t.startMarker()): 3228 data, limbo = Data(len(testdata)), False 3229 testdata.append(data) 3230 testrun = TestRun(data) 3231 testruns.append(testrun) 3232 tp.parseStamp(data, sysvals) 3233 data.setStart(t.time, t.name) 3234 data.first_suspend_prepare = True 3235 phase = data.setPhase('suspend_prepare', t.time, True) 3236 continue 3237 if(not data or limbo): 3238 continue 3239 # process cpu exec line 3240 if t.type == 'tracing_mark_write': 3241 m = re.match(tp.procexecfmt, t.name) 3242 if(m): 3243 proclist = dict() 3244 for ps in m.group('ps').split(','): 3245 val = ps.split() 3246 if not val: 3247 continue 3248 name = val[0].replace('--', '-') 3249 proclist[name] = int(val[1]) 3250 data.pstl[t.time] = proclist 3251 continue 3252 # find the end of resume 3253 if(t.endMarker()): 3254 if data.tKernRes == 0: 3255 data.tKernRes = t.time 3256 data.handleEndMarker(t.time, t.name) 3257 if(not sysvals.usetracemarkers): 3258 # no trace markers? then quit and be sure to finish recording 3259 # the event we used to trigger resume end 3260 if('thaw_processes' in testrun.ttemp and len(testrun.ttemp['thaw_processes']) > 0): 3261 # if an entry exists, assume this is its end 3262 testrun.ttemp['thaw_processes'][-1]['end'] = t.time 3263 limbo = True 3264 continue 3265 # trace event processing 3266 if(t.fevent): 3267 if(t.type == 'suspend_resume'): 3268 # suspend_resume trace events have two types, begin and end 3269 if(re.match('(?P<name>.*) begin$', t.name)): 3270 isbegin = True 3271 elif(re.match('(?P<name>.*) end$', t.name)): 3272 isbegin = False 3273 else: 3274 continue 3275 if '[' in t.name: 3276 m = re.match('(?P<name>.*)\[.*', t.name) 3277 else: 3278 m = re.match('(?P<name>.*) .*', t.name) 3279 name = m.group('name') 3280 # ignore these events 3281 if(name.split('[')[0] in tracewatch): 3282 continue 3283 # -- phase changes -- 3284 # start of kernel suspend 3285 if(re.match('suspend_enter\[.*', t.name)): 3286 if(isbegin and data.tKernSus == 0): 3287 data.tKernSus = t.time 3288 continue 3289 # suspend_prepare start 3290 elif(re.match('dpm_prepare\[.*', t.name)): 3291 if isbegin and data.first_suspend_prepare: 3292 data.first_suspend_prepare = False 3293 if data.tKernSus == 0: 3294 data.tKernSus = t.time 3295 continue 3296 phase = data.setPhase('suspend_prepare', t.time, isbegin) 3297 continue 3298 # suspend start 3299 elif(re.match('dpm_suspend\[.*', t.name)): 3300 phase = data.setPhase('suspend', t.time, isbegin) 3301 continue 3302 # suspend_late start 3303 elif(re.match('dpm_suspend_late\[.*', t.name)): 3304 phase = data.setPhase('suspend_late', t.time, isbegin) 3305 continue 3306 # suspend_noirq start 3307 elif(re.match('dpm_suspend_noirq\[.*', t.name)): 3308 phase = data.setPhase('suspend_noirq', t.time, isbegin) 3309 continue 3310 # suspend_machine/resume_machine 3311 elif(re.match(tp.machinesuspend, t.name)): 3312 lp = data.lastPhase() 3313 if(isbegin): 3314 hwsus = True 3315 if lp.startswith('resume_machine'): 3316 # trim out s2idle loops, track time trying to freeze 3317 llp = data.lastPhase(2) 3318 if llp.startswith('suspend_machine'): 3319 if 'trying' not in data.dmesg[llp]: 3320 data.dmesg[llp]['trying'] = 0 3321 data.dmesg[llp]['trying'] += \ 3322 t.time - data.dmesg[lp]['start'] 3323 data.currphase = '' 3324 del data.dmesg[lp] 3325 continue 3326 phase = data.setPhase('suspend_machine', data.dmesg[lp]['end'], True) 3327 data.setPhase(phase, t.time, False) 3328 if data.tSuspended == 0: 3329 data.tSuspended = t.time 3330 else: 3331 if lp.startswith('resume_machine'): 3332 data.dmesg[lp]['end'] = t.time 3333 continue 3334 phase = data.setPhase('resume_machine', t.time, True) 3335 if(sysvals.suspendmode in ['mem', 'disk']): 3336 susp = phase.replace('resume', 'suspend') 3337 if susp in data.dmesg: 3338 data.dmesg[susp]['end'] = t.time 3339 data.tSuspended = t.time 3340 data.tResumed = t.time 3341 continue 3342 # resume_noirq start 3343 elif(re.match('dpm_resume_noirq\[.*', t.name)): 3344 phase = data.setPhase('resume_noirq', t.time, isbegin) 3345 continue 3346 # resume_early start 3347 elif(re.match('dpm_resume_early\[.*', t.name)): 3348 phase = data.setPhase('resume_early', t.time, isbegin) 3349 continue 3350 # resume start 3351 elif(re.match('dpm_resume\[.*', t.name)): 3352 phase = data.setPhase('resume', t.time, isbegin) 3353 continue 3354 # resume complete start 3355 elif(re.match('dpm_complete\[.*', t.name)): 3356 phase = data.setPhase('resume_complete', t.time, isbegin) 3357 continue 3358 # skip trace events inside devices calls 3359 if(not data.isTraceEventOutsideDeviceCalls(pid, t.time)): 3360 continue 3361 # global events (outside device calls) are graphed 3362 if(name not in testrun.ttemp): 3363 testrun.ttemp[name] = [] 3364 # special handling for s2idle_enter 3365 if name == 'machine_suspend': 3366 if hwsus: 3367 s2idle_enter = hwsus = False 3368 elif s2idle_enter and not isbegin: 3369 if(len(testrun.ttemp[name]) > 0): 3370 testrun.ttemp[name][-1]['end'] = t.time 3371 testrun.ttemp[name][-1]['loop'] += 1 3372 elif not s2idle_enter and isbegin: 3373 s2idle_enter = True 3374 testrun.ttemp[name].append({'begin': t.time, 3375 'end': t.time, 'pid': pid, 'loop': 0}) 3376 continue 3377 if(isbegin): 3378 # create a new list entry 3379 testrun.ttemp[name].append(\ 3380 {'begin': t.time, 'end': t.time, 'pid': pid}) 3381 else: 3382 if(len(testrun.ttemp[name]) > 0): 3383 # if an entry exists, assume this is its end 3384 testrun.ttemp[name][-1]['end'] = t.time 3385 # device callback start 3386 elif(t.type == 'device_pm_callback_start'): 3387 if phase not in data.dmesg: 3388 continue 3389 m = re.match('(?P<drv>.*) (?P<d>.*), parent: *(?P<p>.*), .*',\ 3390 t.name); 3391 if(not m): 3392 continue 3393 drv = m.group('drv') 3394 n = m.group('d') 3395 p = m.group('p') 3396 if(n and p): 3397 data.newAction(phase, n, pid, p, t.time, -1, drv) 3398 if pid not in data.devpids: 3399 data.devpids.append(pid) 3400 # device callback finish 3401 elif(t.type == 'device_pm_callback_end'): 3402 if phase not in data.dmesg: 3403 continue 3404 m = re.match('(?P<drv>.*) (?P<d>.*), err.*', t.name); 3405 if(not m): 3406 continue 3407 n = m.group('d') 3408 dev = data.findDevice(phase, n) 3409 if dev: 3410 dev['length'] = t.time - dev['start'] 3411 dev['end'] = t.time 3412 # kprobe event processing 3413 elif(t.fkprobe): 3414 kprobename = t.type 3415 kprobedata = t.name 3416 key = (kprobename, pid) 3417 # displayname is generated from kprobe data 3418 displayname = '' 3419 if(t.fcall): 3420 displayname = sysvals.kprobeDisplayName(kprobename, kprobedata) 3421 if not displayname: 3422 continue 3423 if(key not in tp.ktemp): 3424 tp.ktemp[key] = [] 3425 tp.ktemp[key].append({ 3426 'pid': pid, 3427 'begin': t.time, 3428 'end': -1, 3429 'name': displayname, 3430 'cdata': kprobedata, 3431 'proc': m_proc, 3432 }) 3433 # start of kernel resume 3434 if(data.tKernSus == 0 and phase == 'suspend_prepare' \ 3435 and kprobename in ksuscalls): 3436 data.tKernSus = t.time 3437 elif(t.freturn): 3438 if(key not in tp.ktemp) or len(tp.ktemp[key]) < 1: 3439 continue 3440 e = next((x for x in reversed(tp.ktemp[key]) if x['end'] < 0), 0) 3441 if not e: 3442 continue 3443 e['end'] = t.time 3444 e['rdata'] = kprobedata 3445 # end of kernel resume 3446 if(phase != 'suspend_prepare' and kprobename in krescalls): 3447 if phase in data.dmesg: 3448 data.dmesg[phase]['end'] = t.time 3449 data.tKernRes = t.time 3450 3451 # callgraph processing 3452 elif sysvals.usecallgraph: 3453 # create a callgraph object for the data 3454 key = (m_proc, pid) 3455 if(key not in testrun.ftemp): 3456 testrun.ftemp[key] = [] 3457 testrun.ftemp[key].append(FTraceCallGraph(pid, sysvals)) 3458 # when the call is finished, see which device matches it 3459 cg = testrun.ftemp[key][-1] 3460 res = cg.addLine(t) 3461 if(res != 0): 3462 testrun.ftemp[key].append(FTraceCallGraph(pid, sysvals)) 3463 if(res == -1): 3464 testrun.ftemp[key][-1].addLine(t) 3465 tf.close() 3466 if len(testdata) < 1: 3467 sysvals.vprint('WARNING: ftrace start marker is missing') 3468 if data and not data.devicegroups: 3469 sysvals.vprint('WARNING: ftrace end marker is missing') 3470 data.handleEndMarker(t.time, t.name) 3471 3472 if sysvals.suspendmode == 'command': 3473 for test in testruns: 3474 for p in test.data.sortedPhases(): 3475 if p == 'suspend_prepare': 3476 test.data.dmesg[p]['start'] = test.data.start 3477 test.data.dmesg[p]['end'] = test.data.end 3478 else: 3479 test.data.dmesg[p]['start'] = test.data.end 3480 test.data.dmesg[p]['end'] = test.data.end 3481 test.data.tSuspended = test.data.end 3482 test.data.tResumed = test.data.end 3483 test.data.fwValid = False 3484 3485 # dev source and procmon events can be unreadable with mixed phase height 3486 if sysvals.usedevsrc or sysvals.useprocmon: 3487 sysvals.mixedphaseheight = False 3488 3489 # expand phase boundaries so there are no gaps 3490 for data in testdata: 3491 lp = data.sortedPhases()[0] 3492 for p in data.sortedPhases(): 3493 if(p != lp and not ('machine' in p and 'machine' in lp)): 3494 data.dmesg[lp]['end'] = data.dmesg[p]['start'] 3495 lp = p 3496 3497 for i in range(len(testruns)): 3498 test = testruns[i] 3499 data = test.data 3500 # find the total time range for this test (begin, end) 3501 tlb, tle = data.start, data.end 3502 if i < len(testruns) - 1: 3503 tle = testruns[i+1].data.start 3504 # add the process usage data to the timeline 3505 if sysvals.useprocmon: 3506 data.createProcessUsageEvents() 3507 # add the traceevent data to the device hierarchy 3508 if(sysvals.usetraceevents): 3509 # add actual trace funcs 3510 for name in sorted(test.ttemp): 3511 for event in test.ttemp[name]: 3512 if event['end'] - event['begin'] <= 0: 3513 continue 3514 title = name 3515 if name == 'machine_suspend' and 'loop' in event: 3516 title = 's2idle_enter_%dx' % event['loop'] 3517 data.newActionGlobal(title, event['begin'], event['end'], event['pid']) 3518 # add the kprobe based virtual tracefuncs as actual devices 3519 for key in sorted(tp.ktemp): 3520 name, pid = key 3521 if name not in sysvals.tracefuncs: 3522 continue 3523 if pid not in data.devpids: 3524 data.devpids.append(pid) 3525 for e in tp.ktemp[key]: 3526 kb, ke = e['begin'], e['end'] 3527 if ke - kb < 0.000001 or tlb > kb or tle <= kb: 3528 continue 3529 color = sysvals.kprobeColor(name) 3530 data.newActionGlobal(e['name'], kb, ke, pid, color) 3531 # add config base kprobes and dev kprobes 3532 if sysvals.usedevsrc: 3533 for key in sorted(tp.ktemp): 3534 name, pid = key 3535 if name in sysvals.tracefuncs or name not in sysvals.dev_tracefuncs: 3536 continue 3537 for e in tp.ktemp[key]: 3538 kb, ke = e['begin'], e['end'] 3539 if ke - kb < 0.000001 or tlb > kb or tle <= kb: 3540 continue 3541 data.addDeviceFunctionCall(e['name'], name, e['proc'], pid, kb, 3542 ke, e['cdata'], e['rdata']) 3543 if sysvals.usecallgraph: 3544 # add the callgraph data to the device hierarchy 3545 sortlist = dict() 3546 for key in sorted(test.ftemp): 3547 proc, pid = key 3548 for cg in test.ftemp[key]: 3549 if len(cg.list) < 1 or cg.invalid or (cg.end - cg.start == 0): 3550 continue 3551 if(not cg.postProcess()): 3552 id = 'task %s' % (pid) 3553 sysvals.vprint('Sanity check failed for '+\ 3554 id+', ignoring this callback') 3555 continue 3556 # match cg data to devices 3557 devname = '' 3558 if sysvals.suspendmode != 'command': 3559 devname = cg.deviceMatch(pid, data) 3560 if not devname: 3561 sortkey = '%f%f%d' % (cg.start, cg.end, pid) 3562 sortlist[sortkey] = cg 3563 elif len(cg.list) > 1000000 and cg.name != sysvals.ftopfunc: 3564 sysvals.vprint('WARNING: the callgraph for %s is massive (%d lines)' %\ 3565 (devname, len(cg.list))) 3566 # create blocks for orphan cg data 3567 for sortkey in sorted(sortlist): 3568 cg = sortlist[sortkey] 3569 name = cg.name 3570 if sysvals.isCallgraphFunc(name): 3571 sysvals.vprint('Callgraph found for task %d: %.3fms, %s' % (cg.pid, (cg.end - cg.start)*1000, name)) 3572 cg.newActionFromFunction(data) 3573 if sysvals.suspendmode == 'command': 3574 return (testdata, '') 3575 3576 # fill in any missing phases 3577 error = [] 3578 for data in testdata: 3579 tn = '' if len(testdata) == 1 else ('%d' % (data.testnumber + 1)) 3580 terr = '' 3581 phasedef = data.phasedef 3582 lp = 'suspend_prepare' 3583 for p in sorted(phasedef, key=lambda k:phasedef[k]['order']): 3584 if p not in data.dmesg: 3585 if not terr: 3586 ph = p if 'machine' in p else lp 3587 terr = '%s%s failed in %s phase' % (sysvals.suspendmode, tn, ph) 3588 pprint('TEST%s FAILED: %s' % (tn, terr)) 3589 error.append(terr) 3590 if data.tSuspended == 0: 3591 data.tSuspended = data.dmesg[lp]['end'] 3592 if data.tResumed == 0: 3593 data.tResumed = data.dmesg[lp]['end'] 3594 data.fwValid = False 3595 sysvals.vprint('WARNING: phase "%s" is missing!' % p) 3596 lp = p 3597 if not terr and 'dev' in data.wifi and data.wifi['stat'] == 'timeout': 3598 terr = '%s%s failed in wifi_resume <i>(%s %.0fs timeout)</i>' % \ 3599 (sysvals.suspendmode, tn, data.wifi['dev'], data.wifi['time']) 3600 error.append(terr) 3601 if not terr and data.enterfail: 3602 pprint('test%s FAILED: enter %s failed with %s' % (tn, sysvals.suspendmode, data.enterfail)) 3603 terr = 'test%s failed to enter %s mode' % (tn, sysvals.suspendmode) 3604 error.append(terr) 3605 if data.tSuspended == 0: 3606 data.tSuspended = data.tKernRes 3607 if data.tResumed == 0: 3608 data.tResumed = data.tSuspended 3609 3610 if(len(sysvals.devicefilter) > 0): 3611 data.deviceFilter(sysvals.devicefilter) 3612 data.fixupInitcallsThatDidntReturn() 3613 if sysvals.usedevsrc: 3614 data.optimizeDevSrc() 3615 3616 # x2: merge any overlapping devices between test runs 3617 if sysvals.usedevsrc and len(testdata) > 1: 3618 tc = len(testdata) 3619 for i in range(tc - 1): 3620 devlist = testdata[i].overflowDevices() 3621 for j in range(i + 1, tc): 3622 testdata[j].mergeOverlapDevices(devlist) 3623 testdata[0].stitchTouchingThreads(testdata[1:]) 3624 return (testdata, ', '.join(error)) 3625 3626# Function: loadKernelLog 3627# Description: 3628# [deprecated for kernel 3.15.0 or newer] 3629# load the dmesg file into memory and fix up any ordering issues 3630# The dmesg filename is taken from sysvals 3631# Output: 3632# An array of empty Data objects with only their dmesgtext attributes set 3633def loadKernelLog(): 3634 sysvals.vprint('Analyzing the dmesg data (%s)...' % \ 3635 os.path.basename(sysvals.dmesgfile)) 3636 if(os.path.exists(sysvals.dmesgfile) == False): 3637 doError('%s does not exist' % sysvals.dmesgfile) 3638 3639 # there can be multiple test runs in a single file 3640 tp = TestProps() 3641 tp.stamp = datetime.now().strftime('# suspend-%m%d%y-%H%M%S localhost mem unknown') 3642 testruns = [] 3643 data = 0 3644 lf = sysvals.openlog(sysvals.dmesgfile, 'r') 3645 for line in lf: 3646 line = line.replace('\r\n', '') 3647 idx = line.find('[') 3648 if idx > 1: 3649 line = line[idx:] 3650 if tp.stampInfo(line, sysvals): 3651 continue 3652 m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line) 3653 if(not m): 3654 continue 3655 msg = m.group("msg") 3656 if(re.match('PM: Syncing filesystems.*', msg)): 3657 if(data): 3658 testruns.append(data) 3659 data = Data(len(testruns)) 3660 tp.parseStamp(data, sysvals) 3661 if(not data): 3662 continue 3663 m = re.match('.* *(?P<k>[0-9]\.[0-9]{2}\.[0-9]-.*) .*', msg) 3664 if(m): 3665 sysvals.stamp['kernel'] = m.group('k') 3666 m = re.match('PM: Preparing system for (?P<m>.*) sleep', msg) 3667 if(m): 3668 sysvals.stamp['mode'] = sysvals.suspendmode = m.group('m') 3669 data.dmesgtext.append(line) 3670 lf.close() 3671 3672 if data: 3673 testruns.append(data) 3674 if len(testruns) < 1: 3675 doError('dmesg log has no suspend/resume data: %s' \ 3676 % sysvals.dmesgfile) 3677 3678 # fix lines with same timestamp/function with the call and return swapped 3679 for data in testruns: 3680 last = '' 3681 for line in data.dmesgtext: 3682 mc = re.match('.*(\[ *)(?P<t>[0-9\.]*)(\]) calling '+\ 3683 '(?P<f>.*)\+ @ .*, parent: .*', line) 3684 mr = re.match('.*(\[ *)(?P<t>[0-9\.]*)(\]) call '+\ 3685 '(?P<f>.*)\+ returned .* after (?P<dt>.*) usecs', last) 3686 if(mc and mr and (mc.group('t') == mr.group('t')) and 3687 (mc.group('f') == mr.group('f'))): 3688 i = data.dmesgtext.index(last) 3689 j = data.dmesgtext.index(line) 3690 data.dmesgtext[i] = line 3691 data.dmesgtext[j] = last 3692 last = line 3693 return testruns 3694 3695# Function: parseKernelLog 3696# Description: 3697# [deprecated for kernel 3.15.0 or newer] 3698# Analyse a dmesg log output file generated from this app during 3699# the execution phase. Create a set of device structures in memory 3700# for subsequent formatting in the html output file 3701# This call is only for legacy support on kernels where the ftrace 3702# data lacks the suspend_resume or device_pm_callbacks trace events. 3703# Arguments: 3704# data: an empty Data object (with dmesgtext) obtained from loadKernelLog 3705# Output: 3706# The filled Data object 3707def parseKernelLog(data): 3708 phase = 'suspend_runtime' 3709 3710 if(data.fwValid): 3711 sysvals.vprint('Firmware Suspend = %u ns, Firmware Resume = %u ns' % \ 3712 (data.fwSuspend, data.fwResume)) 3713 3714 # dmesg phase match table 3715 dm = { 3716 'suspend_prepare': ['PM: Syncing filesystems.*'], 3717 'suspend': ['PM: Entering [a-z]* sleep.*', 'Suspending console.*'], 3718 'suspend_late': ['PM: suspend of devices complete after.*'], 3719 'suspend_noirq': ['PM: late suspend of devices complete after.*'], 3720 'suspend_machine': ['PM: noirq suspend of devices complete after.*'], 3721 'resume_machine': ['ACPI: Low-level resume complete.*'], 3722 'resume_noirq': ['ACPI: Waking up from system sleep state.*'], 3723 'resume_early': ['PM: noirq resume of devices complete after.*'], 3724 'resume': ['PM: early resume of devices complete after.*'], 3725 'resume_complete': ['PM: resume of devices complete after.*'], 3726 'post_resume': ['.*Restarting tasks \.\.\..*'], 3727 } 3728 if(sysvals.suspendmode == 'standby'): 3729 dm['resume_machine'] = ['PM: Restoring platform NVS memory'] 3730 elif(sysvals.suspendmode == 'disk'): 3731 dm['suspend_late'] = ['PM: freeze of devices complete after.*'] 3732 dm['suspend_noirq'] = ['PM: late freeze of devices complete after.*'] 3733 dm['suspend_machine'] = ['PM: noirq freeze of devices complete after.*'] 3734 dm['resume_machine'] = ['PM: Restoring platform NVS memory'] 3735 dm['resume_early'] = ['PM: noirq restore of devices complete after.*'] 3736 dm['resume'] = ['PM: early restore of devices complete after.*'] 3737 dm['resume_complete'] = ['PM: restore of devices complete after.*'] 3738 elif(sysvals.suspendmode == 'freeze'): 3739 dm['resume_machine'] = ['ACPI: resume from mwait'] 3740 3741 # action table (expected events that occur and show up in dmesg) 3742 at = { 3743 'sync_filesystems': { 3744 'smsg': 'PM: Syncing filesystems.*', 3745 'emsg': 'PM: Preparing system for mem sleep.*' }, 3746 'freeze_user_processes': { 3747 'smsg': 'Freezing user space processes .*', 3748 'emsg': 'Freezing remaining freezable tasks.*' }, 3749 'freeze_tasks': { 3750 'smsg': 'Freezing remaining freezable tasks.*', 3751 'emsg': 'PM: Entering (?P<mode>[a-z,A-Z]*) sleep.*' }, 3752 'ACPI prepare': { 3753 'smsg': 'ACPI: Preparing to enter system sleep state.*', 3754 'emsg': 'PM: Saving platform NVS memory.*' }, 3755 'PM vns': { 3756 'smsg': 'PM: Saving platform NVS memory.*', 3757 'emsg': 'Disabling non-boot CPUs .*' }, 3758 } 3759 3760 t0 = -1.0 3761 cpu_start = -1.0 3762 prevktime = -1.0 3763 actions = dict() 3764 for line in data.dmesgtext: 3765 # parse each dmesg line into the time and message 3766 m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line) 3767 if(m): 3768 val = m.group('ktime') 3769 try: 3770 ktime = float(val) 3771 except: 3772 continue 3773 msg = m.group('msg') 3774 # initialize data start to first line time 3775 if t0 < 0: 3776 data.setStart(ktime) 3777 t0 = ktime 3778 else: 3779 continue 3780 3781 # check for a phase change line 3782 phasechange = False 3783 for p in dm: 3784 for s in dm[p]: 3785 if(re.match(s, msg)): 3786 phasechange, phase = True, p 3787 break 3788 3789 # hack for determining resume_machine end for freeze 3790 if(not sysvals.usetraceevents and sysvals.suspendmode == 'freeze' \ 3791 and phase == 'resume_machine' and \ 3792 re.match('calling (?P<f>.*)\+ @ .*, parent: .*', msg)): 3793 data.setPhase(phase, ktime, False) 3794 phase = 'resume_noirq' 3795 data.setPhase(phase, ktime, True) 3796 3797 if phasechange: 3798 if phase == 'suspend_prepare': 3799 data.setPhase(phase, ktime, True) 3800 data.setStart(ktime) 3801 data.tKernSus = ktime 3802 elif phase == 'suspend': 3803 lp = data.lastPhase() 3804 if lp: 3805 data.setPhase(lp, ktime, False) 3806 data.setPhase(phase, ktime, True) 3807 elif phase == 'suspend_late': 3808 lp = data.lastPhase() 3809 if lp: 3810 data.setPhase(lp, ktime, False) 3811 data.setPhase(phase, ktime, True) 3812 elif phase == 'suspend_noirq': 3813 lp = data.lastPhase() 3814 if lp: 3815 data.setPhase(lp, ktime, False) 3816 data.setPhase(phase, ktime, True) 3817 elif phase == 'suspend_machine': 3818 lp = data.lastPhase() 3819 if lp: 3820 data.setPhase(lp, ktime, False) 3821 data.setPhase(phase, ktime, True) 3822 elif phase == 'resume_machine': 3823 lp = data.lastPhase() 3824 if(sysvals.suspendmode in ['freeze', 'standby']): 3825 data.tSuspended = prevktime 3826 if lp: 3827 data.setPhase(lp, prevktime, False) 3828 else: 3829 data.tSuspended = ktime 3830 if lp: 3831 data.setPhase(lp, prevktime, False) 3832 data.tResumed = ktime 3833 data.setPhase(phase, ktime, True) 3834 elif phase == 'resume_noirq': 3835 lp = data.lastPhase() 3836 if lp: 3837 data.setPhase(lp, ktime, False) 3838 data.setPhase(phase, ktime, True) 3839 elif phase == 'resume_early': 3840 lp = data.lastPhase() 3841 if lp: 3842 data.setPhase(lp, ktime, False) 3843 data.setPhase(phase, ktime, True) 3844 elif phase == 'resume': 3845 lp = data.lastPhase() 3846 if lp: 3847 data.setPhase(lp, ktime, False) 3848 data.setPhase(phase, ktime, True) 3849 elif phase == 'resume_complete': 3850 lp = data.lastPhase() 3851 if lp: 3852 data.setPhase(lp, ktime, False) 3853 data.setPhase(phase, ktime, True) 3854 elif phase == 'post_resume': 3855 lp = data.lastPhase() 3856 if lp: 3857 data.setPhase(lp, ktime, False) 3858 data.setEnd(ktime) 3859 data.tKernRes = ktime 3860 break 3861 3862 # -- device callbacks -- 3863 if(phase in data.sortedPhases()): 3864 # device init call 3865 if(re.match('calling (?P<f>.*)\+ @ .*, parent: .*', msg)): 3866 sm = re.match('calling (?P<f>.*)\+ @ '+\ 3867 '(?P<n>.*), parent: (?P<p>.*)', msg); 3868 f = sm.group('f') 3869 n = sm.group('n') 3870 p = sm.group('p') 3871 if(f and n and p): 3872 data.newAction(phase, f, int(n), p, ktime, -1, '') 3873 # device init return 3874 elif(re.match('call (?P<f>.*)\+ returned .* after '+\ 3875 '(?P<t>.*) usecs', msg)): 3876 sm = re.match('call (?P<f>.*)\+ returned .* after '+\ 3877 '(?P<t>.*) usecs(?P<a>.*)', msg); 3878 f = sm.group('f') 3879 t = sm.group('t') 3880 list = data.dmesg[phase]['list'] 3881 if(f in list): 3882 dev = list[f] 3883 dev['length'] = int(t) 3884 dev['end'] = ktime 3885 3886 # if trace events are not available, these are better than nothing 3887 if(not sysvals.usetraceevents): 3888 # look for known actions 3889 for a in sorted(at): 3890 if(re.match(at[a]['smsg'], msg)): 3891 if(a not in actions): 3892 actions[a] = [] 3893 actions[a].append({'begin': ktime, 'end': ktime}) 3894 if(re.match(at[a]['emsg'], msg)): 3895 if(a in actions): 3896 actions[a][-1]['end'] = ktime 3897 # now look for CPU on/off events 3898 if(re.match('Disabling non-boot CPUs .*', msg)): 3899 # start of first cpu suspend 3900 cpu_start = ktime 3901 elif(re.match('Enabling non-boot CPUs .*', msg)): 3902 # start of first cpu resume 3903 cpu_start = ktime 3904 elif(re.match('smpboot: CPU (?P<cpu>[0-9]*) is now offline', msg)): 3905 # end of a cpu suspend, start of the next 3906 m = re.match('smpboot: CPU (?P<cpu>[0-9]*) is now offline', msg) 3907 cpu = 'CPU'+m.group('cpu') 3908 if(cpu not in actions): 3909 actions[cpu] = [] 3910 actions[cpu].append({'begin': cpu_start, 'end': ktime}) 3911 cpu_start = ktime 3912 elif(re.match('CPU(?P<cpu>[0-9]*) is up', msg)): 3913 # end of a cpu resume, start of the next 3914 m = re.match('CPU(?P<cpu>[0-9]*) is up', msg) 3915 cpu = 'CPU'+m.group('cpu') 3916 if(cpu not in actions): 3917 actions[cpu] = [] 3918 actions[cpu].append({'begin': cpu_start, 'end': ktime}) 3919 cpu_start = ktime 3920 prevktime = ktime 3921 data.initDevicegroups() 3922 3923 # fill in any missing phases 3924 phasedef = data.phasedef 3925 terr, lp = '', 'suspend_prepare' 3926 for p in sorted(phasedef, key=lambda k:phasedef[k]['order']): 3927 if p not in data.dmesg: 3928 if not terr: 3929 pprint('TEST FAILED: %s failed in %s phase' % (sysvals.suspendmode, lp)) 3930 terr = '%s failed in %s phase' % (sysvals.suspendmode, lp) 3931 if data.tSuspended == 0: 3932 data.tSuspended = data.dmesg[lp]['end'] 3933 if data.tResumed == 0: 3934 data.tResumed = data.dmesg[lp]['end'] 3935 sysvals.vprint('WARNING: phase "%s" is missing!' % p) 3936 lp = p 3937 lp = data.sortedPhases()[0] 3938 for p in data.sortedPhases(): 3939 if(p != lp and not ('machine' in p and 'machine' in lp)): 3940 data.dmesg[lp]['end'] = data.dmesg[p]['start'] 3941 lp = p 3942 if data.tSuspended == 0: 3943 data.tSuspended = data.tKernRes 3944 if data.tResumed == 0: 3945 data.tResumed = data.tSuspended 3946 3947 # fill in any actions we've found 3948 for name in sorted(actions): 3949 for event in actions[name]: 3950 data.newActionGlobal(name, event['begin'], event['end']) 3951 3952 if(len(sysvals.devicefilter) > 0): 3953 data.deviceFilter(sysvals.devicefilter) 3954 data.fixupInitcallsThatDidntReturn() 3955 return True 3956 3957def callgraphHTML(sv, hf, num, cg, title, color, devid): 3958 html_func_top = '<article id="{0}" class="atop" style="background:{1}">\n<input type="checkbox" class="pf" id="f{2}" checked/><label for="f{2}">{3} {4}</label>\n' 3959 html_func_start = '<article>\n<input type="checkbox" class="pf" id="f{0}" checked/><label for="f{0}">{1} {2}</label>\n' 3960 html_func_end = '</article>\n' 3961 html_func_leaf = '<article>{0} {1}</article>\n' 3962 3963 cgid = devid 3964 if cg.id: 3965 cgid += cg.id 3966 cglen = (cg.end - cg.start) * 1000 3967 if cglen < sv.mincglen: 3968 return num 3969 3970 fmt = '<r>(%.3f ms @ '+sv.timeformat+' to '+sv.timeformat+')</r>' 3971 flen = fmt % (cglen, cg.start, cg.end) 3972 hf.write(html_func_top.format(cgid, color, num, title, flen)) 3973 num += 1 3974 for line in cg.list: 3975 if(line.length < 0.000000001): 3976 flen = '' 3977 else: 3978 fmt = '<n>(%.3f ms @ '+sv.timeformat+')</n>' 3979 flen = fmt % (line.length*1000, line.time) 3980 if line.isLeaf(): 3981 hf.write(html_func_leaf.format(line.name, flen)) 3982 elif line.freturn: 3983 hf.write(html_func_end) 3984 else: 3985 hf.write(html_func_start.format(num, line.name, flen)) 3986 num += 1 3987 hf.write(html_func_end) 3988 return num 3989 3990def addCallgraphs(sv, hf, data): 3991 hf.write('<section id="callgraphs" class="callgraph">\n') 3992 # write out the ftrace data converted to html 3993 num = 0 3994 for p in data.sortedPhases(): 3995 if sv.cgphase and p != sv.cgphase: 3996 continue 3997 list = data.dmesg[p]['list'] 3998 for d in data.sortedDevices(p): 3999 if len(sv.cgfilter) > 0 and d not in sv.cgfilter: 4000 continue 4001 dev = list[d] 4002 color = 'white' 4003 if 'color' in data.dmesg[p]: 4004 color = data.dmesg[p]['color'] 4005 if 'color' in dev: 4006 color = dev['color'] 4007 name = d if '[' not in d else d.split('[')[0] 4008 if(d in sv.devprops): 4009 name = sv.devprops[d].altName(d) 4010 if 'drv' in dev and dev['drv']: 4011 name += ' {%s}' % dev['drv'] 4012 if sv.suspendmode in suspendmodename: 4013 name += ' '+p 4014 if('ftrace' in dev): 4015 cg = dev['ftrace'] 4016 if cg.name == sv.ftopfunc: 4017 name = 'top level suspend/resume call' 4018 num = callgraphHTML(sv, hf, num, cg, 4019 name, color, dev['id']) 4020 if('ftraces' in dev): 4021 for cg in dev['ftraces']: 4022 num = callgraphHTML(sv, hf, num, cg, 4023 name+' → '+cg.name, color, dev['id']) 4024 hf.write('\n\n </section>\n') 4025 4026def summaryCSS(title, center=True): 4027 tdcenter = 'text-align:center;' if center else '' 4028 out = '<!DOCTYPE html>\n<html>\n<head>\n\ 4029 <meta http-equiv="content-type" content="text/html; charset=UTF-8">\n\ 4030 <title>'+title+'</title>\n\ 4031 <style type=\'text/css\'>\n\ 4032 .stamp {width: 100%;text-align:center;background:#888;line-height:30px;color:white;font: 25px Arial;}\n\ 4033 table {width:100%;border-collapse: collapse;border:1px solid;}\n\ 4034 th {border: 1px solid black;background:#222;color:white;}\n\ 4035 td {font: 14px "Times New Roman";'+tdcenter+'}\n\ 4036 tr.head td {border: 1px solid black;background:#aaa;}\n\ 4037 tr.alt {background-color:#ddd;}\n\ 4038 tr.notice {color:red;}\n\ 4039 .minval {background-color:#BBFFBB;}\n\ 4040 .medval {background-color:#BBBBFF;}\n\ 4041 .maxval {background-color:#FFBBBB;}\n\ 4042 .head a {color:#000;text-decoration: none;}\n\ 4043 </style>\n</head>\n<body>\n' 4044 return out 4045 4046# Function: createHTMLSummarySimple 4047# Description: 4048# Create summary html file for a series of tests 4049# Arguments: 4050# testruns: array of Data objects from parseTraceLog 4051def createHTMLSummarySimple(testruns, htmlfile, title): 4052 # write the html header first (html head, css code, up to body start) 4053 html = summaryCSS('Summary - SleepGraph') 4054 4055 # extract the test data into list 4056 list = dict() 4057 tAvg, tMin, tMax, tMed = [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [dict(), dict()] 4058 iMin, iMed, iMax = [0, 0], [0, 0], [0, 0] 4059 num = 0 4060 useturbo = usewifi = False 4061 lastmode = '' 4062 cnt = dict() 4063 for data in sorted(testruns, key=lambda v:(v['mode'], v['host'], v['kernel'], v['time'])): 4064 mode = data['mode'] 4065 if mode not in list: 4066 list[mode] = {'data': [], 'avg': [0,0], 'min': [0,0], 'max': [0,0], 'med': [0,0]} 4067 if lastmode and lastmode != mode and num > 0: 4068 for i in range(2): 4069 s = sorted(tMed[i]) 4070 list[lastmode]['med'][i] = s[int(len(s)//2)] 4071 iMed[i] = tMed[i][list[lastmode]['med'][i]] 4072 list[lastmode]['avg'] = [tAvg[0] / num, tAvg[1] / num] 4073 list[lastmode]['min'] = tMin 4074 list[lastmode]['max'] = tMax 4075 list[lastmode]['idx'] = (iMin, iMed, iMax) 4076 tAvg, tMin, tMax, tMed = [0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [dict(), dict()] 4077 iMin, iMed, iMax = [0, 0], [0, 0], [0, 0] 4078 num = 0 4079 pkgpc10 = syslpi = wifi = '' 4080 if 'pkgpc10' in data and 'syslpi' in data: 4081 pkgpc10, syslpi, useturbo = data['pkgpc10'], data['syslpi'], True 4082 if 'wifi' in data: 4083 wifi, usewifi = data['wifi'], True 4084 res = data['result'] 4085 tVal = [float(data['suspend']), float(data['resume'])] 4086 list[mode]['data'].append([data['host'], data['kernel'], 4087 data['time'], tVal[0], tVal[1], data['url'], res, 4088 data['issues'], data['sus_worst'], data['sus_worsttime'], 4089 data['res_worst'], data['res_worsttime'], pkgpc10, syslpi, wifi]) 4090 idx = len(list[mode]['data']) - 1 4091 if res.startswith('fail in'): 4092 res = 'fail' 4093 if res not in cnt: 4094 cnt[res] = 1 4095 else: 4096 cnt[res] += 1 4097 if res == 'pass': 4098 for i in range(2): 4099 tMed[i][tVal[i]] = idx 4100 tAvg[i] += tVal[i] 4101 if tMin[i] == 0 or tVal[i] < tMin[i]: 4102 iMin[i] = idx 4103 tMin[i] = tVal[i] 4104 if tMax[i] == 0 or tVal[i] > tMax[i]: 4105 iMax[i] = idx 4106 tMax[i] = tVal[i] 4107 num += 1 4108 lastmode = mode 4109 if lastmode and num > 0: 4110 for i in range(2): 4111 s = sorted(tMed[i]) 4112 list[lastmode]['med'][i] = s[int(len(s)//2)] 4113 iMed[i] = tMed[i][list[lastmode]['med'][i]] 4114 list[lastmode]['avg'] = [tAvg[0] / num, tAvg[1] / num] 4115 list[lastmode]['min'] = tMin 4116 list[lastmode]['max'] = tMax 4117 list[lastmode]['idx'] = (iMin, iMed, iMax) 4118 4119 # group test header 4120 desc = [] 4121 for ilk in sorted(cnt, reverse=True): 4122 if cnt[ilk] > 0: 4123 desc.append('%d %s' % (cnt[ilk], ilk)) 4124 html += '<div class="stamp">%s (%d tests: %s)</div>\n' % (title, len(testruns), ', '.join(desc)) 4125 th = '\t<th>{0}</th>\n' 4126 td = '\t<td>{0}</td>\n' 4127 tdh = '\t<td{1}>{0}</td>\n' 4128 tdlink = '\t<td><a href="{0}">html</a></td>\n' 4129 cols = 12 4130 if useturbo: 4131 cols += 2 4132 if usewifi: 4133 cols += 1 4134 colspan = '%d' % cols 4135 4136 # table header 4137 html += '<table>\n<tr>\n' + th.format('#') +\ 4138 th.format('Mode') + th.format('Host') + th.format('Kernel') +\ 4139 th.format('Test Time') + th.format('Result') + th.format('Issues') +\ 4140 th.format('Suspend') + th.format('Resume') +\ 4141 th.format('Worst Suspend Device') + th.format('SD Time') +\ 4142 th.format('Worst Resume Device') + th.format('RD Time') 4143 if useturbo: 4144 html += th.format('PkgPC10') + th.format('SysLPI') 4145 if usewifi: 4146 html += th.format('Wifi') 4147 html += th.format('Detail')+'</tr>\n' 4148 # export list into html 4149 head = '<tr class="head"><td>{0}</td><td>{1}</td>'+\ 4150 '<td colspan='+colspan+' class="sus">Suspend Avg={2} '+\ 4151 '<span class=minval><a href="#s{10}min">Min={3}</a></span> '+\ 4152 '<span class=medval><a href="#s{10}med">Med={4}</a></span> '+\ 4153 '<span class=maxval><a href="#s{10}max">Max={5}</a></span> '+\ 4154 'Resume Avg={6} '+\ 4155 '<span class=minval><a href="#r{10}min">Min={7}</a></span> '+\ 4156 '<span class=medval><a href="#r{10}med">Med={8}</a></span> '+\ 4157 '<span class=maxval><a href="#r{10}max">Max={9}</a></span></td>'+\ 4158 '</tr>\n' 4159 headnone = '<tr class="head"><td>{0}</td><td>{1}</td><td colspan='+\ 4160 colspan+'></td></tr>\n' 4161 for mode in sorted(list): 4162 # header line for each suspend mode 4163 num = 0 4164 tAvg, tMin, tMax, tMed = list[mode]['avg'], list[mode]['min'],\ 4165 list[mode]['max'], list[mode]['med'] 4166 count = len(list[mode]['data']) 4167 if 'idx' in list[mode]: 4168 iMin, iMed, iMax = list[mode]['idx'] 4169 html += head.format('%d' % count, mode.upper(), 4170 '%.3f' % tAvg[0], '%.3f' % tMin[0], '%.3f' % tMed[0], '%.3f' % tMax[0], 4171 '%.3f' % tAvg[1], '%.3f' % tMin[1], '%.3f' % tMed[1], '%.3f' % tMax[1], 4172 mode.lower() 4173 ) 4174 else: 4175 iMin = iMed = iMax = [-1, -1, -1] 4176 html += headnone.format('%d' % count, mode.upper()) 4177 for d in list[mode]['data']: 4178 # row classes - alternate row color 4179 rcls = ['alt'] if num % 2 == 1 else [] 4180 if d[6] != 'pass': 4181 rcls.append('notice') 4182 html += '<tr class="'+(' '.join(rcls))+'">\n' if len(rcls) > 0 else '<tr>\n' 4183 # figure out if the line has sus or res highlighted 4184 idx = list[mode]['data'].index(d) 4185 tHigh = ['', ''] 4186 for i in range(2): 4187 tag = 's%s' % mode if i == 0 else 'r%s' % mode 4188 if idx == iMin[i]: 4189 tHigh[i] = ' id="%smin" class=minval title="Minimum"' % tag 4190 elif idx == iMax[i]: 4191 tHigh[i] = ' id="%smax" class=maxval title="Maximum"' % tag 4192 elif idx == iMed[i]: 4193 tHigh[i] = ' id="%smed" class=medval title="Median"' % tag 4194 html += td.format("%d" % (list[mode]['data'].index(d) + 1)) # row 4195 html += td.format(mode) # mode 4196 html += td.format(d[0]) # host 4197 html += td.format(d[1]) # kernel 4198 html += td.format(d[2]) # time 4199 html += td.format(d[6]) # result 4200 html += td.format(d[7]) # issues 4201 html += tdh.format('%.3f ms' % d[3], tHigh[0]) if d[3] else td.format('') # suspend 4202 html += tdh.format('%.3f ms' % d[4], tHigh[1]) if d[4] else td.format('') # resume 4203 html += td.format(d[8]) # sus_worst 4204 html += td.format('%.3f ms' % d[9]) if d[9] else td.format('') # sus_worst time 4205 html += td.format(d[10]) # res_worst 4206 html += td.format('%.3f ms' % d[11]) if d[11] else td.format('') # res_worst time 4207 if useturbo: 4208 html += td.format(d[12]) # pkg_pc10 4209 html += td.format(d[13]) # syslpi 4210 if usewifi: 4211 html += td.format(d[14]) # wifi 4212 html += tdlink.format(d[5]) if d[5] else td.format('') # url 4213 html += '</tr>\n' 4214 num += 1 4215 4216 # flush the data to file 4217 hf = open(htmlfile, 'w') 4218 hf.write(html+'</table>\n</body>\n</html>\n') 4219 hf.close() 4220 4221def createHTMLDeviceSummary(testruns, htmlfile, title): 4222 html = summaryCSS('Device Summary - SleepGraph', False) 4223 4224 # create global device list from all tests 4225 devall = dict() 4226 for data in testruns: 4227 host, url, devlist = data['host'], data['url'], data['devlist'] 4228 for type in devlist: 4229 if type not in devall: 4230 devall[type] = dict() 4231 mdevlist, devlist = devall[type], data['devlist'][type] 4232 for name in devlist: 4233 length = devlist[name] 4234 if name not in mdevlist: 4235 mdevlist[name] = {'name': name, 'host': host, 4236 'worst': length, 'total': length, 'count': 1, 4237 'url': url} 4238 else: 4239 if length > mdevlist[name]['worst']: 4240 mdevlist[name]['worst'] = length 4241 mdevlist[name]['url'] = url 4242 mdevlist[name]['host'] = host 4243 mdevlist[name]['total'] += length 4244 mdevlist[name]['count'] += 1 4245 4246 # generate the html 4247 th = '\t<th>{0}</th>\n' 4248 td = '\t<td align=center>{0}</td>\n' 4249 tdr = '\t<td align=right>{0}</td>\n' 4250 tdlink = '\t<td align=center><a href="{0}">html</a></td>\n' 4251 limit = 1 4252 for type in sorted(devall, reverse=True): 4253 num = 0 4254 devlist = devall[type] 4255 # table header 4256 html += '<div class="stamp">%s (%s devices > %d ms)</div><table>\n' % \ 4257 (title, type.upper(), limit) 4258 html += '<tr>\n' + '<th align=right>Device Name</th>' +\ 4259 th.format('Average Time') + th.format('Count') +\ 4260 th.format('Worst Time') + th.format('Host (worst time)') +\ 4261 th.format('Link (worst time)') + '</tr>\n' 4262 for name in sorted(devlist, key=lambda k:(devlist[k]['worst'], \ 4263 devlist[k]['total'], devlist[k]['name']), reverse=True): 4264 data = devall[type][name] 4265 data['average'] = data['total'] / data['count'] 4266 if data['average'] < limit: 4267 continue 4268 # row classes - alternate row color 4269 rcls = ['alt'] if num % 2 == 1 else [] 4270 html += '<tr class="'+(' '.join(rcls))+'">\n' if len(rcls) > 0 else '<tr>\n' 4271 html += tdr.format(data['name']) # name 4272 html += td.format('%.3f ms' % data['average']) # average 4273 html += td.format(data['count']) # count 4274 html += td.format('%.3f ms' % data['worst']) # worst 4275 html += td.format(data['host']) # host 4276 html += tdlink.format(data['url']) # url 4277 html += '</tr>\n' 4278 num += 1 4279 html += '</table>\n' 4280 4281 # flush the data to file 4282 hf = open(htmlfile, 'w') 4283 hf.write(html+'</body>\n</html>\n') 4284 hf.close() 4285 return devall 4286 4287def createHTMLIssuesSummary(testruns, issues, htmlfile, title, extra=''): 4288 multihost = len([e for e in issues if len(e['urls']) > 1]) > 0 4289 html = summaryCSS('Issues Summary - SleepGraph', False) 4290 total = len(testruns) 4291 4292 # generate the html 4293 th = '\t<th>{0}</th>\n' 4294 td = '\t<td align={0}>{1}</td>\n' 4295 tdlink = '<a href="{1}">{0}</a>' 4296 subtitle = '%d issues' % len(issues) if len(issues) > 0 else 'no issues' 4297 html += '<div class="stamp">%s (%s)</div><table>\n' % (title, subtitle) 4298 html += '<tr>\n' + th.format('Issue') + th.format('Count') 4299 if multihost: 4300 html += th.format('Hosts') 4301 html += th.format('Tests') + th.format('Fail Rate') +\ 4302 th.format('First Instance') + '</tr>\n' 4303 4304 num = 0 4305 for e in sorted(issues, key=lambda v:v['count'], reverse=True): 4306 testtotal = 0 4307 links = [] 4308 for host in sorted(e['urls']): 4309 links.append(tdlink.format(host, e['urls'][host][0])) 4310 testtotal += len(e['urls'][host]) 4311 rate = '%d/%d (%.2f%%)' % (testtotal, total, 100*float(testtotal)/float(total)) 4312 # row classes - alternate row color 4313 rcls = ['alt'] if num % 2 == 1 else [] 4314 html += '<tr class="'+(' '.join(rcls))+'">\n' if len(rcls) > 0 else '<tr>\n' 4315 html += td.format('left', e['line']) # issue 4316 html += td.format('center', e['count']) # count 4317 if multihost: 4318 html += td.format('center', len(e['urls'])) # hosts 4319 html += td.format('center', testtotal) # test count 4320 html += td.format('center', rate) # test rate 4321 html += td.format('center nowrap', '<br>'.join(links)) # links 4322 html += '</tr>\n' 4323 num += 1 4324 4325 # flush the data to file 4326 hf = open(htmlfile, 'w') 4327 hf.write(html+'</table>\n'+extra+'</body>\n</html>\n') 4328 hf.close() 4329 return issues 4330 4331def ordinal(value): 4332 suffix = 'th' 4333 if value < 10 or value > 19: 4334 if value % 10 == 1: 4335 suffix = 'st' 4336 elif value % 10 == 2: 4337 suffix = 'nd' 4338 elif value % 10 == 3: 4339 suffix = 'rd' 4340 return '%d%s' % (value, suffix) 4341 4342# Function: createHTML 4343# Description: 4344# Create the output html file from the resident test data 4345# Arguments: 4346# testruns: array of Data objects from parseKernelLog or parseTraceLog 4347# Output: 4348# True if the html file was created, false if it failed 4349def createHTML(testruns, testfail): 4350 if len(testruns) < 1: 4351 pprint('ERROR: Not enough test data to build a timeline') 4352 return 4353 4354 kerror = False 4355 for data in testruns: 4356 if data.kerror: 4357 kerror = True 4358 if(sysvals.suspendmode in ['freeze', 'standby']): 4359 data.trimFreezeTime(testruns[-1].tSuspended) 4360 else: 4361 data.getMemTime() 4362 4363 # html function templates 4364 html_error = '<div id="{1}" title="kernel error/warning" class="err" style="right:{0}%">{2}→</div>\n' 4365 html_traceevent = '<div title="{0}" class="traceevent{6}" style="left:{1}%;top:{2}px;height:{3}px;width:{4}%;line-height:{3}px;{7}">{5}</div>\n' 4366 html_cpuexec = '<div class="jiffie" style="left:{0}%;top:{1}px;height:{2}px;width:{3}%;background:{4};"></div>\n' 4367 html_timetotal = '<table class="time1">\n<tr>'\ 4368 '<td class="green" title="{3}">{2} Suspend Time: <b>{0} ms</b></td>'\ 4369 '<td class="yellow" title="{4}">{2} Resume Time: <b>{1} ms</b></td>'\ 4370 '</tr>\n</table>\n' 4371 html_timetotal2 = '<table class="time1">\n<tr>'\ 4372 '<td class="green" title="{4}">{3} Suspend Time: <b>{0} ms</b></td>'\ 4373 '<td class="gray" title="time spent in low-power mode with clock running">'+sysvals.suspendmode+' time: <b>{1} ms</b></td>'\ 4374 '<td class="yellow" title="{5}">{3} Resume Time: <b>{2} ms</b></td>'\ 4375 '</tr>\n</table>\n' 4376 html_timetotal3 = '<table class="time1">\n<tr>'\ 4377 '<td class="green">Execution Time: <b>{0} ms</b></td>'\ 4378 '<td class="yellow">Command: <b>{1}</b></td>'\ 4379 '</tr>\n</table>\n' 4380 html_fail = '<table class="testfail"><tr><td>{0}</td></tr></table>\n' 4381 html_kdesc = '<td class="{3}" title="time spent in kernel execution">{0}Kernel {2}: {1} ms</td>' 4382 html_fwdesc = '<td class="{3}" title="time spent in firmware">{0}Firmware {2}: {1} ms</td>' 4383 html_wifdesc = '<td class="yellow" title="time for wifi to reconnect after resume complete ({2})">{0}Wifi Resume: {1}</td>' 4384 4385 # html format variables 4386 scaleH = 20 4387 if kerror: 4388 scaleH = 40 4389 4390 # device timeline 4391 devtl = Timeline(30, scaleH) 4392 4393 # write the test title and general info header 4394 devtl.createHeader(sysvals, testruns[0].stamp) 4395 4396 # Generate the header for this timeline 4397 for data in testruns: 4398 tTotal = data.end - data.start 4399 if(tTotal == 0): 4400 doError('No timeline data') 4401 if sysvals.suspendmode == 'command': 4402 run_time = '%.0f' % (tTotal * 1000) 4403 if sysvals.testcommand: 4404 testdesc = sysvals.testcommand 4405 else: 4406 testdesc = 'unknown' 4407 if(len(testruns) > 1): 4408 testdesc = ordinal(data.testnumber+1)+' '+testdesc 4409 thtml = html_timetotal3.format(run_time, testdesc) 4410 devtl.html += thtml 4411 continue 4412 # typical full suspend/resume header 4413 stot, rtot = sktime, rktime = data.getTimeValues() 4414 ssrc, rsrc, testdesc, testdesc2 = ['kernel'], ['kernel'], 'Kernel', '' 4415 if data.fwValid: 4416 stot += (data.fwSuspend/1000000.0) 4417 rtot += (data.fwResume/1000000.0) 4418 ssrc.append('firmware') 4419 rsrc.append('firmware') 4420 testdesc = 'Total' 4421 if 'time' in data.wifi and data.wifi['stat'] != 'timeout': 4422 rtot += data.end - data.tKernRes + (data.wifi['time'] * 1000.0) 4423 rsrc.append('wifi') 4424 testdesc = 'Total' 4425 suspend_time, resume_time = '%.3f' % stot, '%.3f' % rtot 4426 stitle = 'time from kernel suspend start to %s mode [%s time]' % \ 4427 (sysvals.suspendmode, ' & '.join(ssrc)) 4428 rtitle = 'time from %s mode to kernel resume complete [%s time]' % \ 4429 (sysvals.suspendmode, ' & '.join(rsrc)) 4430 if(len(testruns) > 1): 4431 testdesc = testdesc2 = ordinal(data.testnumber+1) 4432 testdesc2 += ' ' 4433 if(len(data.tLow) == 0): 4434 thtml = html_timetotal.format(suspend_time, \ 4435 resume_time, testdesc, stitle, rtitle) 4436 else: 4437 low_time = '+'.join(data.tLow) 4438 thtml = html_timetotal2.format(suspend_time, low_time, \ 4439 resume_time, testdesc, stitle, rtitle) 4440 devtl.html += thtml 4441 if not data.fwValid and 'dev' not in data.wifi: 4442 continue 4443 # extra detail when the times come from multiple sources 4444 thtml = '<table class="time2">\n<tr>' 4445 thtml += html_kdesc.format(testdesc2, '%.3f'%sktime, 'Suspend', 'green') 4446 if data.fwValid: 4447 sftime = '%.3f'%(data.fwSuspend / 1000000.0) 4448 rftime = '%.3f'%(data.fwResume / 1000000.0) 4449 thtml += html_fwdesc.format(testdesc2, sftime, 'Suspend', 'green') 4450 thtml += html_fwdesc.format(testdesc2, rftime, 'Resume', 'yellow') 4451 thtml += html_kdesc.format(testdesc2, '%.3f'%rktime, 'Resume', 'yellow') 4452 if 'time' in data.wifi: 4453 if data.wifi['stat'] != 'timeout': 4454 wtime = '%.0f ms'%(data.end - data.tKernRes + (data.wifi['time'] * 1000.0)) 4455 else: 4456 wtime = 'TIMEOUT' 4457 thtml += html_wifdesc.format(testdesc2, wtime, data.wifi['dev']) 4458 thtml += '</tr>\n</table>\n' 4459 devtl.html += thtml 4460 if testfail: 4461 devtl.html += html_fail.format(testfail) 4462 4463 # time scale for potentially multiple datasets 4464 t0 = testruns[0].start 4465 tMax = testruns[-1].end 4466 tTotal = tMax - t0 4467 4468 # determine the maximum number of rows we need to draw 4469 fulllist = [] 4470 threadlist = [] 4471 pscnt = 0 4472 devcnt = 0 4473 for data in testruns: 4474 data.selectTimelineDevices('%f', tTotal, sysvals.mindevlen) 4475 for group in data.devicegroups: 4476 devlist = [] 4477 for phase in group: 4478 for devname in sorted(data.tdevlist[phase]): 4479 d = DevItem(data.testnumber, phase, data.dmesg[phase]['list'][devname]) 4480 devlist.append(d) 4481 if d.isa('kth'): 4482 threadlist.append(d) 4483 else: 4484 if d.isa('ps'): 4485 pscnt += 1 4486 else: 4487 devcnt += 1 4488 fulllist.append(d) 4489 if sysvals.mixedphaseheight: 4490 devtl.getPhaseRows(devlist) 4491 if not sysvals.mixedphaseheight: 4492 if len(threadlist) > 0 and len(fulllist) > 0: 4493 if pscnt > 0 and devcnt > 0: 4494 msg = 'user processes & device pm callbacks' 4495 elif pscnt > 0: 4496 msg = 'user processes' 4497 else: 4498 msg = 'device pm callbacks' 4499 d = testruns[0].addHorizontalDivider(msg, testruns[-1].end) 4500 fulllist.insert(0, d) 4501 devtl.getPhaseRows(fulllist) 4502 if len(threadlist) > 0: 4503 d = testruns[0].addHorizontalDivider('asynchronous kernel threads', testruns[-1].end) 4504 threadlist.insert(0, d) 4505 devtl.getPhaseRows(threadlist, devtl.rows) 4506 devtl.calcTotalRows() 4507 4508 # draw the full timeline 4509 devtl.createZoomBox(sysvals.suspendmode, len(testruns)) 4510 for data in testruns: 4511 # draw each test run and block chronologically 4512 phases = {'suspend':[],'resume':[]} 4513 for phase in data.sortedPhases(): 4514 if data.dmesg[phase]['start'] >= data.tSuspended: 4515 phases['resume'].append(phase) 4516 else: 4517 phases['suspend'].append(phase) 4518 # now draw the actual timeline blocks 4519 for dir in phases: 4520 # draw suspend and resume blocks separately 4521 bname = '%s%d' % (dir[0], data.testnumber) 4522 if dir == 'suspend': 4523 m0 = data.start 4524 mMax = data.tSuspended 4525 left = '%f' % (((m0-t0)*100.0)/tTotal) 4526 else: 4527 m0 = data.tSuspended 4528 mMax = data.end 4529 # in an x2 run, remove any gap between blocks 4530 if len(testruns) > 1 and data.testnumber == 0: 4531 mMax = testruns[1].start 4532 left = '%f' % ((((m0-t0)*100.0)+sysvals.srgap/2)/tTotal) 4533 mTotal = mMax - m0 4534 # if a timeline block is 0 length, skip altogether 4535 if mTotal == 0: 4536 continue 4537 width = '%f' % (((mTotal*100.0)-sysvals.srgap/2)/tTotal) 4538 devtl.html += devtl.html_tblock.format(bname, left, width, devtl.scaleH) 4539 for b in phases[dir]: 4540 # draw the phase color background 4541 phase = data.dmesg[b] 4542 length = phase['end']-phase['start'] 4543 left = '%f' % (((phase['start']-m0)*100.0)/mTotal) 4544 width = '%f' % ((length*100.0)/mTotal) 4545 devtl.html += devtl.html_phase.format(left, width, \ 4546 '%.3f'%devtl.scaleH, '%.3f'%devtl.bodyH, \ 4547 data.dmesg[b]['color'], '') 4548 for e in data.errorinfo[dir]: 4549 # draw red lines for any kernel errors found 4550 type, t, idx1, idx2 = e 4551 id = '%d_%d' % (idx1, idx2) 4552 right = '%f' % (((mMax-t)*100.0)/mTotal) 4553 devtl.html += html_error.format(right, id, type) 4554 for b in phases[dir]: 4555 # draw the devices for this phase 4556 phaselist = data.dmesg[b]['list'] 4557 for d in sorted(data.tdevlist[b]): 4558 dname = d if '[' not in d else d.split('[')[0] 4559 name, dev = dname, phaselist[d] 4560 drv = xtraclass = xtrainfo = xtrastyle = '' 4561 if 'htmlclass' in dev: 4562 xtraclass = dev['htmlclass'] 4563 if 'color' in dev: 4564 xtrastyle = 'background:%s;' % dev['color'] 4565 if(d in sysvals.devprops): 4566 name = sysvals.devprops[d].altName(d) 4567 xtraclass = sysvals.devprops[d].xtraClass() 4568 xtrainfo = sysvals.devprops[d].xtraInfo() 4569 elif xtraclass == ' kth': 4570 xtrainfo = ' kernel_thread' 4571 if('drv' in dev and dev['drv']): 4572 drv = ' {%s}' % dev['drv'] 4573 rowheight = devtl.phaseRowHeight(data.testnumber, b, dev['row']) 4574 rowtop = devtl.phaseRowTop(data.testnumber, b, dev['row']) 4575 top = '%.3f' % (rowtop + devtl.scaleH) 4576 left = '%f' % (((dev['start']-m0)*100)/mTotal) 4577 width = '%f' % (((dev['end']-dev['start'])*100)/mTotal) 4578 length = ' (%0.3f ms) ' % ((dev['end']-dev['start'])*1000) 4579 title = name+drv+xtrainfo+length 4580 if sysvals.suspendmode == 'command': 4581 title += sysvals.testcommand 4582 elif xtraclass == ' ps': 4583 if 'suspend' in b: 4584 title += 'pre_suspend_process' 4585 else: 4586 title += 'post_resume_process' 4587 else: 4588 title += b 4589 devtl.html += devtl.html_device.format(dev['id'], \ 4590 title, left, top, '%.3f'%rowheight, width, \ 4591 dname+drv, xtraclass, xtrastyle) 4592 if('cpuexec' in dev): 4593 for t in sorted(dev['cpuexec']): 4594 start, end = t 4595 j = float(dev['cpuexec'][t]) / 5 4596 if j > 1.0: 4597 j = 1.0 4598 height = '%.3f' % (rowheight/3) 4599 top = '%.3f' % (rowtop + devtl.scaleH + 2*rowheight/3) 4600 left = '%f' % (((start-m0)*100)/mTotal) 4601 width = '%f' % ((end-start)*100/mTotal) 4602 color = 'rgba(255, 0, 0, %f)' % j 4603 devtl.html += \ 4604 html_cpuexec.format(left, top, height, width, color) 4605 if('src' not in dev): 4606 continue 4607 # draw any trace events for this device 4608 for e in dev['src']: 4609 if e.length == 0: 4610 continue 4611 height = '%.3f' % devtl.rowH 4612 top = '%.3f' % (rowtop + devtl.scaleH + (e.row*devtl.rowH)) 4613 left = '%f' % (((e.time-m0)*100)/mTotal) 4614 width = '%f' % (e.length*100/mTotal) 4615 xtrastyle = '' 4616 if e.color: 4617 xtrastyle = 'background:%s;' % e.color 4618 devtl.html += \ 4619 html_traceevent.format(e.title(), \ 4620 left, top, height, width, e.text(), '', xtrastyle) 4621 # draw the time scale, try to make the number of labels readable 4622 devtl.createTimeScale(m0, mMax, tTotal, dir) 4623 devtl.html += '</div>\n' 4624 4625 # timeline is finished 4626 devtl.html += '</div>\n</div>\n' 4627 4628 # draw a legend which describes the phases by color 4629 if sysvals.suspendmode != 'command': 4630 phasedef = testruns[-1].phasedef 4631 devtl.html += '<div class="legend">\n' 4632 pdelta = 100.0/len(phasedef.keys()) 4633 pmargin = pdelta / 4.0 4634 for phase in sorted(phasedef, key=lambda k:phasedef[k]['order']): 4635 id, p = '', phasedef[phase] 4636 for word in phase.split('_'): 4637 id += word[0] 4638 order = '%.2f' % ((p['order'] * pdelta) + pmargin) 4639 name = phase.replace('_', ' ') 4640 devtl.html += devtl.html_legend.format(order, p['color'], name, id) 4641 devtl.html += '</div>\n' 4642 4643 hf = open(sysvals.htmlfile, 'w') 4644 addCSS(hf, sysvals, len(testruns), kerror) 4645 4646 # write the device timeline 4647 hf.write(devtl.html) 4648 hf.write('<div id="devicedetailtitle"></div>\n') 4649 hf.write('<div id="devicedetail" style="display:none;">\n') 4650 # draw the colored boxes for the device detail section 4651 for data in testruns: 4652 hf.write('<div id="devicedetail%d">\n' % data.testnumber) 4653 pscolor = 'linear-gradient(to top left, #ccc, #eee)' 4654 hf.write(devtl.html_phaselet.format('pre_suspend_process', \ 4655 '0', '0', pscolor)) 4656 for b in data.sortedPhases(): 4657 phase = data.dmesg[b] 4658 length = phase['end']-phase['start'] 4659 left = '%.3f' % (((phase['start']-t0)*100.0)/tTotal) 4660 width = '%.3f' % ((length*100.0)/tTotal) 4661 hf.write(devtl.html_phaselet.format(b, left, width, \ 4662 data.dmesg[b]['color'])) 4663 hf.write(devtl.html_phaselet.format('post_resume_process', \ 4664 '0', '0', pscolor)) 4665 if sysvals.suspendmode == 'command': 4666 hf.write(devtl.html_phaselet.format('cmdexec', '0', '0', pscolor)) 4667 hf.write('</div>\n') 4668 hf.write('</div>\n') 4669 4670 # write the ftrace data (callgraph) 4671 if sysvals.cgtest >= 0 and len(testruns) > sysvals.cgtest: 4672 data = testruns[sysvals.cgtest] 4673 else: 4674 data = testruns[-1] 4675 if sysvals.usecallgraph: 4676 addCallgraphs(sysvals, hf, data) 4677 4678 # add the test log as a hidden div 4679 if sysvals.testlog and sysvals.logmsg: 4680 hf.write('<div id="testlog" style="display:none;">\n'+sysvals.logmsg+'</div>\n') 4681 # add the dmesg log as a hidden div 4682 if sysvals.dmesglog and sysvals.dmesgfile: 4683 hf.write('<div id="dmesglog" style="display:none;">\n') 4684 lf = sysvals.openlog(sysvals.dmesgfile, 'r') 4685 for line in lf: 4686 line = line.replace('<', '<').replace('>', '>') 4687 hf.write(line) 4688 lf.close() 4689 hf.write('</div>\n') 4690 # add the ftrace log as a hidden div 4691 if sysvals.ftracelog and sysvals.ftracefile: 4692 hf.write('<div id="ftracelog" style="display:none;">\n') 4693 lf = sysvals.openlog(sysvals.ftracefile, 'r') 4694 for line in lf: 4695 hf.write(line) 4696 lf.close() 4697 hf.write('</div>\n') 4698 4699 # write the footer and close 4700 addScriptCode(hf, testruns) 4701 hf.write('</body>\n</html>\n') 4702 hf.close() 4703 return True 4704 4705def addCSS(hf, sv, testcount=1, kerror=False, extra=''): 4706 kernel = sv.stamp['kernel'] 4707 host = sv.hostname[0].upper()+sv.hostname[1:] 4708 mode = sv.suspendmode 4709 if sv.suspendmode in suspendmodename: 4710 mode = suspendmodename[sv.suspendmode] 4711 title = host+' '+mode+' '+kernel 4712 4713 # various format changes by flags 4714 cgchk = 'checked' 4715 cgnchk = 'not(:checked)' 4716 if sv.cgexp: 4717 cgchk = 'not(:checked)' 4718 cgnchk = 'checked' 4719 4720 hoverZ = 'z-index:8;' 4721 if sv.usedevsrc: 4722 hoverZ = '' 4723 4724 devlistpos = 'absolute' 4725 if testcount > 1: 4726 devlistpos = 'relative' 4727 4728 scaleTH = 20 4729 if kerror: 4730 scaleTH = 60 4731 4732 # write the html header first (html head, css code, up to body start) 4733 html_header = '<!DOCTYPE html>\n<html>\n<head>\n\ 4734 <meta http-equiv="content-type" content="text/html; charset=UTF-8">\n\ 4735 <title>'+title+'</title>\n\ 4736 <style type=\'text/css\'>\n\ 4737 body {overflow-y:scroll;}\n\ 4738 .stamp {width:100%;text-align:center;background:gray;line-height:30px;color:white;font:25px Arial;}\n\ 4739 .stamp.sysinfo {font:10px Arial;}\n\ 4740 .callgraph {margin-top:30px;box-shadow:5px 5px 20px black;}\n\ 4741 .callgraph article * {padding-left:28px;}\n\ 4742 h1 {color:black;font:bold 30px Times;}\n\ 4743 t0 {color:black;font:bold 30px Times;}\n\ 4744 t1 {color:black;font:30px Times;}\n\ 4745 t2 {color:black;font:25px Times;}\n\ 4746 t3 {color:black;font:20px Times;white-space:nowrap;}\n\ 4747 t4 {color:black;font:bold 30px Times;line-height:60px;white-space:nowrap;}\n\ 4748 cS {font:bold 13px Times;}\n\ 4749 table {width:100%;}\n\ 4750 .gray {background:rgba(80,80,80,0.1);}\n\ 4751 .green {background:rgba(204,255,204,0.4);}\n\ 4752 .purple {background:rgba(128,0,128,0.2);}\n\ 4753 .yellow {background:rgba(255,255,204,0.4);}\n\ 4754 .blue {background:rgba(169,208,245,0.4);}\n\ 4755 .time1 {font:22px Arial;border:1px solid;}\n\ 4756 .time2 {font:15px Arial;border-bottom:1px solid;border-left:1px solid;border-right:1px solid;}\n\ 4757 .testfail {font:bold 22px Arial;color:red;border:1px dashed;}\n\ 4758 td {text-align:center;}\n\ 4759 r {color:#500000;font:15px Tahoma;}\n\ 4760 n {color:#505050;font:15px Tahoma;}\n\ 4761 .tdhl {color:red;}\n\ 4762 .hide {display:none;}\n\ 4763 .pf {display:none;}\n\ 4764 .pf:'+cgchk+' + label {background:url(\'data:image/svg+xml;utf,<?xml version="1.0" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" height="18" width="18" version="1.1"><circle cx="9" cy="9" r="8" stroke="black" stroke-width="1" fill="white"/><rect x="4" y="8" width="10" height="2" style="fill:black;stroke-width:0"/><rect x="8" y="4" width="2" height="10" style="fill:black;stroke-width:0"/></svg>\') no-repeat left center;}\n\ 4765 .pf:'+cgnchk+' ~ label {background:url(\'data:image/svg+xml;utf,<?xml version="1.0" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" height="18" width="18" version="1.1"><circle cx="9" cy="9" r="8" stroke="black" stroke-width="1" fill="white"/><rect x="4" y="8" width="10" height="2" style="fill:black;stroke-width:0"/></svg>\') no-repeat left center;}\n\ 4766 .pf:'+cgchk+' ~ *:not(:nth-child(2)) {display:none;}\n\ 4767 .zoombox {position:relative;width:100%;overflow-x:scroll;-webkit-user-select:none;-moz-user-select:none;user-select:none;}\n\ 4768 .timeline {position:relative;font-size:14px;cursor:pointer;width:100%; overflow:hidden;background:linear-gradient(#cccccc, white);}\n\ 4769 .thread {position:absolute;height:0%;overflow:hidden;z-index:7;line-height:30px;font-size:14px;border:1px solid;text-align:center;white-space:nowrap;}\n\ 4770 .thread.ps {border-radius:3px;background:linear-gradient(to top, #ccc, #eee);}\n\ 4771 .thread:hover {background:white;border:1px solid red;'+hoverZ+'}\n\ 4772 .thread.sec,.thread.sec:hover {background:black;border:0;color:white;line-height:15px;font-size:10px;}\n\ 4773 .hover {background:white;border:1px solid red;'+hoverZ+'}\n\ 4774 .hover.sync {background:white;}\n\ 4775 .hover.bg,.hover.kth,.hover.sync,.hover.ps {background:white;}\n\ 4776 .jiffie {position:absolute;pointer-events: none;z-index:8;}\n\ 4777 .traceevent {position:absolute;font-size:10px;z-index:7;overflow:hidden;color:black;text-align:center;white-space:nowrap;border-radius:5px;border:1px solid black;background:linear-gradient(to bottom right,#CCC,#969696);}\n\ 4778 .traceevent:hover {color:white;font-weight:bold;border:1px solid white;}\n\ 4779 .phase {position:absolute;overflow:hidden;border:0px;text-align:center;}\n\ 4780 .phaselet {float:left;overflow:hidden;border:0px;text-align:center;min-height:100px;font-size:24px;}\n\ 4781 .t {position:absolute;line-height:'+('%d'%scaleTH)+'px;pointer-events:none;top:0;height:100%;border-right:1px solid black;z-index:6;}\n\ 4782 .err {position:absolute;top:0%;height:100%;border-right:3px solid red;color:red;font:bold 14px Times;line-height:18px;}\n\ 4783 .legend {position:relative; width:100%; height:40px; text-align:center;margin-bottom:20px}\n\ 4784 .legend .square {position:absolute;cursor:pointer;top:10px; width:0px;height:20px;border:1px solid;padding-left:20px;}\n\ 4785 button {height:40px;width:200px;margin-bottom:20px;margin-top:20px;font-size:24px;}\n\ 4786 .btnfmt {position:relative;float:right;height:25px;width:auto;margin-top:3px;margin-bottom:0;font-size:10px;text-align:center;}\n\ 4787 .devlist {position:'+devlistpos+';width:190px;}\n\ 4788 a:link {color:white;text-decoration:none;}\n\ 4789 a:visited {color:white;}\n\ 4790 a:hover {color:white;}\n\ 4791 a:active {color:white;}\n\ 4792 .version {position:relative;float:left;color:white;font-size:10px;line-height:30px;margin-left:10px;}\n\ 4793 #devicedetail {min-height:100px;box-shadow:5px 5px 20px black;}\n\ 4794 .tblock {position:absolute;height:100%;background:#ddd;}\n\ 4795 .tback {position:absolute;width:100%;background:linear-gradient(#ccc, #ddd);}\n\ 4796 .bg {z-index:1;}\n\ 4797'+extra+'\ 4798 </style>\n</head>\n<body>\n' 4799 hf.write(html_header) 4800 4801# Function: addScriptCode 4802# Description: 4803# Adds the javascript code to the output html 4804# Arguments: 4805# hf: the open html file pointer 4806# testruns: array of Data objects from parseKernelLog or parseTraceLog 4807def addScriptCode(hf, testruns): 4808 t0 = testruns[0].start * 1000 4809 tMax = testruns[-1].end * 1000 4810 # create an array in javascript memory with the device details 4811 detail = ' var devtable = [];\n' 4812 for data in testruns: 4813 topo = data.deviceTopology() 4814 detail += ' devtable[%d] = "%s";\n' % (data.testnumber, topo) 4815 detail += ' var bounds = [%f,%f];\n' % (t0, tMax) 4816 # add the code which will manipulate the data in the browser 4817 script_code = \ 4818 '<script type="text/javascript">\n'+detail+\ 4819 ' var resolution = -1;\n'\ 4820 ' var dragval = [0, 0];\n'\ 4821 ' function redrawTimescale(t0, tMax, tS) {\n'\ 4822 ' var rline = \'<div class="t" style="left:0;border-left:1px solid black;border-right:0;">\';\n'\ 4823 ' var tTotal = tMax - t0;\n'\ 4824 ' var list = document.getElementsByClassName("tblock");\n'\ 4825 ' for (var i = 0; i < list.length; i++) {\n'\ 4826 ' var timescale = list[i].getElementsByClassName("timescale")[0];\n'\ 4827 ' var m0 = t0 + (tTotal*parseFloat(list[i].style.left)/100);\n'\ 4828 ' var mTotal = tTotal*parseFloat(list[i].style.width)/100;\n'\ 4829 ' var mMax = m0 + mTotal;\n'\ 4830 ' var html = "";\n'\ 4831 ' var divTotal = Math.floor(mTotal/tS) + 1;\n'\ 4832 ' if(divTotal > 1000) continue;\n'\ 4833 ' var divEdge = (mTotal - tS*(divTotal-1))*100/mTotal;\n'\ 4834 ' var pos = 0.0, val = 0.0;\n'\ 4835 ' for (var j = 0; j < divTotal; j++) {\n'\ 4836 ' var htmlline = "";\n'\ 4837 ' var mode = list[i].id[5];\n'\ 4838 ' if(mode == "s") {\n'\ 4839 ' pos = 100 - (((j)*tS*100)/mTotal) - divEdge;\n'\ 4840 ' val = (j-divTotal+1)*tS;\n'\ 4841 ' if(j == divTotal - 1)\n'\ 4842 ' htmlline = \'<div class="t" style="right:\'+pos+\'%"><cS>S→</cS></div>\';\n'\ 4843 ' else\n'\ 4844 ' htmlline = \'<div class="t" style="right:\'+pos+\'%">\'+val+\'ms</div>\';\n'\ 4845 ' } else {\n'\ 4846 ' pos = 100 - (((j)*tS*100)/mTotal);\n'\ 4847 ' val = (j)*tS;\n'\ 4848 ' htmlline = \'<div class="t" style="right:\'+pos+\'%">\'+val+\'ms</div>\';\n'\ 4849 ' if(j == 0)\n'\ 4850 ' if(mode == "r")\n'\ 4851 ' htmlline = rline+"<cS>←R</cS></div>";\n'\ 4852 ' else\n'\ 4853 ' htmlline = rline+"<cS>0ms</div>";\n'\ 4854 ' }\n'\ 4855 ' html += htmlline;\n'\ 4856 ' }\n'\ 4857 ' timescale.innerHTML = html;\n'\ 4858 ' }\n'\ 4859 ' }\n'\ 4860 ' function zoomTimeline() {\n'\ 4861 ' var dmesg = document.getElementById("dmesg");\n'\ 4862 ' var zoombox = document.getElementById("dmesgzoombox");\n'\ 4863 ' var left = zoombox.scrollLeft;\n'\ 4864 ' var val = parseFloat(dmesg.style.width);\n'\ 4865 ' var newval = 100;\n'\ 4866 ' var sh = window.outerWidth / 2;\n'\ 4867 ' if(this.id == "zoomin") {\n'\ 4868 ' newval = val * 1.2;\n'\ 4869 ' if(newval > 910034) newval = 910034;\n'\ 4870 ' dmesg.style.width = newval+"%";\n'\ 4871 ' zoombox.scrollLeft = ((left + sh) * newval / val) - sh;\n'\ 4872 ' } else if (this.id == "zoomout") {\n'\ 4873 ' newval = val / 1.2;\n'\ 4874 ' if(newval < 100) newval = 100;\n'\ 4875 ' dmesg.style.width = newval+"%";\n'\ 4876 ' zoombox.scrollLeft = ((left + sh) * newval / val) - sh;\n'\ 4877 ' } else {\n'\ 4878 ' zoombox.scrollLeft = 0;\n'\ 4879 ' dmesg.style.width = "100%";\n'\ 4880 ' }\n'\ 4881 ' var tS = [10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1];\n'\ 4882 ' var t0 = bounds[0];\n'\ 4883 ' var tMax = bounds[1];\n'\ 4884 ' var tTotal = tMax - t0;\n'\ 4885 ' var wTotal = tTotal * 100.0 / newval;\n'\ 4886 ' var idx = 7*window.innerWidth/1100;\n'\ 4887 ' for(var i = 0; (i < tS.length)&&((wTotal / tS[i]) < idx); i++);\n'\ 4888 ' if(i >= tS.length) i = tS.length - 1;\n'\ 4889 ' if(tS[i] == resolution) return;\n'\ 4890 ' resolution = tS[i];\n'\ 4891 ' redrawTimescale(t0, tMax, tS[i]);\n'\ 4892 ' }\n'\ 4893 ' function deviceName(title) {\n'\ 4894 ' var name = title.slice(0, title.indexOf(" ("));\n'\ 4895 ' return name;\n'\ 4896 ' }\n'\ 4897 ' function deviceHover() {\n'\ 4898 ' var name = deviceName(this.title);\n'\ 4899 ' var dmesg = document.getElementById("dmesg");\n'\ 4900 ' var dev = dmesg.getElementsByClassName("thread");\n'\ 4901 ' var cpu = -1;\n'\ 4902 ' if(name.match("CPU_ON\[[0-9]*\]"))\n'\ 4903 ' cpu = parseInt(name.slice(7));\n'\ 4904 ' else if(name.match("CPU_OFF\[[0-9]*\]"))\n'\ 4905 ' cpu = parseInt(name.slice(8));\n'\ 4906 ' for (var i = 0; i < dev.length; i++) {\n'\ 4907 ' dname = deviceName(dev[i].title);\n'\ 4908 ' var cname = dev[i].className.slice(dev[i].className.indexOf("thread"));\n'\ 4909 ' if((cpu >= 0 && dname.match("CPU_O[NF]*\\\[*"+cpu+"\\\]")) ||\n'\ 4910 ' (name == dname))\n'\ 4911 ' {\n'\ 4912 ' dev[i].className = "hover "+cname;\n'\ 4913 ' } else {\n'\ 4914 ' dev[i].className = cname;\n'\ 4915 ' }\n'\ 4916 ' }\n'\ 4917 ' }\n'\ 4918 ' function deviceUnhover() {\n'\ 4919 ' var dmesg = document.getElementById("dmesg");\n'\ 4920 ' var dev = dmesg.getElementsByClassName("thread");\n'\ 4921 ' for (var i = 0; i < dev.length; i++) {\n'\ 4922 ' dev[i].className = dev[i].className.slice(dev[i].className.indexOf("thread"));\n'\ 4923 ' }\n'\ 4924 ' }\n'\ 4925 ' function deviceTitle(title, total, cpu) {\n'\ 4926 ' var prefix = "Total";\n'\ 4927 ' if(total.length > 3) {\n'\ 4928 ' prefix = "Average";\n'\ 4929 ' total[1] = (total[1]+total[3])/2;\n'\ 4930 ' total[2] = (total[2]+total[4])/2;\n'\ 4931 ' }\n'\ 4932 ' var devtitle = document.getElementById("devicedetailtitle");\n'\ 4933 ' var name = deviceName(title);\n'\ 4934 ' if(cpu >= 0) name = "CPU"+cpu;\n'\ 4935 ' var driver = "";\n'\ 4936 ' var tS = "<t2>(</t2>";\n'\ 4937 ' var tR = "<t2>)</t2>";\n'\ 4938 ' if(total[1] > 0)\n'\ 4939 ' tS = "<t2>("+prefix+" Suspend:</t2><t0> "+total[1].toFixed(3)+" ms</t0> ";\n'\ 4940 ' if(total[2] > 0)\n'\ 4941 ' tR = " <t2>"+prefix+" Resume:</t2><t0> "+total[2].toFixed(3)+" ms<t2>)</t2></t0>";\n'\ 4942 ' var s = title.indexOf("{");\n'\ 4943 ' var e = title.indexOf("}");\n'\ 4944 ' if((s >= 0) && (e >= 0))\n'\ 4945 ' driver = title.slice(s+1, e) + " <t1>@</t1> ";\n'\ 4946 ' if(total[1] > 0 && total[2] > 0)\n'\ 4947 ' devtitle.innerHTML = "<t0>"+driver+name+"</t0> "+tS+tR;\n'\ 4948 ' else\n'\ 4949 ' devtitle.innerHTML = "<t0>"+title+"</t0>";\n'\ 4950 ' return name;\n'\ 4951 ' }\n'\ 4952 ' function deviceDetail() {\n'\ 4953 ' var devinfo = document.getElementById("devicedetail");\n'\ 4954 ' devinfo.style.display = "block";\n'\ 4955 ' var name = deviceName(this.title);\n'\ 4956 ' var cpu = -1;\n'\ 4957 ' if(name.match("CPU_ON\[[0-9]*\]"))\n'\ 4958 ' cpu = parseInt(name.slice(7));\n'\ 4959 ' else if(name.match("CPU_OFF\[[0-9]*\]"))\n'\ 4960 ' cpu = parseInt(name.slice(8));\n'\ 4961 ' var dmesg = document.getElementById("dmesg");\n'\ 4962 ' var dev = dmesg.getElementsByClassName("thread");\n'\ 4963 ' var idlist = [];\n'\ 4964 ' var pdata = [[]];\n'\ 4965 ' if(document.getElementById("devicedetail1"))\n'\ 4966 ' pdata = [[], []];\n'\ 4967 ' var pd = pdata[0];\n'\ 4968 ' var total = [0.0, 0.0, 0.0];\n'\ 4969 ' for (var i = 0; i < dev.length; i++) {\n'\ 4970 ' dname = deviceName(dev[i].title);\n'\ 4971 ' if((cpu >= 0 && dname.match("CPU_O[NF]*\\\[*"+cpu+"\\\]")) ||\n'\ 4972 ' (name == dname))\n'\ 4973 ' {\n'\ 4974 ' idlist[idlist.length] = dev[i].id;\n'\ 4975 ' var tidx = 1;\n'\ 4976 ' if(dev[i].id[0] == "a") {\n'\ 4977 ' pd = pdata[0];\n'\ 4978 ' } else {\n'\ 4979 ' if(pdata.length == 1) pdata[1] = [];\n'\ 4980 ' if(total.length == 3) total[3]=total[4]=0.0;\n'\ 4981 ' pd = pdata[1];\n'\ 4982 ' tidx = 3;\n'\ 4983 ' }\n'\ 4984 ' var info = dev[i].title.split(" ");\n'\ 4985 ' var pname = info[info.length-1];\n'\ 4986 ' pd[pname] = parseFloat(info[info.length-3].slice(1));\n'\ 4987 ' total[0] += pd[pname];\n'\ 4988 ' if(pname.indexOf("suspend") >= 0)\n'\ 4989 ' total[tidx] += pd[pname];\n'\ 4990 ' else\n'\ 4991 ' total[tidx+1] += pd[pname];\n'\ 4992 ' }\n'\ 4993 ' }\n'\ 4994 ' var devname = deviceTitle(this.title, total, cpu);\n'\ 4995 ' var left = 0.0;\n'\ 4996 ' for (var t = 0; t < pdata.length; t++) {\n'\ 4997 ' pd = pdata[t];\n'\ 4998 ' devinfo = document.getElementById("devicedetail"+t);\n'\ 4999 ' var phases = devinfo.getElementsByClassName("phaselet");\n'\ 5000 ' for (var i = 0; i < phases.length; i++) {\n'\ 5001 ' if(phases[i].id in pd) {\n'\ 5002 ' var w = 100.0*pd[phases[i].id]/total[0];\n'\ 5003 ' var fs = 32;\n'\ 5004 ' if(w < 8) fs = 4*w | 0;\n'\ 5005 ' var fs2 = fs*3/4;\n'\ 5006 ' phases[i].style.width = w+"%";\n'\ 5007 ' phases[i].style.left = left+"%";\n'\ 5008 ' phases[i].title = phases[i].id+" "+pd[phases[i].id]+" ms";\n'\ 5009 ' left += w;\n'\ 5010 ' var time = "<t4 style=\\"font-size:"+fs+"px\\">"+pd[phases[i].id]+" ms<br></t4>";\n'\ 5011 ' var pname = "<t3 style=\\"font-size:"+fs2+"px\\">"+phases[i].id.replace(new RegExp("_", "g"), " ")+"</t3>";\n'\ 5012 ' phases[i].innerHTML = time+pname;\n'\ 5013 ' } else {\n'\ 5014 ' phases[i].style.width = "0%";\n'\ 5015 ' phases[i].style.left = left+"%";\n'\ 5016 ' }\n'\ 5017 ' }\n'\ 5018 ' }\n'\ 5019 ' if(typeof devstats !== \'undefined\')\n'\ 5020 ' callDetail(this.id, this.title);\n'\ 5021 ' var cglist = document.getElementById("callgraphs");\n'\ 5022 ' if(!cglist) return;\n'\ 5023 ' var cg = cglist.getElementsByClassName("atop");\n'\ 5024 ' if(cg.length < 10) return;\n'\ 5025 ' for (var i = 0; i < cg.length; i++) {\n'\ 5026 ' cgid = cg[i].id.split("x")[0]\n'\ 5027 ' if(idlist.indexOf(cgid) >= 0) {\n'\ 5028 ' cg[i].style.display = "block";\n'\ 5029 ' } else {\n'\ 5030 ' cg[i].style.display = "none";\n'\ 5031 ' }\n'\ 5032 ' }\n'\ 5033 ' }\n'\ 5034 ' function callDetail(devid, devtitle) {\n'\ 5035 ' if(!(devid in devstats) || devstats[devid].length < 1)\n'\ 5036 ' return;\n'\ 5037 ' var list = devstats[devid];\n'\ 5038 ' var tmp = devtitle.split(" ");\n'\ 5039 ' var name = tmp[0], phase = tmp[tmp.length-1];\n'\ 5040 ' var dd = document.getElementById(phase);\n'\ 5041 ' var total = parseFloat(tmp[1].slice(1));\n'\ 5042 ' var mlist = [];\n'\ 5043 ' var maxlen = 0;\n'\ 5044 ' var info = []\n'\ 5045 ' for(var i in list) {\n'\ 5046 ' if(list[i][0] == "@") {\n'\ 5047 ' info = list[i].split("|");\n'\ 5048 ' continue;\n'\ 5049 ' }\n'\ 5050 ' var tmp = list[i].split("|");\n'\ 5051 ' var t = parseFloat(tmp[0]), f = tmp[1], c = parseInt(tmp[2]);\n'\ 5052 ' var p = (t*100.0/total).toFixed(2);\n'\ 5053 ' mlist[mlist.length] = [f, c, t.toFixed(2), p+"%"];\n'\ 5054 ' if(f.length > maxlen)\n'\ 5055 ' maxlen = f.length;\n'\ 5056 ' }\n'\ 5057 ' var pad = 5;\n'\ 5058 ' if(mlist.length == 0) pad = 30;\n'\ 5059 ' var html = \'<div style="padding-top:\'+pad+\'px"><t3> <b>\'+name+\':</b>\';\n'\ 5060 ' if(info.length > 2)\n'\ 5061 ' html += " start=<b>"+info[1]+"</b>, end=<b>"+info[2]+"</b>";\n'\ 5062 ' if(info.length > 3)\n'\ 5063 ' html += ", length<i>(w/o overhead)</i>=<b>"+info[3]+" ms</b>";\n'\ 5064 ' if(info.length > 4)\n'\ 5065 ' html += ", return=<b>"+info[4]+"</b>";\n'\ 5066 ' html += "</t3></div>";\n'\ 5067 ' if(mlist.length > 0) {\n'\ 5068 ' html += \'<table class=fstat style="padding-top:\'+(maxlen*5)+\'px;"><tr><th>Function</th>\';\n'\ 5069 ' for(var i in mlist)\n'\ 5070 ' html += "<td class=vt>"+mlist[i][0]+"</td>";\n'\ 5071 ' html += "</tr><tr><th>Calls</th>";\n'\ 5072 ' for(var i in mlist)\n'\ 5073 ' html += "<td>"+mlist[i][1]+"</td>";\n'\ 5074 ' html += "</tr><tr><th>Time(ms)</th>";\n'\ 5075 ' for(var i in mlist)\n'\ 5076 ' html += "<td>"+mlist[i][2]+"</td>";\n'\ 5077 ' html += "</tr><tr><th>Percent</th>";\n'\ 5078 ' for(var i in mlist)\n'\ 5079 ' html += "<td>"+mlist[i][3]+"</td>";\n'\ 5080 ' html += "</tr></table>";\n'\ 5081 ' }\n'\ 5082 ' dd.innerHTML = html;\n'\ 5083 ' var height = (maxlen*5)+100;\n'\ 5084 ' dd.style.height = height+"px";\n'\ 5085 ' document.getElementById("devicedetail").style.height = height+"px";\n'\ 5086 ' }\n'\ 5087 ' function callSelect() {\n'\ 5088 ' var cglist = document.getElementById("callgraphs");\n'\ 5089 ' if(!cglist) return;\n'\ 5090 ' var cg = cglist.getElementsByClassName("atop");\n'\ 5091 ' for (var i = 0; i < cg.length; i++) {\n'\ 5092 ' if(this.id == cg[i].id) {\n'\ 5093 ' cg[i].style.display = "block";\n'\ 5094 ' } else {\n'\ 5095 ' cg[i].style.display = "none";\n'\ 5096 ' }\n'\ 5097 ' }\n'\ 5098 ' }\n'\ 5099 ' function devListWindow(e) {\n'\ 5100 ' var win = window.open();\n'\ 5101 ' var html = "<title>"+e.target.innerHTML+"</title>"+\n'\ 5102 ' "<style type=\\"text/css\\">"+\n'\ 5103 ' " ul {list-style-type:circle;padding-left:10px;margin-left:10px;}"+\n'\ 5104 ' "</style>"\n'\ 5105 ' var dt = devtable[0];\n'\ 5106 ' if(e.target.id != "devlist1")\n'\ 5107 ' dt = devtable[1];\n'\ 5108 ' win.document.write(html+dt);\n'\ 5109 ' }\n'\ 5110 ' function errWindow() {\n'\ 5111 ' var range = this.id.split("_");\n'\ 5112 ' var idx1 = parseInt(range[0]);\n'\ 5113 ' var idx2 = parseInt(range[1]);\n'\ 5114 ' var win = window.open();\n'\ 5115 ' var log = document.getElementById("dmesglog");\n'\ 5116 ' var title = "<title>dmesg log</title>";\n'\ 5117 ' var text = log.innerHTML.split("\\n");\n'\ 5118 ' var html = "";\n'\ 5119 ' for(var i = 0; i < text.length; i++) {\n'\ 5120 ' if(i == idx1) {\n'\ 5121 ' html += "<e id=target>"+text[i]+"</e>\\n";\n'\ 5122 ' } else if(i > idx1 && i <= idx2) {\n'\ 5123 ' html += "<e>"+text[i]+"</e>\\n";\n'\ 5124 ' } else {\n'\ 5125 ' html += text[i]+"\\n";\n'\ 5126 ' }\n'\ 5127 ' }\n'\ 5128 ' win.document.write("<style>e{color:red}</style>"+title+"<pre>"+html+"</pre>");\n'\ 5129 ' win.location.hash = "#target";\n'\ 5130 ' win.document.close();\n'\ 5131 ' }\n'\ 5132 ' function logWindow(e) {\n'\ 5133 ' var name = e.target.id.slice(4);\n'\ 5134 ' var win = window.open();\n'\ 5135 ' var log = document.getElementById(name+"log");\n'\ 5136 ' var title = "<title>"+document.title.split(" ")[0]+" "+name+" log</title>";\n'\ 5137 ' win.document.write(title+"<pre>"+log.innerHTML+"</pre>");\n'\ 5138 ' win.document.close();\n'\ 5139 ' }\n'\ 5140 ' function onMouseDown(e) {\n'\ 5141 ' dragval[0] = e.clientX;\n'\ 5142 ' dragval[1] = document.getElementById("dmesgzoombox").scrollLeft;\n'\ 5143 ' document.onmousemove = onMouseMove;\n'\ 5144 ' }\n'\ 5145 ' function onMouseMove(e) {\n'\ 5146 ' var zoombox = document.getElementById("dmesgzoombox");\n'\ 5147 ' zoombox.scrollLeft = dragval[1] + dragval[0] - e.clientX;\n'\ 5148 ' }\n'\ 5149 ' function onMouseUp(e) {\n'\ 5150 ' document.onmousemove = null;\n'\ 5151 ' }\n'\ 5152 ' function onKeyPress(e) {\n'\ 5153 ' var c = e.charCode;\n'\ 5154 ' if(c != 42 && c != 43 && c != 45) return;\n'\ 5155 ' var click = document.createEvent("Events");\n'\ 5156 ' click.initEvent("click", true, false);\n'\ 5157 ' if(c == 43) \n'\ 5158 ' document.getElementById("zoomin").dispatchEvent(click);\n'\ 5159 ' else if(c == 45)\n'\ 5160 ' document.getElementById("zoomout").dispatchEvent(click);\n'\ 5161 ' else if(c == 42)\n'\ 5162 ' document.getElementById("zoomdef").dispatchEvent(click);\n'\ 5163 ' }\n'\ 5164 ' window.addEventListener("resize", function () {zoomTimeline();});\n'\ 5165 ' window.addEventListener("load", function () {\n'\ 5166 ' var dmesg = document.getElementById("dmesg");\n'\ 5167 ' dmesg.style.width = "100%"\n'\ 5168 ' dmesg.onmousedown = onMouseDown;\n'\ 5169 ' document.onmouseup = onMouseUp;\n'\ 5170 ' document.onkeypress = onKeyPress;\n'\ 5171 ' document.getElementById("zoomin").onclick = zoomTimeline;\n'\ 5172 ' document.getElementById("zoomout").onclick = zoomTimeline;\n'\ 5173 ' document.getElementById("zoomdef").onclick = zoomTimeline;\n'\ 5174 ' var list = document.getElementsByClassName("err");\n'\ 5175 ' for (var i = 0; i < list.length; i++)\n'\ 5176 ' list[i].onclick = errWindow;\n'\ 5177 ' var list = document.getElementsByClassName("logbtn");\n'\ 5178 ' for (var i = 0; i < list.length; i++)\n'\ 5179 ' list[i].onclick = logWindow;\n'\ 5180 ' list = document.getElementsByClassName("devlist");\n'\ 5181 ' for (var i = 0; i < list.length; i++)\n'\ 5182 ' list[i].onclick = devListWindow;\n'\ 5183 ' var dev = dmesg.getElementsByClassName("thread");\n'\ 5184 ' for (var i = 0; i < dev.length; i++) {\n'\ 5185 ' dev[i].onclick = deviceDetail;\n'\ 5186 ' dev[i].onmouseover = deviceHover;\n'\ 5187 ' dev[i].onmouseout = deviceUnhover;\n'\ 5188 ' }\n'\ 5189 ' var dev = dmesg.getElementsByClassName("srccall");\n'\ 5190 ' for (var i = 0; i < dev.length; i++)\n'\ 5191 ' dev[i].onclick = callSelect;\n'\ 5192 ' zoomTimeline();\n'\ 5193 ' });\n'\ 5194 '</script>\n' 5195 hf.write(script_code); 5196 5197def setRuntimeSuspend(before=True): 5198 global sysvals 5199 sv = sysvals 5200 if sv.rs == 0: 5201 return 5202 if before: 5203 # runtime suspend disable or enable 5204 if sv.rs > 0: 5205 sv.rstgt, sv.rsval, sv.rsdir = 'on', 'auto', 'enabled' 5206 else: 5207 sv.rstgt, sv.rsval, sv.rsdir = 'auto', 'on', 'disabled' 5208 pprint('CONFIGURING RUNTIME SUSPEND...') 5209 sv.rslist = deviceInfo(sv.rstgt) 5210 for i in sv.rslist: 5211 sv.setVal(sv.rsval, i) 5212 pprint('runtime suspend %s on all devices (%d changed)' % (sv.rsdir, len(sv.rslist))) 5213 pprint('waiting 5 seconds...') 5214 time.sleep(5) 5215 else: 5216 # runtime suspend re-enable or re-disable 5217 for i in sv.rslist: 5218 sv.setVal(sv.rstgt, i) 5219 pprint('runtime suspend settings restored on %d devices' % len(sv.rslist)) 5220 5221# Function: executeSuspend 5222# Description: 5223# Execute system suspend through the sysfs interface, then copy the output 5224# dmesg and ftrace files to the test output directory. 5225def executeSuspend(quiet=False): 5226 pm = ProcessMonitor() 5227 tp = sysvals.tpath 5228 if sysvals.wifi: 5229 wifi = sysvals.checkWifi() 5230 testdata = [] 5231 # run these commands to prepare the system for suspend 5232 if sysvals.display: 5233 if not quiet: 5234 pprint('SET DISPLAY TO %s' % sysvals.display.upper()) 5235 displayControl(sysvals.display) 5236 time.sleep(1) 5237 if sysvals.sync: 5238 if not quiet: 5239 pprint('SYNCING FILESYSTEMS') 5240 call('sync', shell=True) 5241 # mark the start point in the kernel ring buffer just as we start 5242 sysvals.initdmesg() 5243 # start ftrace 5244 if(sysvals.usecallgraph or sysvals.usetraceevents): 5245 if not quiet: 5246 pprint('START TRACING') 5247 sysvals.fsetVal('1', 'tracing_on') 5248 if sysvals.useprocmon: 5249 pm.start() 5250 sysvals.cmdinfo(True) 5251 # execute however many s/r runs requested 5252 for count in range(1,sysvals.execcount+1): 5253 # x2delay in between test runs 5254 if(count > 1 and sysvals.x2delay > 0): 5255 sysvals.fsetVal('WAIT %d' % sysvals.x2delay, 'trace_marker') 5256 time.sleep(sysvals.x2delay/1000.0) 5257 sysvals.fsetVal('WAIT END', 'trace_marker') 5258 # start message 5259 if sysvals.testcommand != '': 5260 pprint('COMMAND START') 5261 else: 5262 if(sysvals.rtcwake): 5263 pprint('SUSPEND START') 5264 else: 5265 pprint('SUSPEND START (press a key to resume)') 5266 # set rtcwake 5267 if(sysvals.rtcwake): 5268 if not quiet: 5269 pprint('will issue an rtcwake in %d seconds' % sysvals.rtcwaketime) 5270 sysvals.rtcWakeAlarmOn() 5271 # start of suspend trace marker 5272 if(sysvals.usecallgraph or sysvals.usetraceevents): 5273 sysvals.fsetVal(datetime.now().strftime(sysvals.tmstart), 'trace_marker') 5274 # predelay delay 5275 if(count == 1 and sysvals.predelay > 0): 5276 sysvals.fsetVal('WAIT %d' % sysvals.predelay, 'trace_marker') 5277 time.sleep(sysvals.predelay/1000.0) 5278 sysvals.fsetVal('WAIT END', 'trace_marker') 5279 # initiate suspend or command 5280 tdata = {'error': ''} 5281 if sysvals.testcommand != '': 5282 res = call(sysvals.testcommand+' 2>&1', shell=True); 5283 if res != 0: 5284 tdata['error'] = 'cmd returned %d' % res 5285 else: 5286 mode = sysvals.suspendmode 5287 if sysvals.memmode and os.path.exists(sysvals.mempowerfile): 5288 mode = 'mem' 5289 pf = open(sysvals.mempowerfile, 'w') 5290 pf.write(sysvals.memmode) 5291 pf.close() 5292 if sysvals.diskmode and os.path.exists(sysvals.diskpowerfile): 5293 mode = 'disk' 5294 pf = open(sysvals.diskpowerfile, 'w') 5295 pf.write(sysvals.diskmode) 5296 pf.close() 5297 if mode == 'freeze' and sysvals.haveTurbostat(): 5298 # execution will pause here 5299 turbo = sysvals.turbostat() 5300 if turbo: 5301 tdata['turbo'] = turbo 5302 else: 5303 pf = open(sysvals.powerfile, 'w') 5304 pf.write(mode) 5305 # execution will pause here 5306 try: 5307 pf.close() 5308 except Exception as e: 5309 tdata['error'] = str(e) 5310 if(sysvals.rtcwake): 5311 sysvals.rtcWakeAlarmOff() 5312 # postdelay delay 5313 if(count == sysvals.execcount and sysvals.postdelay > 0): 5314 sysvals.fsetVal('WAIT %d' % sysvals.postdelay, 'trace_marker') 5315 time.sleep(sysvals.postdelay/1000.0) 5316 sysvals.fsetVal('WAIT END', 'trace_marker') 5317 # return from suspend 5318 pprint('RESUME COMPLETE') 5319 if(sysvals.usecallgraph or sysvals.usetraceevents): 5320 sysvals.fsetVal(datetime.now().strftime(sysvals.tmend), 'trace_marker') 5321 if sysvals.wifi and wifi: 5322 tdata['wifi'] = sysvals.pollWifi(wifi) 5323 if(sysvals.suspendmode == 'mem' or sysvals.suspendmode == 'command'): 5324 tdata['fw'] = getFPDT(False) 5325 testdata.append(tdata) 5326 cmdafter = sysvals.cmdinfo(False) 5327 # stop ftrace 5328 if(sysvals.usecallgraph or sysvals.usetraceevents): 5329 if sysvals.useprocmon: 5330 pm.stop() 5331 sysvals.fsetVal('0', 'tracing_on') 5332 # grab a copy of the dmesg output 5333 if not quiet: 5334 pprint('CAPTURING DMESG') 5335 sysvals.getdmesg(testdata) 5336 # grab a copy of the ftrace output 5337 if(sysvals.usecallgraph or sysvals.usetraceevents): 5338 if not quiet: 5339 pprint('CAPTURING TRACE') 5340 op = sysvals.writeDatafileHeader(sysvals.ftracefile, testdata) 5341 fp = open(tp+'trace', 'r') 5342 for line in fp: 5343 op.write(line) 5344 op.close() 5345 sysvals.fsetVal('', 'trace') 5346 sysvals.platforminfo(cmdafter) 5347 5348def readFile(file): 5349 if os.path.islink(file): 5350 return os.readlink(file).split('/')[-1] 5351 else: 5352 return sysvals.getVal(file).strip() 5353 5354# Function: ms2nice 5355# Description: 5356# Print out a very concise time string in minutes and seconds 5357# Output: 5358# The time string, e.g. "1901m16s" 5359def ms2nice(val): 5360 val = int(val) 5361 h = val // 3600000 5362 m = (val // 60000) % 60 5363 s = (val // 1000) % 60 5364 if h > 0: 5365 return '%d:%02d:%02d' % (h, m, s) 5366 if m > 0: 5367 return '%02d:%02d' % (m, s) 5368 return '%ds' % s 5369 5370def yesno(val): 5371 list = {'enabled':'A', 'disabled':'S', 'auto':'E', 'on':'D', 5372 'active':'A', 'suspended':'S', 'suspending':'S'} 5373 if val not in list: 5374 return ' ' 5375 return list[val] 5376 5377# Function: deviceInfo 5378# Description: 5379# Detect all the USB hosts and devices currently connected and add 5380# a list of USB device names to sysvals for better timeline readability 5381def deviceInfo(output=''): 5382 if not output: 5383 pprint('LEGEND\n'\ 5384 '---------------------------------------------------------------------------------------------\n'\ 5385 ' A = async/sync PM queue (A/S) C = runtime active children\n'\ 5386 ' R = runtime suspend enabled/disabled (E/D) rACTIVE = runtime active (min/sec)\n'\ 5387 ' S = runtime status active/suspended (A/S) rSUSPEND = runtime suspend (min/sec)\n'\ 5388 ' U = runtime usage count\n'\ 5389 '---------------------------------------------------------------------------------------------\n'\ 5390 'DEVICE NAME A R S U C rACTIVE rSUSPEND\n'\ 5391 '---------------------------------------------------------------------------------------------') 5392 5393 res = [] 5394 tgtval = 'runtime_status' 5395 lines = dict() 5396 for dirname, dirnames, filenames in os.walk('/sys/devices'): 5397 if(not re.match('.*/power', dirname) or 5398 'control' not in filenames or 5399 tgtval not in filenames): 5400 continue 5401 name = '' 5402 dirname = dirname[:-6] 5403 device = dirname.split('/')[-1] 5404 power = dict() 5405 power[tgtval] = readFile('%s/power/%s' % (dirname, tgtval)) 5406 # only list devices which support runtime suspend 5407 if power[tgtval] not in ['active', 'suspended', 'suspending']: 5408 continue 5409 for i in ['product', 'driver', 'subsystem']: 5410 file = '%s/%s' % (dirname, i) 5411 if os.path.exists(file): 5412 name = readFile(file) 5413 break 5414 for i in ['async', 'control', 'runtime_status', 'runtime_usage', 5415 'runtime_active_kids', 'runtime_active_time', 5416 'runtime_suspended_time']: 5417 if i in filenames: 5418 power[i] = readFile('%s/power/%s' % (dirname, i)) 5419 if output: 5420 if power['control'] == output: 5421 res.append('%s/power/control' % dirname) 5422 continue 5423 lines[dirname] = '%-26s %-26s %1s %1s %1s %1s %1s %10s %10s' % \ 5424 (device[:26], name[:26], 5425 yesno(power['async']), \ 5426 yesno(power['control']), \ 5427 yesno(power['runtime_status']), \ 5428 power['runtime_usage'], \ 5429 power['runtime_active_kids'], \ 5430 ms2nice(power['runtime_active_time']), \ 5431 ms2nice(power['runtime_suspended_time'])) 5432 for i in sorted(lines): 5433 print(lines[i]) 5434 return res 5435 5436# Function: getModes 5437# Description: 5438# Determine the supported power modes on this system 5439# Output: 5440# A string list of the available modes 5441def getModes(): 5442 modes = [] 5443 if(os.path.exists(sysvals.powerfile)): 5444 fp = open(sysvals.powerfile, 'r') 5445 modes = fp.read().split() 5446 fp.close() 5447 if(os.path.exists(sysvals.mempowerfile)): 5448 deep = False 5449 fp = open(sysvals.mempowerfile, 'r') 5450 for m in fp.read().split(): 5451 memmode = m.strip('[]') 5452 if memmode == 'deep': 5453 deep = True 5454 else: 5455 modes.append('mem-%s' % memmode) 5456 fp.close() 5457 if 'mem' in modes and not deep: 5458 modes.remove('mem') 5459 if('disk' in modes and os.path.exists(sysvals.diskpowerfile)): 5460 fp = open(sysvals.diskpowerfile, 'r') 5461 for m in fp.read().split(): 5462 modes.append('disk-%s' % m.strip('[]')) 5463 fp.close() 5464 return modes 5465 5466# Function: dmidecode 5467# Description: 5468# Read the bios tables and pull out system info 5469# Arguments: 5470# mempath: /dev/mem or custom mem path 5471# fatal: True to exit on error, False to return empty dict 5472# Output: 5473# A dict object with all available key/values 5474def dmidecode(mempath, fatal=False): 5475 out = dict() 5476 5477 # the list of values to retrieve, with hardcoded (type, idx) 5478 info = { 5479 'bios-vendor': (0, 4), 5480 'bios-version': (0, 5), 5481 'bios-release-date': (0, 8), 5482 'system-manufacturer': (1, 4), 5483 'system-product-name': (1, 5), 5484 'system-version': (1, 6), 5485 'system-serial-number': (1, 7), 5486 'baseboard-manufacturer': (2, 4), 5487 'baseboard-product-name': (2, 5), 5488 'baseboard-version': (2, 6), 5489 'baseboard-serial-number': (2, 7), 5490 'chassis-manufacturer': (3, 4), 5491 'chassis-type': (3, 5), 5492 'chassis-version': (3, 6), 5493 'chassis-serial-number': (3, 7), 5494 'processor-manufacturer': (4, 7), 5495 'processor-version': (4, 16), 5496 } 5497 if(not os.path.exists(mempath)): 5498 if(fatal): 5499 doError('file does not exist: %s' % mempath) 5500 return out 5501 if(not os.access(mempath, os.R_OK)): 5502 if(fatal): 5503 doError('file is not readable: %s' % mempath) 5504 return out 5505 5506 # by default use legacy scan, but try to use EFI first 5507 memaddr = 0xf0000 5508 memsize = 0x10000 5509 for ep in ['/sys/firmware/efi/systab', '/proc/efi/systab']: 5510 if not os.path.exists(ep) or not os.access(ep, os.R_OK): 5511 continue 5512 fp = open(ep, 'r') 5513 buf = fp.read() 5514 fp.close() 5515 i = buf.find('SMBIOS=') 5516 if i >= 0: 5517 try: 5518 memaddr = int(buf[i+7:], 16) 5519 memsize = 0x20 5520 except: 5521 continue 5522 5523 # read in the memory for scanning 5524 try: 5525 fp = open(mempath, 'rb') 5526 fp.seek(memaddr) 5527 buf = fp.read(memsize) 5528 except: 5529 if(fatal): 5530 doError('DMI table is unreachable, sorry') 5531 else: 5532 pprint('WARNING: /dev/mem is not readable, ignoring DMI data') 5533 return out 5534 fp.close() 5535 5536 # search for either an SM table or DMI table 5537 i = base = length = num = 0 5538 while(i < memsize): 5539 if buf[i:i+4] == b'_SM_' and i < memsize - 16: 5540 length = struct.unpack('H', buf[i+22:i+24])[0] 5541 base, num = struct.unpack('IH', buf[i+24:i+30]) 5542 break 5543 elif buf[i:i+5] == b'_DMI_': 5544 length = struct.unpack('H', buf[i+6:i+8])[0] 5545 base, num = struct.unpack('IH', buf[i+8:i+14]) 5546 break 5547 i += 16 5548 if base == 0 and length == 0 and num == 0: 5549 if(fatal): 5550 doError('Neither SMBIOS nor DMI were found') 5551 else: 5552 return out 5553 5554 # read in the SM or DMI table 5555 try: 5556 fp = open(mempath, 'rb') 5557 fp.seek(base) 5558 buf = fp.read(length) 5559 except: 5560 if(fatal): 5561 doError('DMI table is unreachable, sorry') 5562 else: 5563 pprint('WARNING: /dev/mem is not readable, ignoring DMI data') 5564 return out 5565 fp.close() 5566 5567 # scan the table for the values we want 5568 count = i = 0 5569 while(count < num and i <= len(buf) - 4): 5570 type, size, handle = struct.unpack('BBH', buf[i:i+4]) 5571 n = i + size 5572 while n < len(buf) - 1: 5573 if 0 == struct.unpack('H', buf[n:n+2])[0]: 5574 break 5575 n += 1 5576 data = buf[i+size:n+2].split(b'\0') 5577 for name in info: 5578 itype, idxadr = info[name] 5579 if itype == type: 5580 idx = struct.unpack('B', buf[i+idxadr:i+idxadr+1])[0] 5581 if idx > 0 and idx < len(data) - 1: 5582 s = data[idx-1].decode('utf-8') 5583 if s.strip() and s.strip().lower() != 'to be filled by o.e.m.': 5584 out[name] = s 5585 i = n + 2 5586 count += 1 5587 return out 5588 5589def displayControl(cmd): 5590 xset, ret = 'timeout 10 xset -d :0.0 {0}', 0 5591 if sysvals.sudouser: 5592 xset = 'sudo -u %s %s' % (sysvals.sudouser, xset) 5593 if cmd == 'init': 5594 ret = call(xset.format('dpms 0 0 0'), shell=True) 5595 if not ret: 5596 ret = call(xset.format('s off'), shell=True) 5597 elif cmd == 'reset': 5598 ret = call(xset.format('s reset'), shell=True) 5599 elif cmd in ['on', 'off', 'standby', 'suspend']: 5600 b4 = displayControl('stat') 5601 ret = call(xset.format('dpms force %s' % cmd), shell=True) 5602 if not ret: 5603 curr = displayControl('stat') 5604 sysvals.vprint('Display Switched: %s -> %s' % (b4, curr)) 5605 if curr != cmd: 5606 sysvals.vprint('WARNING: Display failed to change to %s' % cmd) 5607 if ret: 5608 sysvals.vprint('WARNING: Display failed to change to %s with xset' % cmd) 5609 return ret 5610 elif cmd == 'stat': 5611 fp = Popen(xset.format('q').split(' '), stdout=PIPE).stdout 5612 ret = 'unknown' 5613 for line in fp: 5614 m = re.match('[\s]*Monitor is (?P<m>.*)', ascii(line)) 5615 if(m and len(m.group('m')) >= 2): 5616 out = m.group('m').lower() 5617 ret = out[3:] if out[0:2] == 'in' else out 5618 break 5619 fp.close() 5620 return ret 5621 5622# Function: getFPDT 5623# Description: 5624# Read the acpi bios tables and pull out FPDT, the firmware data 5625# Arguments: 5626# output: True to output the info to stdout, False otherwise 5627def getFPDT(output): 5628 rectype = {} 5629 rectype[0] = 'Firmware Basic Boot Performance Record' 5630 rectype[1] = 'S3 Performance Table Record' 5631 prectype = {} 5632 prectype[0] = 'Basic S3 Resume Performance Record' 5633 prectype[1] = 'Basic S3 Suspend Performance Record' 5634 5635 sysvals.rootCheck(True) 5636 if(not os.path.exists(sysvals.fpdtpath)): 5637 if(output): 5638 doError('file does not exist: %s' % sysvals.fpdtpath) 5639 return False 5640 if(not os.access(sysvals.fpdtpath, os.R_OK)): 5641 if(output): 5642 doError('file is not readable: %s' % sysvals.fpdtpath) 5643 return False 5644 if(not os.path.exists(sysvals.mempath)): 5645 if(output): 5646 doError('file does not exist: %s' % sysvals.mempath) 5647 return False 5648 if(not os.access(sysvals.mempath, os.R_OK)): 5649 if(output): 5650 doError('file is not readable: %s' % sysvals.mempath) 5651 return False 5652 5653 fp = open(sysvals.fpdtpath, 'rb') 5654 buf = fp.read() 5655 fp.close() 5656 5657 if(len(buf) < 36): 5658 if(output): 5659 doError('Invalid FPDT table data, should '+\ 5660 'be at least 36 bytes') 5661 return False 5662 5663 table = struct.unpack('4sIBB6s8sI4sI', buf[0:36]) 5664 if(output): 5665 pprint('\n'\ 5666 'Firmware Performance Data Table (%s)\n'\ 5667 ' Signature : %s\n'\ 5668 ' Table Length : %u\n'\ 5669 ' Revision : %u\n'\ 5670 ' Checksum : 0x%x\n'\ 5671 ' OEM ID : %s\n'\ 5672 ' OEM Table ID : %s\n'\ 5673 ' OEM Revision : %u\n'\ 5674 ' Creator ID : %s\n'\ 5675 ' Creator Revision : 0x%x\n'\ 5676 '' % (ascii(table[0]), ascii(table[0]), table[1], table[2], 5677 table[3], ascii(table[4]), ascii(table[5]), table[6], 5678 ascii(table[7]), table[8])) 5679 5680 if(table[0] != b'FPDT'): 5681 if(output): 5682 doError('Invalid FPDT table') 5683 return False 5684 if(len(buf) <= 36): 5685 return False 5686 i = 0 5687 fwData = [0, 0] 5688 records = buf[36:] 5689 try: 5690 fp = open(sysvals.mempath, 'rb') 5691 except: 5692 pprint('WARNING: /dev/mem is not readable, ignoring the FPDT data') 5693 return False 5694 while(i < len(records)): 5695 header = struct.unpack('HBB', records[i:i+4]) 5696 if(header[0] not in rectype): 5697 i += header[1] 5698 continue 5699 if(header[1] != 16): 5700 i += header[1] 5701 continue 5702 addr = struct.unpack('Q', records[i+8:i+16])[0] 5703 try: 5704 fp.seek(addr) 5705 first = fp.read(8) 5706 except: 5707 if(output): 5708 pprint('Bad address 0x%x in %s' % (addr, sysvals.mempath)) 5709 return [0, 0] 5710 rechead = struct.unpack('4sI', first) 5711 recdata = fp.read(rechead[1]-8) 5712 if(rechead[0] == b'FBPT'): 5713 record = struct.unpack('HBBIQQQQQ', recdata[:48]) 5714 if(output): 5715 pprint('%s (%s)\n'\ 5716 ' Reset END : %u ns\n'\ 5717 ' OS Loader LoadImage Start : %u ns\n'\ 5718 ' OS Loader StartImage Start : %u ns\n'\ 5719 ' ExitBootServices Entry : %u ns\n'\ 5720 ' ExitBootServices Exit : %u ns'\ 5721 '' % (rectype[header[0]], ascii(rechead[0]), record[4], record[5], 5722 record[6], record[7], record[8])) 5723 elif(rechead[0] == b'S3PT'): 5724 if(output): 5725 pprint('%s (%s)' % (rectype[header[0]], ascii(rechead[0]))) 5726 j = 0 5727 while(j < len(recdata)): 5728 prechead = struct.unpack('HBB', recdata[j:j+4]) 5729 if(prechead[0] not in prectype): 5730 continue 5731 if(prechead[0] == 0): 5732 record = struct.unpack('IIQQ', recdata[j:j+prechead[1]]) 5733 fwData[1] = record[2] 5734 if(output): 5735 pprint(' %s\n'\ 5736 ' Resume Count : %u\n'\ 5737 ' FullResume : %u ns\n'\ 5738 ' AverageResume : %u ns'\ 5739 '' % (prectype[prechead[0]], record[1], 5740 record[2], record[3])) 5741 elif(prechead[0] == 1): 5742 record = struct.unpack('QQ', recdata[j+4:j+prechead[1]]) 5743 fwData[0] = record[1] - record[0] 5744 if(output): 5745 pprint(' %s\n'\ 5746 ' SuspendStart : %u ns\n'\ 5747 ' SuspendEnd : %u ns\n'\ 5748 ' SuspendTime : %u ns'\ 5749 '' % (prectype[prechead[0]], record[0], 5750 record[1], fwData[0])) 5751 5752 j += prechead[1] 5753 if(output): 5754 pprint('') 5755 i += header[1] 5756 fp.close() 5757 return fwData 5758 5759# Function: statusCheck 5760# Description: 5761# Verify that the requested command and options will work, and 5762# print the results to the terminal 5763# Output: 5764# True if the test will work, False if not 5765def statusCheck(probecheck=False): 5766 status = '' 5767 5768 pprint('Checking this system (%s)...' % platform.node()) 5769 5770 # check we have root access 5771 res = sysvals.colorText('NO (No features of this tool will work!)') 5772 if(sysvals.rootCheck(False)): 5773 res = 'YES' 5774 pprint(' have root access: %s' % res) 5775 if(res != 'YES'): 5776 pprint(' Try running this script with sudo') 5777 return 'missing root access' 5778 5779 # check sysfs is mounted 5780 res = sysvals.colorText('NO (No features of this tool will work!)') 5781 if(os.path.exists(sysvals.powerfile)): 5782 res = 'YES' 5783 pprint(' is sysfs mounted: %s' % res) 5784 if(res != 'YES'): 5785 return 'sysfs is missing' 5786 5787 # check target mode is a valid mode 5788 if sysvals.suspendmode != 'command': 5789 res = sysvals.colorText('NO') 5790 modes = getModes() 5791 if(sysvals.suspendmode in modes): 5792 res = 'YES' 5793 else: 5794 status = '%s mode is not supported' % sysvals.suspendmode 5795 pprint(' is "%s" a valid power mode: %s' % (sysvals.suspendmode, res)) 5796 if(res == 'NO'): 5797 pprint(' valid power modes are: %s' % modes) 5798 pprint(' please choose one with -m') 5799 5800 # check if ftrace is available 5801 res = sysvals.colorText('NO') 5802 ftgood = sysvals.verifyFtrace() 5803 if(ftgood): 5804 res = 'YES' 5805 elif(sysvals.usecallgraph): 5806 status = 'ftrace is not properly supported' 5807 pprint(' is ftrace supported: %s' % res) 5808 5809 # check if kprobes are available 5810 if sysvals.usekprobes: 5811 res = sysvals.colorText('NO') 5812 sysvals.usekprobes = sysvals.verifyKprobes() 5813 if(sysvals.usekprobes): 5814 res = 'YES' 5815 else: 5816 sysvals.usedevsrc = False 5817 pprint(' are kprobes supported: %s' % res) 5818 5819 # what data source are we using 5820 res = 'DMESG' 5821 if(ftgood): 5822 sysvals.usetraceevents = True 5823 for e in sysvals.traceevents: 5824 if not os.path.exists(sysvals.epath+e): 5825 sysvals.usetraceevents = False 5826 if(sysvals.usetraceevents): 5827 res = 'FTRACE (all trace events found)' 5828 pprint(' timeline data source: %s' % res) 5829 5830 # check if rtcwake 5831 res = sysvals.colorText('NO') 5832 if(sysvals.rtcpath != ''): 5833 res = 'YES' 5834 elif(sysvals.rtcwake): 5835 status = 'rtcwake is not properly supported' 5836 pprint(' is rtcwake supported: %s' % res) 5837 5838 # check info commands 5839 pprint(' optional commands this tool may use for info:') 5840 no = sysvals.colorText('MISSING') 5841 yes = sysvals.colorText('FOUND', 32) 5842 for c in ['turbostat', 'mcelog', 'lspci', 'lsusb']: 5843 if c == 'turbostat': 5844 res = yes if sysvals.haveTurbostat() else no 5845 else: 5846 res = yes if sysvals.getExec(c) else no 5847 pprint(' %s: %s' % (c, res)) 5848 5849 if not probecheck: 5850 return status 5851 5852 # verify kprobes 5853 if sysvals.usekprobes: 5854 for name in sysvals.tracefuncs: 5855 sysvals.defaultKprobe(name, sysvals.tracefuncs[name]) 5856 if sysvals.usedevsrc: 5857 for name in sysvals.dev_tracefuncs: 5858 sysvals.defaultKprobe(name, sysvals.dev_tracefuncs[name]) 5859 sysvals.addKprobes(True) 5860 5861 return status 5862 5863# Function: doError 5864# Description: 5865# generic error function for catastrphic failures 5866# Arguments: 5867# msg: the error message to print 5868# help: True if printHelp should be called after, False otherwise 5869def doError(msg, help=False): 5870 if(help == True): 5871 printHelp() 5872 pprint('ERROR: %s\n' % msg) 5873 sysvals.outputResult({'error':msg}) 5874 sys.exit(1) 5875 5876# Function: getArgInt 5877# Description: 5878# pull out an integer argument from the command line with checks 5879def getArgInt(name, args, min, max, main=True): 5880 if main: 5881 try: 5882 arg = next(args) 5883 except: 5884 doError(name+': no argument supplied', True) 5885 else: 5886 arg = args 5887 try: 5888 val = int(arg) 5889 except: 5890 doError(name+': non-integer value given', True) 5891 if(val < min or val > max): 5892 doError(name+': value should be between %d and %d' % (min, max), True) 5893 return val 5894 5895# Function: getArgFloat 5896# Description: 5897# pull out a float argument from the command line with checks 5898def getArgFloat(name, args, min, max, main=True): 5899 if main: 5900 try: 5901 arg = next(args) 5902 except: 5903 doError(name+': no argument supplied', True) 5904 else: 5905 arg = args 5906 try: 5907 val = float(arg) 5908 except: 5909 doError(name+': non-numerical value given', True) 5910 if(val < min or val > max): 5911 doError(name+': value should be between %f and %f' % (min, max), True) 5912 return val 5913 5914def processData(live=False, quiet=False): 5915 if not quiet: 5916 pprint('PROCESSING: %s' % sysvals.htmlfile) 5917 sysvals.vprint('usetraceevents=%s, usetracemarkers=%s, usekprobes=%s' % \ 5918 (sysvals.usetraceevents, sysvals.usetracemarkers, sysvals.usekprobes)) 5919 error = '' 5920 if(sysvals.usetraceevents): 5921 testruns, error = parseTraceLog(live) 5922 if sysvals.dmesgfile: 5923 for data in testruns: 5924 data.extractErrorInfo() 5925 else: 5926 testruns = loadKernelLog() 5927 for data in testruns: 5928 parseKernelLog(data) 5929 if(sysvals.ftracefile and (sysvals.usecallgraph or sysvals.usetraceevents)): 5930 appendIncompleteTraceLog(testruns) 5931 if not sysvals.stamp: 5932 pprint('ERROR: data does not include the expected stamp') 5933 return (testruns, {'error': 'timeline generation failed'}) 5934 shown = ['bios', 'biosdate', 'cpu', 'host', 'kernel', 'man', 'memfr', 5935 'memsz', 'mode', 'numcpu', 'plat', 'time', 'wifi'] 5936 sysvals.vprint('System Info:') 5937 for key in sorted(sysvals.stamp): 5938 if key in shown: 5939 sysvals.vprint(' %-8s : %s' % (key.upper(), sysvals.stamp[key])) 5940 sysvals.vprint('Command:\n %s' % sysvals.cmdline) 5941 for data in testruns: 5942 if data.turbostat: 5943 idx, s = 0, 'Turbostat:\n ' 5944 for val in data.turbostat.split('|'): 5945 idx += len(val) + 1 5946 if idx >= 80: 5947 idx = 0 5948 s += '\n ' 5949 s += val + ' ' 5950 sysvals.vprint(s) 5951 data.printDetails() 5952 if len(sysvals.platinfo) > 0: 5953 sysvals.vprint('\nPlatform Info:') 5954 for info in sysvals.platinfo: 5955 sysvals.vprint('[%s - %s]' % (info[0], info[1])) 5956 sysvals.vprint(info[2]) 5957 sysvals.vprint('') 5958 if sysvals.cgdump: 5959 for data in testruns: 5960 data.debugPrint() 5961 sys.exit(0) 5962 if len(testruns) < 1: 5963 pprint('ERROR: Not enough test data to build a timeline') 5964 return (testruns, {'error': 'timeline generation failed'}) 5965 sysvals.vprint('Creating the html timeline (%s)...' % sysvals.htmlfile) 5966 createHTML(testruns, error) 5967 if not quiet: 5968 pprint('DONE: %s' % sysvals.htmlfile) 5969 data = testruns[0] 5970 stamp = data.stamp 5971 stamp['suspend'], stamp['resume'] = data.getTimeValues() 5972 if data.fwValid: 5973 stamp['fwsuspend'], stamp['fwresume'] = data.fwSuspend, data.fwResume 5974 if error: 5975 stamp['error'] = error 5976 return (testruns, stamp) 5977 5978# Function: rerunTest 5979# Description: 5980# generate an output from an existing set of ftrace/dmesg logs 5981def rerunTest(htmlfile=''): 5982 if sysvals.ftracefile: 5983 doesTraceLogHaveTraceEvents() 5984 if not sysvals.dmesgfile and not sysvals.usetraceevents: 5985 doError('recreating this html output requires a dmesg file') 5986 if htmlfile: 5987 sysvals.htmlfile = htmlfile 5988 else: 5989 sysvals.setOutputFile() 5990 if os.path.exists(sysvals.htmlfile): 5991 if not os.path.isfile(sysvals.htmlfile): 5992 doError('a directory already exists with this name: %s' % sysvals.htmlfile) 5993 elif not os.access(sysvals.htmlfile, os.W_OK): 5994 doError('missing permission to write to %s' % sysvals.htmlfile) 5995 testruns, stamp = processData() 5996 sysvals.resetlog() 5997 return stamp 5998 5999# Function: runTest 6000# Description: 6001# execute a suspend/resume, gather the logs, and generate the output 6002def runTest(n=0, quiet=False): 6003 # prepare for the test 6004 sysvals.initFtrace(quiet) 6005 sysvals.initTestOutput('suspend') 6006 6007 # execute the test 6008 executeSuspend(quiet) 6009 sysvals.cleanupFtrace() 6010 if sysvals.skiphtml: 6011 sysvals.outputResult({}, n) 6012 sysvals.sudoUserchown(sysvals.testdir) 6013 return 6014 testruns, stamp = processData(True, quiet) 6015 for data in testruns: 6016 del data 6017 sysvals.sudoUserchown(sysvals.testdir) 6018 sysvals.outputResult(stamp, n) 6019 if 'error' in stamp: 6020 return 2 6021 return 0 6022 6023def find_in_html(html, start, end, firstonly=True): 6024 cnt, out, list = len(html), [], [] 6025 if firstonly: 6026 m = re.search(start, html) 6027 if m: 6028 list.append(m) 6029 else: 6030 list = re.finditer(start, html) 6031 for match in list: 6032 s = match.end() 6033 e = cnt if (len(out) < 1 or s + 10000 > cnt) else s + 10000 6034 m = re.search(end, html[s:e]) 6035 if not m: 6036 break 6037 e = s + m.start() 6038 str = html[s:e] 6039 if end == 'ms': 6040 num = re.search(r'[-+]?\d*\.\d+|\d+', str) 6041 str = num.group() if num else 'NaN' 6042 if firstonly: 6043 return str 6044 out.append(str) 6045 if firstonly: 6046 return '' 6047 return out 6048 6049def data_from_html(file, outpath, issues, fulldetail=False): 6050 html = open(file, 'r').read() 6051 sysvals.htmlfile = os.path.relpath(file, outpath) 6052 # extract general info 6053 suspend = find_in_html(html, 'Kernel Suspend', 'ms') 6054 resume = find_in_html(html, 'Kernel Resume', 'ms') 6055 sysinfo = find_in_html(html, '<div class="stamp sysinfo">', '</div>') 6056 line = find_in_html(html, '<div class="stamp">', '</div>') 6057 stmp = line.split() 6058 if not suspend or not resume or len(stmp) != 8: 6059 return False 6060 try: 6061 dt = datetime.strptime(' '.join(stmp[3:]), '%B %d %Y, %I:%M:%S %p') 6062 except: 6063 return False 6064 sysvals.hostname = stmp[0] 6065 tstr = dt.strftime('%Y/%m/%d %H:%M:%S') 6066 error = find_in_html(html, '<table class="testfail"><tr><td>', '</td>') 6067 if error: 6068 m = re.match('[a-z0-9]* failed in (?P<p>\S*).*', error) 6069 if m: 6070 result = 'fail in %s' % m.group('p') 6071 else: 6072 result = 'fail' 6073 else: 6074 result = 'pass' 6075 # extract error info 6076 tp, ilist = False, [] 6077 extra = dict() 6078 log = find_in_html(html, '<div id="dmesglog" style="display:none;">', 6079 '</div>').strip() 6080 if log: 6081 d = Data(0) 6082 d.end = 999999999 6083 d.dmesgtext = log.split('\n') 6084 tp = d.extractErrorInfo() 6085 for msg in tp.msglist: 6086 sysvals.errorSummary(issues, msg) 6087 if stmp[2] == 'freeze': 6088 extra = d.turbostatInfo() 6089 elist = dict() 6090 for dir in d.errorinfo: 6091 for err in d.errorinfo[dir]: 6092 if err[0] not in elist: 6093 elist[err[0]] = 0 6094 elist[err[0]] += 1 6095 for i in elist: 6096 ilist.append('%sx%d' % (i, elist[i]) if elist[i] > 1 else i) 6097 wifi = find_in_html(html, 'Wifi Resume: ', '</td>') 6098 if wifi: 6099 extra['wifi'] = wifi 6100 low = find_in_html(html, 'freeze time: <b>', ' ms</b>') 6101 if low and 'waking' in low: 6102 issue = 'FREEZEWAKE' 6103 match = [i for i in issues if i['match'] == issue] 6104 if len(match) > 0: 6105 match[0]['count'] += 1 6106 if sysvals.hostname not in match[0]['urls']: 6107 match[0]['urls'][sysvals.hostname] = [sysvals.htmlfile] 6108 elif sysvals.htmlfile not in match[0]['urls'][sysvals.hostname]: 6109 match[0]['urls'][sysvals.hostname].append(sysvals.htmlfile) 6110 else: 6111 issues.append({ 6112 'match': issue, 'count': 1, 'line': issue, 6113 'urls': {sysvals.hostname: [sysvals.htmlfile]}, 6114 }) 6115 ilist.append(issue) 6116 # extract device info 6117 devices = dict() 6118 for line in html.split('\n'): 6119 m = re.match(' *<div id=\"[a,0-9]*\" *title=\"(?P<title>.*)\" class=\"thread.*', line) 6120 if not m or 'thread kth' in line or 'thread sec' in line: 6121 continue 6122 m = re.match('(?P<n>.*) \((?P<t>[0-9,\.]*) ms\) (?P<p>.*)', m.group('title')) 6123 if not m: 6124 continue 6125 name, time, phase = m.group('n'), m.group('t'), m.group('p') 6126 if ' async' in name or ' sync' in name: 6127 name = ' '.join(name.split(' ')[:-1]) 6128 if phase.startswith('suspend'): 6129 d = 'suspend' 6130 elif phase.startswith('resume'): 6131 d = 'resume' 6132 else: 6133 continue 6134 if d not in devices: 6135 devices[d] = dict() 6136 if name not in devices[d]: 6137 devices[d][name] = 0.0 6138 devices[d][name] += float(time) 6139 # create worst device info 6140 worst = dict() 6141 for d in ['suspend', 'resume']: 6142 worst[d] = {'name':'', 'time': 0.0} 6143 dev = devices[d] if d in devices else 0 6144 if dev and len(dev.keys()) > 0: 6145 n = sorted(dev, key=lambda k:(dev[k], k), reverse=True)[0] 6146 worst[d]['name'], worst[d]['time'] = n, dev[n] 6147 data = { 6148 'mode': stmp[2], 6149 'host': stmp[0], 6150 'kernel': stmp[1], 6151 'sysinfo': sysinfo, 6152 'time': tstr, 6153 'result': result, 6154 'issues': ' '.join(ilist), 6155 'suspend': suspend, 6156 'resume': resume, 6157 'devlist': devices, 6158 'sus_worst': worst['suspend']['name'], 6159 'sus_worsttime': worst['suspend']['time'], 6160 'res_worst': worst['resume']['name'], 6161 'res_worsttime': worst['resume']['time'], 6162 'url': sysvals.htmlfile, 6163 } 6164 for key in extra: 6165 data[key] = extra[key] 6166 if fulldetail: 6167 data['funclist'] = find_in_html(html, '<div title="', '" class="traceevent"', False) 6168 if tp: 6169 for arg in ['-multi ', '-info ']: 6170 if arg in tp.cmdline: 6171 data['target'] = tp.cmdline[tp.cmdline.find(arg):].split()[1] 6172 break 6173 return data 6174 6175def genHtml(subdir, force=False): 6176 for dirname, dirnames, filenames in os.walk(subdir): 6177 sysvals.dmesgfile = sysvals.ftracefile = sysvals.htmlfile = '' 6178 for filename in filenames: 6179 file = os.path.join(dirname, filename) 6180 if sysvals.usable(file): 6181 if(re.match('.*_dmesg.txt', filename)): 6182 sysvals.dmesgfile = file 6183 elif(re.match('.*_ftrace.txt', filename)): 6184 sysvals.ftracefile = file 6185 sysvals.setOutputFile() 6186 if (sysvals.dmesgfile or sysvals.ftracefile) and sysvals.htmlfile and \ 6187 (force or not sysvals.usable(sysvals.htmlfile)): 6188 pprint('FTRACE: %s' % sysvals.ftracefile) 6189 if sysvals.dmesgfile: 6190 pprint('DMESG : %s' % sysvals.dmesgfile) 6191 rerunTest() 6192 6193# Function: runSummary 6194# Description: 6195# create a summary of tests in a sub-directory 6196def runSummary(subdir, local=True, genhtml=False): 6197 inpath = os.path.abspath(subdir) 6198 outpath = os.path.abspath('.') if local else inpath 6199 pprint('Generating a summary of folder:\n %s' % inpath) 6200 if genhtml: 6201 genHtml(subdir) 6202 target, issues, testruns = '', [], [] 6203 desc = {'host':[],'mode':[],'kernel':[]} 6204 for dirname, dirnames, filenames in os.walk(subdir): 6205 for filename in filenames: 6206 if(not re.match('.*.html', filename)): 6207 continue 6208 data = data_from_html(os.path.join(dirname, filename), outpath, issues) 6209 if(not data): 6210 continue 6211 if 'target' in data: 6212 target = data['target'] 6213 testruns.append(data) 6214 for key in desc: 6215 if data[key] not in desc[key]: 6216 desc[key].append(data[key]) 6217 pprint('Summary files:') 6218 if len(desc['host']) == len(desc['mode']) == len(desc['kernel']) == 1: 6219 title = '%s %s %s' % (desc['host'][0], desc['kernel'][0], desc['mode'][0]) 6220 if target: 6221 title += ' %s' % target 6222 else: 6223 title = inpath 6224 createHTMLSummarySimple(testruns, os.path.join(outpath, 'summary.html'), title) 6225 pprint(' summary.html - tabular list of test data found') 6226 createHTMLDeviceSummary(testruns, os.path.join(outpath, 'summary-devices.html'), title) 6227 pprint(' summary-devices.html - kernel device list sorted by total execution time') 6228 createHTMLIssuesSummary(testruns, issues, os.path.join(outpath, 'summary-issues.html'), title) 6229 pprint(' summary-issues.html - kernel issues found sorted by frequency') 6230 6231# Function: checkArgBool 6232# Description: 6233# check if a boolean string value is true or false 6234def checkArgBool(name, value): 6235 if value in switchvalues: 6236 if value in switchoff: 6237 return False 6238 return True 6239 doError('invalid boolean --> (%s: %s), use "true/false" or "1/0"' % (name, value), True) 6240 return False 6241 6242# Function: configFromFile 6243# Description: 6244# Configure the script via the info in a config file 6245def configFromFile(file): 6246 Config = configparser.ConfigParser() 6247 6248 Config.read(file) 6249 sections = Config.sections() 6250 overridekprobes = False 6251 overridedevkprobes = False 6252 if 'Settings' in sections: 6253 for opt in Config.options('Settings'): 6254 value = Config.get('Settings', opt).lower() 6255 option = opt.lower() 6256 if(option == 'verbose'): 6257 sysvals.verbose = checkArgBool(option, value) 6258 elif(option == 'addlogs'): 6259 sysvals.dmesglog = sysvals.ftracelog = checkArgBool(option, value) 6260 elif(option == 'dev'): 6261 sysvals.usedevsrc = checkArgBool(option, value) 6262 elif(option == 'proc'): 6263 sysvals.useprocmon = checkArgBool(option, value) 6264 elif(option == 'x2'): 6265 if checkArgBool(option, value): 6266 sysvals.execcount = 2 6267 elif(option == 'callgraph'): 6268 sysvals.usecallgraph = checkArgBool(option, value) 6269 elif(option == 'override-timeline-functions'): 6270 overridekprobes = checkArgBool(option, value) 6271 elif(option == 'override-dev-timeline-functions'): 6272 overridedevkprobes = checkArgBool(option, value) 6273 elif(option == 'skiphtml'): 6274 sysvals.skiphtml = checkArgBool(option, value) 6275 elif(option == 'sync'): 6276 sysvals.sync = checkArgBool(option, value) 6277 elif(option == 'rs' or option == 'runtimesuspend'): 6278 if value in switchvalues: 6279 if value in switchoff: 6280 sysvals.rs = -1 6281 else: 6282 sysvals.rs = 1 6283 else: 6284 doError('invalid value --> (%s: %s), use "enable/disable"' % (option, value), True) 6285 elif(option == 'display'): 6286 disopt = ['on', 'off', 'standby', 'suspend'] 6287 if value not in disopt: 6288 doError('invalid value --> (%s: %s), use %s' % (option, value, disopt), True) 6289 sysvals.display = value 6290 elif(option == 'gzip'): 6291 sysvals.gzip = checkArgBool(option, value) 6292 elif(option == 'cgfilter'): 6293 sysvals.setCallgraphFilter(value) 6294 elif(option == 'cgskip'): 6295 if value in switchoff: 6296 sysvals.cgskip = '' 6297 else: 6298 sysvals.cgskip = sysvals.configFile(val) 6299 if(not sysvals.cgskip): 6300 doError('%s does not exist' % sysvals.cgskip) 6301 elif(option == 'cgtest'): 6302 sysvals.cgtest = getArgInt('cgtest', value, 0, 1, False) 6303 elif(option == 'cgphase'): 6304 d = Data(0) 6305 if value not in d.phasedef: 6306 doError('invalid phase --> (%s: %s), valid phases are %s'\ 6307 % (option, value, d.phasedef.keys()), True) 6308 sysvals.cgphase = value 6309 elif(option == 'fadd'): 6310 file = sysvals.configFile(value) 6311 if(not file): 6312 doError('%s does not exist' % value) 6313 sysvals.addFtraceFilterFunctions(file) 6314 elif(option == 'result'): 6315 sysvals.result = value 6316 elif(option == 'multi'): 6317 nums = value.split() 6318 if len(nums) != 2: 6319 doError('multi requires 2 integers (exec_count and delay)', True) 6320 sysvals.multiinit(nums[0], nums[1]) 6321 elif(option == 'devicefilter'): 6322 sysvals.setDeviceFilter(value) 6323 elif(option == 'expandcg'): 6324 sysvals.cgexp = checkArgBool(option, value) 6325 elif(option == 'srgap'): 6326 if checkArgBool(option, value): 6327 sysvals.srgap = 5 6328 elif(option == 'mode'): 6329 sysvals.suspendmode = value 6330 elif(option == 'command' or option == 'cmd'): 6331 sysvals.testcommand = value 6332 elif(option == 'x2delay'): 6333 sysvals.x2delay = getArgInt('x2delay', value, 0, 60000, False) 6334 elif(option == 'predelay'): 6335 sysvals.predelay = getArgInt('predelay', value, 0, 60000, False) 6336 elif(option == 'postdelay'): 6337 sysvals.postdelay = getArgInt('postdelay', value, 0, 60000, False) 6338 elif(option == 'maxdepth'): 6339 sysvals.max_graph_depth = getArgInt('maxdepth', value, 0, 1000, False) 6340 elif(option == 'rtcwake'): 6341 if value in switchoff: 6342 sysvals.rtcwake = False 6343 else: 6344 sysvals.rtcwake = True 6345 sysvals.rtcwaketime = getArgInt('rtcwake', value, 0, 3600, False) 6346 elif(option == 'timeprec'): 6347 sysvals.setPrecision(getArgInt('timeprec', value, 0, 6, False)) 6348 elif(option == 'mindev'): 6349 sysvals.mindevlen = getArgFloat('mindev', value, 0.0, 10000.0, False) 6350 elif(option == 'callloop-maxgap'): 6351 sysvals.callloopmaxgap = getArgFloat('callloop-maxgap', value, 0.0, 1.0, False) 6352 elif(option == 'callloop-maxlen'): 6353 sysvals.callloopmaxgap = getArgFloat('callloop-maxlen', value, 0.0, 1.0, False) 6354 elif(option == 'mincg'): 6355 sysvals.mincglen = getArgFloat('mincg', value, 0.0, 10000.0, False) 6356 elif(option == 'bufsize'): 6357 sysvals.bufsize = getArgInt('bufsize', value, 1, 1024*1024*8, False) 6358 elif(option == 'output-dir'): 6359 sysvals.outdir = sysvals.setOutputFolder(value) 6360 6361 if sysvals.suspendmode == 'command' and not sysvals.testcommand: 6362 doError('No command supplied for mode "command"') 6363 6364 # compatibility errors 6365 if sysvals.usedevsrc and sysvals.usecallgraph: 6366 doError('-dev is not compatible with -f') 6367 if sysvals.usecallgraph and sysvals.useprocmon: 6368 doError('-proc is not compatible with -f') 6369 6370 if overridekprobes: 6371 sysvals.tracefuncs = dict() 6372 if overridedevkprobes: 6373 sysvals.dev_tracefuncs = dict() 6374 6375 kprobes = dict() 6376 kprobesec = 'dev_timeline_functions_'+platform.machine() 6377 if kprobesec in sections: 6378 for name in Config.options(kprobesec): 6379 text = Config.get(kprobesec, name) 6380 kprobes[name] = (text, True) 6381 kprobesec = 'timeline_functions_'+platform.machine() 6382 if kprobesec in sections: 6383 for name in Config.options(kprobesec): 6384 if name in kprobes: 6385 doError('Duplicate timeline function found "%s"' % (name)) 6386 text = Config.get(kprobesec, name) 6387 kprobes[name] = (text, False) 6388 6389 for name in kprobes: 6390 function = name 6391 format = name 6392 color = '' 6393 args = dict() 6394 text, dev = kprobes[name] 6395 data = text.split() 6396 i = 0 6397 for val in data: 6398 # bracketted strings are special formatting, read them separately 6399 if val[0] == '[' and val[-1] == ']': 6400 for prop in val[1:-1].split(','): 6401 p = prop.split('=') 6402 if p[0] == 'color': 6403 try: 6404 color = int(p[1], 16) 6405 color = '#'+p[1] 6406 except: 6407 color = p[1] 6408 continue 6409 # first real arg should be the format string 6410 if i == 0: 6411 format = val 6412 # all other args are actual function args 6413 else: 6414 d = val.split('=') 6415 args[d[0]] = d[1] 6416 i += 1 6417 if not function or not format: 6418 doError('Invalid kprobe: %s' % name) 6419 for arg in re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', format): 6420 if arg not in args: 6421 doError('Kprobe "%s" is missing argument "%s"' % (name, arg)) 6422 if (dev and name in sysvals.dev_tracefuncs) or (not dev and name in sysvals.tracefuncs): 6423 doError('Duplicate timeline function found "%s"' % (name)) 6424 6425 kp = { 6426 'name': name, 6427 'func': function, 6428 'format': format, 6429 sysvals.archargs: args 6430 } 6431 if color: 6432 kp['color'] = color 6433 if dev: 6434 sysvals.dev_tracefuncs[name] = kp 6435 else: 6436 sysvals.tracefuncs[name] = kp 6437 6438# Function: printHelp 6439# Description: 6440# print out the help text 6441def printHelp(): 6442 pprint('\n%s v%s\n'\ 6443 'Usage: sudo sleepgraph <options> <commands>\n'\ 6444 '\n'\ 6445 'Description:\n'\ 6446 ' This tool is designed to assist kernel and OS developers in optimizing\n'\ 6447 ' their linux stack\'s suspend/resume time. Using a kernel image built\n'\ 6448 ' with a few extra options enabled, the tool will execute a suspend and\n'\ 6449 ' capture dmesg and ftrace data until resume is complete. This data is\n'\ 6450 ' transformed into a device timeline and an optional callgraph to give\n'\ 6451 ' a detailed view of which devices/subsystems are taking the most\n'\ 6452 ' time in suspend/resume.\n'\ 6453 '\n'\ 6454 ' If no specific command is given, the default behavior is to initiate\n'\ 6455 ' a suspend/resume and capture the dmesg/ftrace output as an html timeline.\n'\ 6456 '\n'\ 6457 ' Generates output files in subdirectory: suspend-yymmdd-HHMMSS\n'\ 6458 ' HTML output: <hostname>_<mode>.html\n'\ 6459 ' raw dmesg output: <hostname>_<mode>_dmesg.txt\n'\ 6460 ' raw ftrace output: <hostname>_<mode>_ftrace.txt\n'\ 6461 '\n'\ 6462 'Options:\n'\ 6463 ' -h Print this help text\n'\ 6464 ' -v Print the current tool version\n'\ 6465 ' -config fn Pull arguments and config options from file fn\n'\ 6466 ' -verbose Print extra information during execution and analysis\n'\ 6467 ' -m mode Mode to initiate for suspend (default: %s)\n'\ 6468 ' -o name Overrides the output subdirectory name when running a new test\n'\ 6469 ' default: suspend-{date}-{time}\n'\ 6470 ' -rtcwake t Wakeup t seconds after suspend, set t to "off" to disable (default: 15)\n'\ 6471 ' -addlogs Add the dmesg and ftrace logs to the html output\n'\ 6472 ' -noturbostat Dont use turbostat in freeze mode (default: disabled)\n'\ 6473 ' -srgap Add a visible gap in the timeline between sus/res (default: disabled)\n'\ 6474 ' -skiphtml Run the test and capture the trace logs, but skip the timeline (default: disabled)\n'\ 6475 ' -result fn Export a results table to a text file for parsing.\n'\ 6476 ' -wifi If a wifi connection is available, check that it reconnects after resume.\n'\ 6477 ' [testprep]\n'\ 6478 ' -sync Sync the filesystems before starting the test\n'\ 6479 ' -rs on/off Enable/disable runtime suspend for all devices, restore all after test\n'\ 6480 ' -display m Change the display mode to m for the test (on/off/standby/suspend)\n'\ 6481 ' [advanced]\n'\ 6482 ' -gzip Gzip the trace and dmesg logs to save space\n'\ 6483 ' -cmd {s} Run the timeline over a custom command, e.g. "sync -d"\n'\ 6484 ' -proc Add usermode process info into the timeline (default: disabled)\n'\ 6485 ' -dev Add kernel function calls and threads to the timeline (default: disabled)\n'\ 6486 ' -x2 Run two suspend/resumes back to back (default: disabled)\n'\ 6487 ' -x2delay t Include t ms delay between multiple test runs (default: 0 ms)\n'\ 6488 ' -predelay t Include t ms delay before 1st suspend (default: 0 ms)\n'\ 6489 ' -postdelay t Include t ms delay after last resume (default: 0 ms)\n'\ 6490 ' -mindev ms Discard all device blocks shorter than ms milliseconds (e.g. 0.001 for us)\n'\ 6491 ' -multi n d Execute <n> consecutive tests at <d> seconds intervals. If <n> is followed\n'\ 6492 ' by a "d", "h", or "m" execute for <n> days, hours, or mins instead.\n'\ 6493 ' The outputs will be created in a new subdirectory with a summary page.\n'\ 6494 ' -maxfail n Abort a -multi run after n consecutive fails (default is 0 = never abort)\n'\ 6495 ' [debug]\n'\ 6496 ' -f Use ftrace to create device callgraphs (default: disabled)\n'\ 6497 ' -ftop Use ftrace on the top level call: "%s" (default: disabled)\n'\ 6498 ' -maxdepth N limit the callgraph data to N call levels (default: 0=all)\n'\ 6499 ' -expandcg pre-expand the callgraph data in the html output (default: disabled)\n'\ 6500 ' -fadd file Add functions to be graphed in the timeline from a list in a text file\n'\ 6501 ' -filter "d1,d2,..." Filter out all but this comma-delimited list of device names\n'\ 6502 ' -mincg ms Discard all callgraphs shorter than ms milliseconds (e.g. 0.001 for us)\n'\ 6503 ' -cgphase P Only show callgraph data for phase P (e.g. suspend_late)\n'\ 6504 ' -cgtest N Only show callgraph data for test N (e.g. 0 or 1 in an x2 run)\n'\ 6505 ' -timeprec N Number of significant digits in timestamps (0:S, [3:ms], 6:us)\n'\ 6506 ' -cgfilter S Filter the callgraph output in the timeline\n'\ 6507 ' -cgskip file Callgraph functions to skip, off to disable (default: cgskip.txt)\n'\ 6508 ' -bufsize N Set trace buffer size to N kilo-bytes (default: all of free memory)\n'\ 6509 ' -devdump Print out all the raw device data for each phase\n'\ 6510 ' -cgdump Print out all the raw callgraph data\n'\ 6511 '\n'\ 6512 'Other commands:\n'\ 6513 ' -modes List available suspend modes\n'\ 6514 ' -status Test to see if the system is enabled to run this tool\n'\ 6515 ' -fpdt Print out the contents of the ACPI Firmware Performance Data Table\n'\ 6516 ' -wificheck Print out wifi connection info\n'\ 6517 ' -x<mode> Test xset by toggling the given mode (on/off/standby/suspend)\n'\ 6518 ' -sysinfo Print out system info extracted from BIOS\n'\ 6519 ' -devinfo Print out the pm settings of all devices which support runtime suspend\n'\ 6520 ' -cmdinfo Print out all the platform info collected before and after suspend/resume\n'\ 6521 ' -flist Print the list of functions currently being captured in ftrace\n'\ 6522 ' -flistall Print all functions capable of being captured in ftrace\n'\ 6523 ' -summary dir Create a summary of tests in this dir [-genhtml builds missing html]\n'\ 6524 ' [redo]\n'\ 6525 ' -ftrace ftracefile Create HTML output using ftrace input (used with -dmesg)\n'\ 6526 ' -dmesg dmesgfile Create HTML output using dmesg (used with -ftrace)\n'\ 6527 '' % (sysvals.title, sysvals.version, sysvals.suspendmode, sysvals.ftopfunc)) 6528 return True 6529 6530# ----------------- MAIN -------------------- 6531# exec start (skipped if script is loaded as library) 6532if __name__ == '__main__': 6533 genhtml = False 6534 cmd = '' 6535 simplecmds = ['-sysinfo', '-modes', '-fpdt', '-flist', '-flistall', 6536 '-devinfo', '-status', '-xon', '-xoff', '-xstandby', '-xsuspend', 6537 '-xinit', '-xreset', '-xstat', '-wificheck', '-cmdinfo'] 6538 if '-f' in sys.argv: 6539 sysvals.cgskip = sysvals.configFile('cgskip.txt') 6540 # loop through the command line arguments 6541 args = iter(sys.argv[1:]) 6542 for arg in args: 6543 if(arg == '-m'): 6544 try: 6545 val = next(args) 6546 except: 6547 doError('No mode supplied', True) 6548 if val == 'command' and not sysvals.testcommand: 6549 doError('No command supplied for mode "command"', True) 6550 sysvals.suspendmode = val 6551 elif(arg in simplecmds): 6552 cmd = arg[1:] 6553 elif(arg == '-h'): 6554 printHelp() 6555 sys.exit(0) 6556 elif(arg == '-v'): 6557 pprint("Version %s" % sysvals.version) 6558 sys.exit(0) 6559 elif(arg == '-x2'): 6560 sysvals.execcount = 2 6561 elif(arg == '-x2delay'): 6562 sysvals.x2delay = getArgInt('-x2delay', args, 0, 60000) 6563 elif(arg == '-predelay'): 6564 sysvals.predelay = getArgInt('-predelay', args, 0, 60000) 6565 elif(arg == '-postdelay'): 6566 sysvals.postdelay = getArgInt('-postdelay', args, 0, 60000) 6567 elif(arg == '-f'): 6568 sysvals.usecallgraph = True 6569 elif(arg == '-ftop'): 6570 sysvals.usecallgraph = True 6571 sysvals.ftop = True 6572 sysvals.usekprobes = False 6573 elif(arg == '-skiphtml'): 6574 sysvals.skiphtml = True 6575 elif(arg == '-cgdump'): 6576 sysvals.cgdump = True 6577 elif(arg == '-devdump'): 6578 sysvals.devdump = True 6579 elif(arg == '-genhtml'): 6580 genhtml = True 6581 elif(arg == '-addlogs'): 6582 sysvals.dmesglog = sysvals.ftracelog = True 6583 elif(arg == '-nologs'): 6584 sysvals.dmesglog = sysvals.ftracelog = False 6585 elif(arg == '-addlogdmesg'): 6586 sysvals.dmesglog = True 6587 elif(arg == '-addlogftrace'): 6588 sysvals.ftracelog = True 6589 elif(arg == '-noturbostat'): 6590 sysvals.tstat = False 6591 elif(arg == '-verbose'): 6592 sysvals.verbose = True 6593 elif(arg == '-proc'): 6594 sysvals.useprocmon = True 6595 elif(arg == '-dev'): 6596 sysvals.usedevsrc = True 6597 elif(arg == '-sync'): 6598 sysvals.sync = True 6599 elif(arg == '-wifi'): 6600 sysvals.wifi = True 6601 elif(arg == '-gzip'): 6602 sysvals.gzip = True 6603 elif(arg == '-info'): 6604 try: 6605 val = next(args) 6606 except: 6607 doError('-info requires one string argument', True) 6608 elif(arg == '-rs'): 6609 try: 6610 val = next(args) 6611 except: 6612 doError('-rs requires "enable" or "disable"', True) 6613 if val.lower() in switchvalues: 6614 if val.lower() in switchoff: 6615 sysvals.rs = -1 6616 else: 6617 sysvals.rs = 1 6618 else: 6619 doError('invalid option: %s, use "enable/disable" or "on/off"' % val, True) 6620 elif(arg == '-display'): 6621 try: 6622 val = next(args) 6623 except: 6624 doError('-display requires an mode value', True) 6625 disopt = ['on', 'off', 'standby', 'suspend'] 6626 if val.lower() not in disopt: 6627 doError('valid display mode values are %s' % disopt, True) 6628 sysvals.display = val.lower() 6629 elif(arg == '-maxdepth'): 6630 sysvals.max_graph_depth = getArgInt('-maxdepth', args, 0, 1000) 6631 elif(arg == '-rtcwake'): 6632 try: 6633 val = next(args) 6634 except: 6635 doError('No rtcwake time supplied', True) 6636 if val.lower() in switchoff: 6637 sysvals.rtcwake = False 6638 else: 6639 sysvals.rtcwake = True 6640 sysvals.rtcwaketime = getArgInt('-rtcwake', val, 0, 3600, False) 6641 elif(arg == '-timeprec'): 6642 sysvals.setPrecision(getArgInt('-timeprec', args, 0, 6)) 6643 elif(arg == '-mindev'): 6644 sysvals.mindevlen = getArgFloat('-mindev', args, 0.0, 10000.0) 6645 elif(arg == '-mincg'): 6646 sysvals.mincglen = getArgFloat('-mincg', args, 0.0, 10000.0) 6647 elif(arg == '-bufsize'): 6648 sysvals.bufsize = getArgInt('-bufsize', args, 1, 1024*1024*8) 6649 elif(arg == '-cgtest'): 6650 sysvals.cgtest = getArgInt('-cgtest', args, 0, 1) 6651 elif(arg == '-cgphase'): 6652 try: 6653 val = next(args) 6654 except: 6655 doError('No phase name supplied', True) 6656 d = Data(0) 6657 if val not in d.phasedef: 6658 doError('invalid phase --> (%s: %s), valid phases are %s'\ 6659 % (arg, val, d.phasedef.keys()), True) 6660 sysvals.cgphase = val 6661 elif(arg == '-cgfilter'): 6662 try: 6663 val = next(args) 6664 except: 6665 doError('No callgraph functions supplied', True) 6666 sysvals.setCallgraphFilter(val) 6667 elif(arg == '-skipkprobe'): 6668 try: 6669 val = next(args) 6670 except: 6671 doError('No kprobe functions supplied', True) 6672 sysvals.skipKprobes(val) 6673 elif(arg == '-cgskip'): 6674 try: 6675 val = next(args) 6676 except: 6677 doError('No file supplied', True) 6678 if val.lower() in switchoff: 6679 sysvals.cgskip = '' 6680 else: 6681 sysvals.cgskip = sysvals.configFile(val) 6682 if(not sysvals.cgskip): 6683 doError('%s does not exist' % sysvals.cgskip) 6684 elif(arg == '-callloop-maxgap'): 6685 sysvals.callloopmaxgap = getArgFloat('-callloop-maxgap', args, 0.0, 1.0) 6686 elif(arg == '-callloop-maxlen'): 6687 sysvals.callloopmaxlen = getArgFloat('-callloop-maxlen', args, 0.0, 1.0) 6688 elif(arg == '-cmd'): 6689 try: 6690 val = next(args) 6691 except: 6692 doError('No command string supplied', True) 6693 sysvals.testcommand = val 6694 sysvals.suspendmode = 'command' 6695 elif(arg == '-expandcg'): 6696 sysvals.cgexp = True 6697 elif(arg == '-srgap'): 6698 sysvals.srgap = 5 6699 elif(arg == '-maxfail'): 6700 sysvals.maxfail = getArgInt('-maxfail', args, 0, 1000000) 6701 elif(arg == '-multi'): 6702 try: 6703 c, d = next(args), next(args) 6704 except: 6705 doError('-multi requires two values', True) 6706 sysvals.multiinit(c, d) 6707 elif(arg == '-o'): 6708 try: 6709 val = next(args) 6710 except: 6711 doError('No subdirectory name supplied', True) 6712 sysvals.outdir = sysvals.setOutputFolder(val) 6713 elif(arg == '-config'): 6714 try: 6715 val = next(args) 6716 except: 6717 doError('No text file supplied', True) 6718 file = sysvals.configFile(val) 6719 if(not file): 6720 doError('%s does not exist' % val) 6721 configFromFile(file) 6722 elif(arg == '-fadd'): 6723 try: 6724 val = next(args) 6725 except: 6726 doError('No text file supplied', True) 6727 file = sysvals.configFile(val) 6728 if(not file): 6729 doError('%s does not exist' % val) 6730 sysvals.addFtraceFilterFunctions(file) 6731 elif(arg == '-dmesg'): 6732 try: 6733 val = next(args) 6734 except: 6735 doError('No dmesg file supplied', True) 6736 sysvals.notestrun = True 6737 sysvals.dmesgfile = val 6738 if(os.path.exists(sysvals.dmesgfile) == False): 6739 doError('%s does not exist' % sysvals.dmesgfile) 6740 elif(arg == '-ftrace'): 6741 try: 6742 val = next(args) 6743 except: 6744 doError('No ftrace file supplied', True) 6745 sysvals.notestrun = True 6746 sysvals.ftracefile = val 6747 if(os.path.exists(sysvals.ftracefile) == False): 6748 doError('%s does not exist' % sysvals.ftracefile) 6749 elif(arg == '-summary'): 6750 try: 6751 val = next(args) 6752 except: 6753 doError('No directory supplied', True) 6754 cmd = 'summary' 6755 sysvals.outdir = val 6756 sysvals.notestrun = True 6757 if(os.path.isdir(val) == False): 6758 doError('%s is not accesible' % val) 6759 elif(arg == '-filter'): 6760 try: 6761 val = next(args) 6762 except: 6763 doError('No devnames supplied', True) 6764 sysvals.setDeviceFilter(val) 6765 elif(arg == '-result'): 6766 try: 6767 val = next(args) 6768 except: 6769 doError('No result file supplied', True) 6770 sysvals.result = val 6771 sysvals.signalHandlerInit() 6772 else: 6773 doError('Invalid argument: '+arg, True) 6774 6775 # compatibility errors 6776 if(sysvals.usecallgraph and sysvals.usedevsrc): 6777 doError('-dev is not compatible with -f') 6778 if(sysvals.usecallgraph and sysvals.useprocmon): 6779 doError('-proc is not compatible with -f') 6780 6781 if sysvals.usecallgraph and sysvals.cgskip: 6782 sysvals.vprint('Using cgskip file: %s' % sysvals.cgskip) 6783 sysvals.setCallgraphBlacklist(sysvals.cgskip) 6784 6785 # callgraph size cannot exceed device size 6786 if sysvals.mincglen < sysvals.mindevlen: 6787 sysvals.mincglen = sysvals.mindevlen 6788 6789 # remove existing buffers before calculating memory 6790 if(sysvals.usecallgraph or sysvals.usedevsrc): 6791 sysvals.fsetVal('16', 'buffer_size_kb') 6792 sysvals.cpuInfo() 6793 6794 # just run a utility command and exit 6795 if(cmd != ''): 6796 ret = 0 6797 if(cmd == 'status'): 6798 if not statusCheck(True): 6799 ret = 1 6800 elif(cmd == 'fpdt'): 6801 if not getFPDT(True): 6802 ret = 1 6803 elif(cmd == 'sysinfo'): 6804 sysvals.printSystemInfo(True) 6805 elif(cmd == 'devinfo'): 6806 deviceInfo() 6807 elif(cmd == 'modes'): 6808 pprint(getModes()) 6809 elif(cmd == 'flist'): 6810 sysvals.getFtraceFilterFunctions(True) 6811 elif(cmd == 'flistall'): 6812 sysvals.getFtraceFilterFunctions(False) 6813 elif(cmd == 'summary'): 6814 runSummary(sysvals.outdir, True, genhtml) 6815 elif(cmd in ['xon', 'xoff', 'xstandby', 'xsuspend', 'xinit', 'xreset']): 6816 sysvals.verbose = True 6817 ret = displayControl(cmd[1:]) 6818 elif(cmd == 'xstat'): 6819 pprint('Display Status: %s' % displayControl('stat').upper()) 6820 elif(cmd == 'wificheck'): 6821 dev = sysvals.checkWifi() 6822 if dev: 6823 print('%s is connected' % sysvals.wifiDetails(dev)) 6824 else: 6825 print('No wifi connection found') 6826 elif(cmd == 'cmdinfo'): 6827 for out in sysvals.cmdinfo(False, True): 6828 print('[%s - %s]\n%s\n' % out) 6829 sys.exit(ret) 6830 6831 # if instructed, re-analyze existing data files 6832 if(sysvals.notestrun): 6833 stamp = rerunTest(sysvals.outdir) 6834 sysvals.outputResult(stamp) 6835 sys.exit(0) 6836 6837 # verify that we can run a test 6838 error = statusCheck() 6839 if(error): 6840 doError(error) 6841 6842 # extract mem/disk extra modes and convert 6843 mode = sysvals.suspendmode 6844 if mode.startswith('mem'): 6845 memmode = mode.split('-', 1)[-1] if '-' in mode else 'deep' 6846 if memmode == 'shallow': 6847 mode = 'standby' 6848 elif memmode == 's2idle': 6849 mode = 'freeze' 6850 else: 6851 mode = 'mem' 6852 sysvals.memmode = memmode 6853 sysvals.suspendmode = mode 6854 if mode.startswith('disk-'): 6855 sysvals.diskmode = mode.split('-', 1)[-1] 6856 sysvals.suspendmode = 'disk' 6857 6858 sysvals.systemInfo(dmidecode(sysvals.mempath)) 6859 6860 setRuntimeSuspend(True) 6861 if sysvals.display: 6862 displayControl('init') 6863 failcnt, ret = 0, 0 6864 if sysvals.multitest['run']: 6865 # run multiple tests in a separate subdirectory 6866 if not sysvals.outdir: 6867 if 'time' in sysvals.multitest: 6868 s = '-%dm' % sysvals.multitest['time'] 6869 else: 6870 s = '-x%d' % sysvals.multitest['count'] 6871 sysvals.outdir = datetime.now().strftime('suspend-%y%m%d-%H%M%S'+s) 6872 if not os.path.isdir(sysvals.outdir): 6873 os.makedirs(sysvals.outdir) 6874 sysvals.sudoUserchown(sysvals.outdir) 6875 finish = datetime.now() 6876 if 'time' in sysvals.multitest: 6877 finish += timedelta(minutes=sysvals.multitest['time']) 6878 for i in range(sysvals.multitest['count']): 6879 sysvals.multistat(True, i, finish) 6880 if i != 0 and sysvals.multitest['delay'] > 0: 6881 pprint('Waiting %d seconds...' % (sysvals.multitest['delay'])) 6882 time.sleep(sysvals.multitest['delay']) 6883 fmt = 'suspend-%y%m%d-%H%M%S' 6884 sysvals.testdir = os.path.join(sysvals.outdir, datetime.now().strftime(fmt)) 6885 ret = runTest(i+1, True) 6886 failcnt = 0 if not ret else failcnt + 1 6887 if sysvals.maxfail > 0 and failcnt >= sysvals.maxfail: 6888 pprint('Maximum fail count of %d reached, aborting multitest' % (sysvals.maxfail)) 6889 break 6890 time.sleep(5) 6891 sysvals.resetlog() 6892 sysvals.multistat(False, i, finish) 6893 if 'time' in sysvals.multitest and datetime.now() >= finish: 6894 break 6895 if not sysvals.skiphtml: 6896 runSummary(sysvals.outdir, False, False) 6897 sysvals.sudoUserchown(sysvals.outdir) 6898 else: 6899 if sysvals.outdir: 6900 sysvals.testdir = sysvals.outdir 6901 # run the test in the current directory 6902 ret = runTest() 6903 if sysvals.display: 6904 displayControl('reset') 6905 setRuntimeSuspend(False) 6906 sys.exit(ret) 6907