tools/power/pm-graph/sleepgraph.py

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