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