tools/power/pm-graph/sleepgraph.py

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