#!/usr/bin/python # SPDX-License-Identifier: GPL-2.0-only # # Tool for analyzing suspend/resume timing # Copyright (c) 2013, Intel Corporation. # # This program is free software; you can redistribute it and/or modify it # under the terms and conditions of the GNU General Public License, # version 2, as published by the Free Software Foundation. # # This program is distributed in the hope it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for # more details. # # Authors: # Todd Brandt # # Links: # Home Page # https://01.org/pm-graph # Source repo # git@github.com:intel/pm-graph # # Description: # This tool is designed to assist kernel and OS developers in optimizing # their linux stack's suspend/resume time. Using a kernel image built # with a few extra options enabled, the tool will execute a suspend and # will capture dmesg and ftrace data until resume is complete. This data # is transformed into a device timeline and a callgraph to give a quick # and detailed view of which devices and callbacks are taking the most # time in suspend/resume. The output is a single html file which can be # viewed in firefox or chrome. # # The following kernel build options are required: # CONFIG_DEVMEM=y # CONFIG_PM_DEBUG=y # CONFIG_PM_SLEEP_DEBUG=y # CONFIG_FTRACE=y # CONFIG_FUNCTION_TRACER=y # CONFIG_FUNCTION_GRAPH_TRACER=y # CONFIG_KPROBES=y # CONFIG_KPROBES_ON_FTRACE=y # # For kernel versions older than 3.15: # The following additional kernel parameters are required: # (e.g. in file /etc/default/grub) # GRUB_CMDLINE_LINUX_DEFAULT="... initcall_debug log_buf_len=16M ..." # # ----------------- LIBRARIES -------------------- import sys import time import os import string import re import platform import signal import codecs from datetime import datetime import struct import configparser import gzip from threading import Thread from subprocess import call, Popen, PIPE import base64 def pprint(msg): print(msg) sys.stdout.flush() def ascii(text): return text.decode('ascii', 'ignore') # ----------------- CLASSES -------------------- # Class: SystemValues # Description: # A global, single-instance container used to # store system values and test parameters class SystemValues: title = 'SleepGraph' version = '5.5' ansi = False rs = 0 display = '' gzip = False sync = False verbose = False testlog = True dmesglog = True ftracelog = False tstat = True mindevlen = 0.0 mincglen = 0.0 cgphase = '' cgtest = -1 cgskip = '' multitest = {'run': False, 'count': 0, 'delay': 0} max_graph_depth = 0 callloopmaxgap = 0.0001 callloopmaxlen = 0.005 bufsize = 0 cpucount = 0 memtotal = 204800 memfree = 204800 srgap = 0 cgexp = False testdir = '' outdir = '' tpath = '/sys/kernel/debug/tracing/' fpdtpath = '/sys/firmware/acpi/tables/FPDT' epath = '/sys/kernel/debug/tracing/events/power/' pmdpath = '/sys/power/pm_debug_messages' traceevents = [ 'suspend_resume', 'wakeup_source_activate', 'wakeup_source_deactivate', 'device_pm_callback_end', 'device_pm_callback_start' ] logmsg = '' testcommand = '' mempath = '/dev/mem' powerfile = '/sys/power/state' mempowerfile = '/sys/power/mem_sleep' diskpowerfile = '/sys/power/disk' suspendmode = 'mem' memmode = '' diskmode = '' hostname = 'localhost' prefix = 'test' teststamp = '' sysstamp = '' dmesgstart = 0.0 dmesgfile = '' ftracefile = '' htmlfile = 'output.html' result = '' rtcwake = True rtcwaketime = 15 rtcpath = '' devicefilter = [] cgfilter = [] stamp = 0 execcount = 1 x2delay = 0 skiphtml = False usecallgraph = False ftopfunc = 'suspend_devices_and_enter' ftop = False usetraceevents = False usetracemarkers = True usekprobes = True usedevsrc = False useprocmon = False notestrun = False cgdump = False devdump = False mixedphaseheight = True devprops = dict() platinfo = [] predelay = 0 postdelay = 0 pmdebug = '' tracefuncs = { 'sys_sync': {}, 'ksys_sync': {}, '__pm_notifier_call_chain': {}, 'pm_prepare_console': {}, 'pm_notifier_call_chain': {}, 'freeze_processes': {}, 'freeze_kernel_threads': {}, 'pm_restrict_gfp_mask': {}, 'acpi_suspend_begin': {}, 'acpi_hibernation_begin': {}, 'acpi_hibernation_enter': {}, 'acpi_hibernation_leave': {}, 'acpi_pm_freeze': {}, 'acpi_pm_thaw': {}, 'acpi_s2idle_end': {}, 'acpi_s2idle_sync': {}, 'acpi_s2idle_begin': {}, 'acpi_s2idle_prepare': {}, 'acpi_s2idle_wake': {}, 'acpi_s2idle_wakeup': {}, 'acpi_s2idle_restore': {}, 'hibernate_preallocate_memory': {}, 'create_basic_memory_bitmaps': {}, 'swsusp_write': {}, 'suspend_console': {}, 'acpi_pm_prepare': {}, 'syscore_suspend': {}, 'arch_enable_nonboot_cpus_end': {}, 'syscore_resume': {}, 'acpi_pm_finish': {}, 'resume_console': {}, 'acpi_pm_end': {}, 'pm_restore_gfp_mask': {}, 'thaw_processes': {}, 'pm_restore_console': {}, 'CPU_OFF': { 'func':'_cpu_down', 'args_x86_64': {'cpu':'%di:s32'}, 'format': 'CPU_OFF[{cpu}]' }, 'CPU_ON': { 'func':'_cpu_up', 'args_x86_64': {'cpu':'%di:s32'}, 'format': 'CPU_ON[{cpu}]' }, } dev_tracefuncs = { # general wait/delay/sleep 'msleep': { 'args_x86_64': {'time':'%di:s32'}, 'ub': 1 }, 'schedule_timeout': { 'args_x86_64': {'timeout':'%di:s32'}, 'ub': 1 }, 'udelay': { 'func':'__const_udelay', 'args_x86_64': {'loops':'%di:s32'}, 'ub': 1 }, 'usleep_range': { 'args_x86_64': {'min':'%di:s32', 'max':'%si:s32'}, 'ub': 1 }, 'mutex_lock_slowpath': { 'func':'__mutex_lock_slowpath', 'ub': 1 }, 'acpi_os_stall': {'ub': 1}, 'rt_mutex_slowlock': {'ub': 1}, # ACPI 'acpi_resume_power_resources': {}, 'acpi_ps_execute_method': { 'args_x86_64': { 'fullpath':'+0(+40(%di)):string', }}, # mei_me 'mei_reset': {}, # filesystem 'ext4_sync_fs': {}, # 80211 'ath10k_bmi_read_memory': { 'args_x86_64': {'length':'%cx:s32'} }, 'ath10k_bmi_write_memory': { 'args_x86_64': {'length':'%cx:s32'} }, 'ath10k_bmi_fast_download': { 'args_x86_64': {'length':'%cx:s32'} }, 'iwlagn_mac_start': {}, 'iwlagn_alloc_bcast_station': {}, 'iwl_trans_pcie_start_hw': {}, 'iwl_trans_pcie_start_fw': {}, 'iwl_run_init_ucode': {}, 'iwl_load_ucode_wait_alive': {}, 'iwl_alive_start': {}, 'iwlagn_mac_stop': {}, 'iwlagn_mac_suspend': {}, 'iwlagn_mac_resume': {}, 'iwlagn_mac_add_interface': {}, 'iwlagn_mac_remove_interface': {}, 'iwlagn_mac_change_interface': {}, 'iwlagn_mac_config': {}, 'iwlagn_configure_filter': {}, 'iwlagn_mac_hw_scan': {}, 'iwlagn_bss_info_changed': {}, 'iwlagn_mac_channel_switch': {}, 'iwlagn_mac_flush': {}, # ATA 'ata_eh_recover': { 'args_x86_64': {'port':'+36(%di):s32'} }, # i915 'i915_gem_resume': {}, 'i915_restore_state': {}, 'intel_opregion_setup': {}, 'g4x_pre_enable_dp': {}, 'vlv_pre_enable_dp': {}, 'chv_pre_enable_dp': {}, 'g4x_enable_dp': {}, 'vlv_enable_dp': {}, 'intel_hpd_init': {}, 'intel_opregion_register': {}, 'intel_dp_detect': {}, 'intel_hdmi_detect': {}, 'intel_opregion_init': {}, 'intel_fbdev_set_suspend': {}, } cgblacklist = [] kprobes = dict() timeformat = '%.3f' cmdline = '%s %s' % \ (os.path.basename(sys.argv[0]), ' '.join(sys.argv[1:])) kparams = '' sudouser = '' def __init__(self): self.archargs = 'args_'+platform.machine() self.hostname = platform.node() if(self.hostname == ''): self.hostname = 'localhost' rtc = "rtc0" if os.path.exists('/dev/rtc'): rtc = os.readlink('/dev/rtc') rtc = '/sys/class/rtc/'+rtc if os.path.exists(rtc) and os.path.exists(rtc+'/date') and \ os.path.exists(rtc+'/time') and os.path.exists(rtc+'/wakealarm'): self.rtcpath = rtc if (hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()): self.ansi = True self.testdir = datetime.now().strftime('suspend-%y%m%d-%H%M%S') if os.getuid() == 0 and 'SUDO_USER' in os.environ and \ os.environ['SUDO_USER']: self.sudouser = os.environ['SUDO_USER'] def vprint(self, msg): self.logmsg += msg+'\n' if self.verbose or msg.startswith('WARNING:'): pprint(msg) def signalHandler(self, signum, frame): if not self.result: return signame = self.signames[signum] if signum in self.signames else 'UNKNOWN' msg = 'Signal %s caused a tool exit, line %d' % (signame, frame.f_lineno) sysvals.outputResult({'error':msg}) sys.exit(3) def signalHandlerInit(self): capture = ['BUS', 'SYS', 'XCPU', 'XFSZ', 'PWR', 'HUP', 'INT', 'QUIT', 'ILL', 'ABRT', 'FPE', 'SEGV', 'TERM', 'TSTP'] self.signames = dict() for i in capture: s = 'SIG'+i try: signum = getattr(signal, s) signal.signal(signum, self.signalHandler) except: continue self.signames[signum] = s def rootCheck(self, fatal=True): if(os.access(self.powerfile, os.W_OK)): return True if fatal: msg = 'This command requires sysfs mount and root access' pprint('ERROR: %s\n' % msg) self.outputResult({'error':msg}) sys.exit(1) return False def rootUser(self, fatal=False): if 'USER' in os.environ and os.environ['USER'] == 'root': return True if fatal: msg = 'This command must be run as root' pprint('ERROR: %s\n' % msg) self.outputResult({'error':msg}) sys.exit(1) return False def getExec(self, cmd): try: fp = Popen(['which', cmd], stdout=PIPE, stderr=PIPE).stdout out = ascii(fp.read()).strip() fp.close() except: out = '' if out: return out for path in ['/sbin', '/bin', '/usr/sbin', '/usr/bin', '/usr/local/sbin', '/usr/local/bin']: cmdfull = os.path.join(path, cmd) if os.path.exists(cmdfull): return cmdfull return out def setPrecision(self, num): if num < 0 or num > 6: return self.timeformat = '%.{0}f'.format(num) def setOutputFolder(self, value): args = dict() n = datetime.now() args['date'] = n.strftime('%y%m%d') args['time'] = n.strftime('%H%M%S') args['hostname'] = args['host'] = self.hostname args['mode'] = self.suspendmode return value.format(**args) def setOutputFile(self): if self.dmesgfile != '': m = re.match('(?P.*)_dmesg\.txt.*', self.dmesgfile) if(m): self.htmlfile = m.group('name')+'.html' if self.ftracefile != '': m = re.match('(?P.*)_ftrace\.txt.*', self.ftracefile) if(m): self.htmlfile = m.group('name')+'.html' def systemInfo(self, info): p = m = '' if 'baseboard-manufacturer' in info: m = info['baseboard-manufacturer'] elif 'system-manufacturer' in info: m = info['system-manufacturer'] if 'system-product-name' in info: p = info['system-product-name'] elif 'baseboard-product-name' in info: p = info['baseboard-product-name'] if m[:5].lower() == 'intel' and 'baseboard-product-name' in info: p = info['baseboard-product-name'] c = info['processor-version'] if 'processor-version' in info else '' b = info['bios-version'] if 'bios-version' in info else '' r = info['bios-release-date'] if 'bios-release-date' in info else '' self.sysstamp = '# sysinfo | man:%s | plat:%s | cpu:%s | bios:%s | biosdate:%s | numcpu:%d | memsz:%d | memfr:%d' % \ (m, p, c, b, r, self.cpucount, self.memtotal, self.memfree) try: kcmd = open('/proc/cmdline', 'r').read().strip() except: kcmd = '' if kcmd: self.sysstamp += '\n# kparams | %s' % kcmd def printSystemInfo(self, fatal=False): self.rootCheck(True) out = dmidecode(self.mempath, fatal) if len(out) < 1: return fmt = '%-24s: %s' for name in sorted(out): print(fmt % (name, out[name])) print(fmt % ('cpucount', ('%d' % self.cpucount))) print(fmt % ('memtotal', ('%d kB' % self.memtotal))) print(fmt % ('memfree', ('%d kB' % self.memfree))) def cpuInfo(self): self.cpucount = 0 fp = open('/proc/cpuinfo', 'r') for line in fp: if re.match('^processor[ \t]*:[ \t]*[0-9]*', line): self.cpucount += 1 fp.close() fp = open('/proc/meminfo', 'r') for line in fp: m = re.match('^MemTotal:[ \t]*(?P[0-9]*) *kB', line) if m: self.memtotal = int(m.group('sz')) m = re.match('^MemFree:[ \t]*(?P[0-9]*) *kB', line) if m: self.memfree = int(m.group('sz')) fp.close() def initTestOutput(self, name): self.prefix = self.hostname v = open('/proc/version', 'r').read().strip() kver = v.split()[2] fmt = name+'-%m%d%y-%H%M%S' testtime = datetime.now().strftime(fmt) self.teststamp = \ '# '+testtime+' '+self.prefix+' '+self.suspendmode+' '+kver ext = '' if self.gzip: ext = '.gz' self.dmesgfile = \ self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_dmesg.txt'+ext self.ftracefile = \ self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_ftrace.txt'+ext self.htmlfile = \ self.testdir+'/'+self.prefix+'_'+self.suspendmode+'.html' if not os.path.isdir(self.testdir): os.makedirs(self.testdir) def getValueList(self, value): out = [] for i in value.split(','): if i.strip(): out.append(i.strip()) return out def setDeviceFilter(self, value): self.devicefilter = self.getValueList(value) def setCallgraphFilter(self, value): self.cgfilter = self.getValueList(value) def skipKprobes(self, value): for k in self.getValueList(value): if k in self.tracefuncs: del self.tracefuncs[k] if k in self.dev_tracefuncs: del self.dev_tracefuncs[k] def setCallgraphBlacklist(self, file): self.cgblacklist = self.listFromFile(file) def rtcWakeAlarmOn(self): call('echo 0 > '+self.rtcpath+'/wakealarm', shell=True) nowtime = open(self.rtcpath+'/since_epoch', 'r').read().strip() if nowtime: nowtime = int(nowtime) else: # if hardware time fails, use the software time nowtime = int(datetime.now().strftime('%s')) alarm = nowtime + self.rtcwaketime call('echo %d > %s/wakealarm' % (alarm, self.rtcpath), shell=True) def rtcWakeAlarmOff(self): call('echo 0 > %s/wakealarm' % self.rtcpath, shell=True) def initdmesg(self): # get the latest time stamp from the dmesg log fp = Popen('dmesg', stdout=PIPE).stdout ktime = '0' for line in fp: line = ascii(line).replace('\r\n', '') idx = line.find('[') if idx > 1: line = line[idx:] m = re.match('[ \t]*(\[ *)(?P[0-9\.]*)(\]) (?P.*)', line) if(m): ktime = m.group('ktime') fp.close() self.dmesgstart = float(ktime) def getdmesg(self, testdata): op = self.writeDatafileHeader(sysvals.dmesgfile, testdata) # store all new dmesg lines since initdmesg was called fp = Popen('dmesg', stdout=PIPE).stdout for line in fp: line = ascii(line).replace('\r\n', '') idx = line.find('[') if idx > 1: line = line[idx:] m = re.match('[ \t]*(\[ *)(?P[0-9\.]*)(\]) (?P.*)', line) if(not m): continue ktime = float(m.group('ktime')) if ktime > self.dmesgstart: op.write(line) fp.close() op.close() def listFromFile(self, file): list = [] fp = open(file) for i in fp.read().split('\n'): i = i.strip() if i and i[0] != '#': list.append(i) fp.close() return list def addFtraceFilterFunctions(self, file): for i in self.listFromFile(file): if len(i) < 2: continue self.tracefuncs[i] = dict() def getFtraceFilterFunctions(self, current): self.rootCheck(True) if not current: call('cat '+self.tpath+'available_filter_functions', shell=True) return master = self.listFromFile(self.tpath+'available_filter_functions') for i in sorted(self.tracefuncs): if 'func' in self.tracefuncs[i]: i = self.tracefuncs[i]['func'] if i in master: print(i) else: print(self.colorText(i)) def setFtraceFilterFunctions(self, list): master = self.listFromFile(self.tpath+'available_filter_functions') flist = '' for i in list: if i not in master: continue if ' [' in i: flist += i.split(' ')[0]+'\n' else: flist += i+'\n' fp = open(self.tpath+'set_graph_function', 'w') fp.write(flist) fp.close() def basicKprobe(self, name): self.kprobes[name] = {'name': name,'func': name,'args': dict(),'format': name} def defaultKprobe(self, name, kdata): k = kdata for field in ['name', 'format', 'func']: if field not in k: k[field] = name if self.archargs in k: k['args'] = k[self.archargs] else: k['args'] = dict() k['format'] = name self.kprobes[name] = k def kprobeColor(self, name): if name not in self.kprobes or 'color' not in self.kprobes[name]: return '' return self.kprobes[name]['color'] def kprobeDisplayName(self, name, dataraw): if name not in self.kprobes: self.basicKprobe(name) data = '' quote=0 # first remvoe any spaces inside quotes, and the quotes for c in dataraw: if c == '"': quote = (quote + 1) % 2 if quote and c == ' ': data += '_' elif c != '"': data += c fmt, args = self.kprobes[name]['format'], self.kprobes[name]['args'] arglist = dict() # now process the args for arg in sorted(args): arglist[arg] = '' m = re.match('.* '+arg+'=(?P.*) ', data); if m: arglist[arg] = m.group('arg') else: m = re.match('.* '+arg+'=(?P.*)', data); if m: arglist[arg] = m.group('arg') out = fmt.format(**arglist) out = out.replace(' ', '_').replace('"', '') return out def kprobeText(self, kname, kprobe): name = fmt = func = kname args = dict() if 'name' in kprobe: name = kprobe['name'] if 'format' in kprobe: fmt = kprobe['format'] if 'func' in kprobe: func = kprobe['func'] if self.archargs in kprobe: args = kprobe[self.archargs] if 'args' in kprobe: args = kprobe['args'] if re.findall('{(?P[a-z,A-Z,0-9]*)}', func): doError('Kprobe "%s" has format info in the function name "%s"' % (name, func)) for arg in re.findall('{(?P[a-z,A-Z,0-9]*)}', fmt): if arg not in args: doError('Kprobe "%s" is missing argument "%s"' % (name, arg)) val = 'p:%s_cal %s' % (name, func) for i in sorted(args): val += ' %s=%s' % (i, args[i]) val += '\nr:%s_ret %s $retval\n' % (name, func) return val def addKprobes(self, output=False): if len(self.kprobes) < 1: return if output: pprint(' kprobe functions in this kernel:') # first test each kprobe rejects = [] # sort kprobes: trace, ub-dev, custom, dev kpl = [[], [], [], []] linesout = len(self.kprobes) for name in sorted(self.kprobes): res = self.colorText('YES', 32) if not self.testKprobe(name, self.kprobes[name]): res = self.colorText('NO') rejects.append(name) else: if name in self.tracefuncs: kpl[0].append(name) elif name in self.dev_tracefuncs: if 'ub' in self.dev_tracefuncs[name]: kpl[1].append(name) else: kpl[3].append(name) else: kpl[2].append(name) if output: pprint(' %s: %s' % (name, res)) kplist = kpl[0] + kpl[1] + kpl[2] + kpl[3] # remove all failed ones from the list for name in rejects: self.kprobes.pop(name) # set the kprobes all at once self.fsetVal('', 'kprobe_events') kprobeevents = '' for kp in kplist: kprobeevents += self.kprobeText(kp, self.kprobes[kp]) self.fsetVal(kprobeevents, 'kprobe_events') if output: check = self.fgetVal('kprobe_events') linesack = (len(check.split('\n')) - 1) // 2 pprint(' kprobe functions enabled: %d/%d' % (linesack, linesout)) self.fsetVal('1', 'events/kprobes/enable') def testKprobe(self, kname, kprobe): self.fsetVal('0', 'events/kprobes/enable') kprobeevents = self.kprobeText(kname, kprobe) if not kprobeevents: return False try: self.fsetVal(kprobeevents, 'kprobe_events') check = self.fgetVal('kprobe_events') except: return False linesout = len(kprobeevents.split('\n')) linesack = len(check.split('\n')) if linesack < linesout: return False return True def setVal(self, val, file): if not os.path.exists(file): return False try: fp = open(file, 'wb', 0) fp.write(val.encode()) fp.flush() fp.close() except: return False return True def fsetVal(self, val, path): return self.setVal(val, self.tpath+path) def getVal(self, file): res = '' if not os.path.exists(file): return res try: fp = open(file, 'r') res = fp.read() fp.close() except: pass return res def fgetVal(self, path): return self.getVal(self.tpath+path) def cleanupFtrace(self): if(self.usecallgraph or self.usetraceevents or self.usedevsrc): self.fsetVal('0', 'events/kprobes/enable') self.fsetVal('', 'kprobe_events') self.fsetVal('1024', 'buffer_size_kb') if self.pmdebug: self.setVal(self.pmdebug, self.pmdpath) def setupAllKprobes(self): for name in self.tracefuncs: self.defaultKprobe(name, self.tracefuncs[name]) for name in self.dev_tracefuncs: self.defaultKprobe(name, self.dev_tracefuncs[name]) def isCallgraphFunc(self, name): if len(self.tracefuncs) < 1 and self.suspendmode == 'command': return True for i in self.tracefuncs: if 'func' in self.tracefuncs[i]: f = self.tracefuncs[i]['func'] else: f = i if name == f: return True return False def initFtrace(self): self.printSystemInfo(False) pprint('INITIALIZING FTRACE...') # turn trace off self.fsetVal('0', 'tracing_on') self.cleanupFtrace() # pm debug messages pv = self.getVal(self.pmdpath) if pv != '1': self.setVal('1', self.pmdpath) self.pmdebug = pv # set the trace clock to global self.fsetVal('global', 'trace_clock') self.fsetVal('nop', 'current_tracer') # set trace buffer to an appropriate value cpus = max(1, self.cpucount) if self.bufsize > 0: tgtsize = self.bufsize elif self.usecallgraph or self.usedevsrc: bmax = (1*1024*1024) if self.suspendmode in ['disk', 'command'] \ else (3*1024*1024) tgtsize = min(self.memfree, bmax) else: tgtsize = 65536 while not self.fsetVal('%d' % (tgtsize // cpus), 'buffer_size_kb'): # if the size failed to set, lower it and keep trying tgtsize -= 65536 if tgtsize < 65536: tgtsize = int(self.fgetVal('buffer_size_kb')) * cpus break pprint('Setting trace buffers to %d kB (%d kB per cpu)' % (tgtsize, tgtsize/cpus)) # initialize the callgraph trace if(self.usecallgraph): # set trace type self.fsetVal('function_graph', 'current_tracer') self.fsetVal('', 'set_ftrace_filter') # set trace format options self.fsetVal('print-parent', 'trace_options') self.fsetVal('funcgraph-abstime', 'trace_options') self.fsetVal('funcgraph-cpu', 'trace_options') self.fsetVal('funcgraph-duration', 'trace_options') self.fsetVal('funcgraph-proc', 'trace_options') self.fsetVal('funcgraph-tail', 'trace_options') self.fsetVal('nofuncgraph-overhead', 'trace_options') self.fsetVal('context-info', 'trace_options') self.fsetVal('graph-time', 'trace_options') self.fsetVal('%d' % self.max_graph_depth, 'max_graph_depth') cf = ['dpm_run_callback'] if(self.usetraceevents): cf += ['dpm_prepare', 'dpm_complete'] for fn in self.tracefuncs: if 'func' in self.tracefuncs[fn]: cf.append(self.tracefuncs[fn]['func']) else: cf.append(fn) if self.ftop: self.setFtraceFilterFunctions([self.ftopfunc]) else: self.setFtraceFilterFunctions(cf) # initialize the kprobe trace elif self.usekprobes: for name in self.tracefuncs: self.defaultKprobe(name, self.tracefuncs[name]) if self.usedevsrc: for name in self.dev_tracefuncs: self.defaultKprobe(name, self.dev_tracefuncs[name]) pprint('INITIALIZING KPROBES...') self.addKprobes(self.verbose) if(self.usetraceevents): # turn trace events on events = iter(self.traceevents) for e in events: self.fsetVal('1', 'events/power/'+e+'/enable') # clear the trace buffer self.fsetVal('', 'trace') def verifyFtrace(self): # files needed for any trace data files = ['buffer_size_kb', 'current_tracer', 'trace', 'trace_clock', 'trace_marker', 'trace_options', 'tracing_on'] # files needed for callgraph trace data tp = self.tpath if(self.usecallgraph): files += [ 'available_filter_functions', 'set_ftrace_filter', 'set_graph_function' ] for f in files: if(os.path.exists(tp+f) == False): return False return True def verifyKprobes(self): # files needed for kprobes to work files = ['kprobe_events', 'events'] tp = self.tpath for f in files: if(os.path.exists(tp+f) == False): return False return True def colorText(self, str, color=31): if not self.ansi: return str return '\x1B[%d;40m%s\x1B[m' % (color, str) def writeDatafileHeader(self, filename, testdata): fp = self.openlog(filename, 'w') fp.write('%s\n%s\n# command | %s\n' % (self.teststamp, self.sysstamp, self.cmdline)) for test in testdata: if 'fw' in test: fw = test['fw'] if(fw): fp.write('# fwsuspend %u fwresume %u\n' % (fw[0], fw[1])) if 'mcelog' in test: fp.write('# mcelog %s\n' % test['mcelog']) if 'turbo' in test: fp.write('# turbostat %s\n' % test['turbo']) if 'bat' in test: (a1, c1), (a2, c2) = test['bat'] fp.write('# battery %s %d %s %d\n' % (a1, c1, a2, c2)) if 'wifi' in test: wstr = [] for wifi in test['wifi']: tmp = [] for key in sorted(wifi): tmp.append('%s:%s' % (key, wifi[key])) wstr.append('|'.join(tmp)) fp.write('# wifi %s\n' % (','.join(wstr))) if test['error'] or len(testdata) > 1: fp.write('# enter_sleep_error %s\n' % test['error']) return fp def sudoUserchown(self, dir): if os.path.exists(dir) and self.sudouser: cmd = 'chown -R {0}:{0} {1} > /dev/null 2>&1' call(cmd.format(self.sudouser, dir), shell=True) def outputResult(self, testdata, num=0): if not self.result: return n = '' if num > 0: n = '%d' % num fp = open(self.result, 'a') if 'error' in testdata: fp.write('result%s: fail\n' % n) fp.write('error%s: %s\n' % (n, testdata['error'])) else: fp.write('result%s: pass\n' % n) for v in ['suspend', 'resume', 'boot', 'lastinit']: if v in testdata: fp.write('%s%s: %.3f\n' % (v, n, testdata[v])) for v in ['fwsuspend', 'fwresume']: if v in testdata: fp.write('%s%s: %.3f\n' % (v, n, testdata[v] / 1000000.0)) if 'bugurl' in testdata: fp.write('url%s: %s\n' % (n, testdata['bugurl'])) fp.close() self.sudoUserchown(self.result) def configFile(self, file): dir = os.path.dirname(os.path.realpath(__file__)) if os.path.exists(file): return file elif os.path.exists(dir+'/'+file): return dir+'/'+file elif os.path.exists(dir+'/config/'+file): return dir+'/config/'+file return '' def openlog(self, filename, mode): isgz = self.gzip if mode == 'r': try: with gzip.open(filename, mode+'t') as fp: test = fp.read(64) isgz = True except: isgz = False if isgz: return gzip.open(filename, mode+'t') return open(filename, mode) def b64unzip(self, data): try: out = codecs.decode(base64.b64decode(data), 'zlib').decode() except: out = data return out def b64zip(self, data): out = base64.b64encode(codecs.encode(data.encode(), 'zlib')).decode() return out def mcelog(self, clear=False): cmd = self.getExec('mcelog') if not cmd: return '' if clear: call(cmd+' > /dev/null 2>&1', shell=True) return '' try: fp = Popen([cmd], stdout=PIPE, stderr=PIPE).stdout out = ascii(fp.read()).strip() fp.close() except: return '' if not out: return '' return self.b64zip(out) def platforminfo(self): # add platform info on to a completed ftrace file if not os.path.exists(self.ftracefile): return False footer = '#\n' # add test command string line if need be if self.suspendmode == 'command' and self.testcommand: footer += '# platform-testcmd: %s\n' % (self.testcommand) # get a list of target devices from the ftrace file props = dict() tp = TestProps() tf = self.openlog(self.ftracefile, 'r') for line in tf: # determine the trace data type (required for further parsing) m = re.match(tp.tracertypefmt, line) if(m): tp.setTracerType(m.group('t')) continue # parse only valid lines, if this is not one move on m = re.match(tp.ftrace_line_fmt, line) if(not m or 'device_pm_callback_start' not in line): continue m = re.match('.*: (?P.*) (?P.*), parent: *(?P

.*), .*', m.group('msg')); if(not m): continue dev = m.group('d') if dev not in props: props[dev] = DevProps() tf.close() # now get the syspath for each target device for dirname, dirnames, filenames in os.walk('/sys/devices'): if(re.match('.*/power', dirname) and 'async' in filenames): dev = dirname.split('/')[-2] if dev in props and (not props[dev].syspath or len(dirname) < len(props[dev].syspath)): props[dev].syspath = dirname[:-6] # now fill in the properties for our target devices for dev in sorted(props): dirname = props[dev].syspath if not dirname or not os.path.exists(dirname): continue with open(dirname+'/power/async') as fp: text = fp.read() props[dev].isasync = False if 'enabled' in text: props[dev].isasync = True fields = os.listdir(dirname) if 'product' in fields: with open(dirname+'/product', 'rb') as fp: props[dev].altname = ascii(fp.read()) elif 'name' in fields: with open(dirname+'/name', 'rb') as fp: props[dev].altname = ascii(fp.read()) elif 'model' in fields: with open(dirname+'/model', 'rb') as fp: props[dev].altname = ascii(fp.read()) elif 'description' in fields: with open(dirname+'/description', 'rb') as fp: props[dev].altname = ascii(fp.read()) elif 'id' in fields: with open(dirname+'/id', 'rb') as fp: props[dev].altname = ascii(fp.read()) elif 'idVendor' in fields and 'idProduct' in fields: idv, idp = '', '' with open(dirname+'/idVendor', 'rb') as fp: idv = ascii(fp.read()).strip() with open(dirname+'/idProduct', 'rb') as fp: idp = ascii(fp.read()).strip() props[dev].altname = '%s:%s' % (idv, idp) if props[dev].altname: out = props[dev].altname.strip().replace('\n', ' ')\ .replace(',', ' ').replace(';', ' ') props[dev].altname = out # add a devinfo line to the bottom of ftrace out = '' for dev in sorted(props): out += props[dev].out(dev) footer += '# platform-devinfo: %s\n' % self.b64zip(out) # add a line for each of these commands with their outputs cmds = [ ['pcidevices', 'lspci', '-tv'], ['interrupts', 'cat', '/proc/interrupts'], ['gpecounts', 'sh', '-c', 'grep -v invalid /sys/firmware/acpi/interrupts/gpe*'], ] for cargs in cmds: name = cargs[0] cmdline = ' '.join(cargs[1:]) cmdpath = self.getExec(cargs[1]) if not cmdpath: continue cmd = [cmdpath] + cargs[2:] try: fp = Popen(cmd, stdout=PIPE, stderr=PIPE).stdout info = ascii(fp.read()).strip() fp.close() except: continue if not info: continue footer += '# platform-%s: %s | %s\n' % (name, cmdline, self.b64zip(info)) with self.openlog(self.ftracefile, 'a') as fp: fp.write(footer) return True def haveTurbostat(self): if not self.tstat: return False cmd = self.getExec('turbostat') if not cmd: return False fp = Popen([cmd, '-v'], stdout=PIPE, stderr=PIPE).stderr out = ascii(fp.read()).strip() fp.close() if re.match('turbostat version [0-9\.]* .*', out): sysvals.vprint(out) return True return False def turbostat(self): cmd = self.getExec('turbostat') rawout = keyline = valline = '' fullcmd = '%s -q -S echo freeze > %s' % (cmd, self.powerfile) fp = Popen(['sh', '-c', fullcmd], stdout=PIPE, stderr=PIPE).stderr for line in fp: line = ascii(line) rawout += line if keyline and valline: continue if re.match('(?i)Avg_MHz.*', line): keyline = line.strip().split() elif keyline: valline = line.strip().split() fp.close() if not keyline or not valline or len(keyline) != len(valline): errmsg = 'unrecognized turbostat output:\n'+rawout.strip() sysvals.vprint(errmsg) if not sysvals.verbose: pprint(errmsg) return '' if sysvals.verbose: pprint(rawout.strip()) out = [] for key in keyline: idx = keyline.index(key) val = valline[idx] out.append('%s=%s' % (key, val)) return '|'.join(out) def checkWifi(self): out = dict() iwcmd, ifcmd = self.getExec('iwconfig'), self.getExec('ifconfig') if not iwcmd or not ifcmd: return out fp = Popen(iwcmd, stdout=PIPE, stderr=PIPE).stdout for line in fp: m = re.match('(?P\S*) .* ESSID:(?P\S*)', ascii(line)) if not m: continue out['device'] = m.group('dev') if '"' in m.group('ess'): out['essid'] = m.group('ess').strip('"') break fp.close() if 'device' in out: fp = Popen([ifcmd, out['device']], stdout=PIPE, stderr=PIPE).stdout for line in fp: m = re.match('.* inet (?P[0-9\.]*)', ascii(line)) if m: out['ip'] = m.group('ip') break fp.close() return out def errorSummary(self, errinfo, msg): found = False for entry in errinfo: if re.match(entry['match'], msg): entry['count'] += 1 if self.hostname not in entry['urls']: entry['urls'][self.hostname] = [self.htmlfile] elif self.htmlfile not in entry['urls'][self.hostname]: entry['urls'][self.hostname].append(self.htmlfile) found = True break if found: return arr = msg.split() for j in range(len(arr)): if re.match('^[0-9,\-\.]*$', arr[j]): arr[j] = '[0-9,\-\.]*' else: arr[j] = arr[j]\ .replace('\\', '\\\\').replace(']', '\]').replace('[', '\[')\ .replace('.', '\.').replace('+', '\+').replace('*', '\*')\ .replace('(', '\(').replace(')', '\)') mstr = ' '.join(arr) entry = { 'line': msg, 'match': mstr, 'count': 1, 'urls': {self.hostname: [self.htmlfile]} } errinfo.append(entry) sysvals = SystemValues() switchvalues = ['enable', 'disable', 'on', 'off', 'true', 'false', '1', '0'] switchoff = ['disable', 'off', 'false', '0'] suspendmodename = { 'freeze': 'Freeze (S0)', 'standby': 'Standby (S1)', 'mem': 'Suspend (S3)', 'disk': 'Hibernate (S4)' } # Class: DevProps # Description: # Simple class which holds property values collected # for all the devices used in the timeline. class DevProps: def __init__(self): self.syspath = '' self.altname = '' self.isasync = True self.xtraclass = '' self.xtrainfo = '' def out(self, dev): return '%s,%s,%d;' % (dev, self.altname, self.isasync) def debug(self, dev): pprint('%s:\n\taltname = %s\n\t async = %s' % (dev, self.altname, self.isasync)) def altName(self, dev): if not self.altname or self.altname == dev: return dev return '%s [%s]' % (self.altname, dev) def xtraClass(self): if self.xtraclass: return ' '+self.xtraclass if not self.isasync: return ' sync' return '' def xtraInfo(self): if self.xtraclass: return ' '+self.xtraclass if self.isasync: return ' async_device' return ' sync_device' # Class: DeviceNode # Description: # A container used to create a device hierachy, with a single root node # and a tree of child nodes. Used by Data.deviceTopology() class DeviceNode: def __init__(self, nodename, nodedepth): self.name = nodename self.children = [] self.depth = nodedepth # Class: Data # Description: # The primary container for suspend/resume test data. There is one for # each test run. The data is organized into a cronological hierarchy: # Data.dmesg { # phases { # 10 sequential, non-overlapping phases of S/R # contents: times for phase start/end, order/color data for html # devlist { # device callback or action list for this phase # device { # a single device callback or generic action # contents: start/stop times, pid/cpu/driver info # parents/children, html id for timeline/callgraph # optionally includes an ftrace callgraph # optionally includes dev/ps data # } # } # } # } # class Data: phasedef = { 'suspend_prepare': {'order': 0, 'color': '#CCFFCC'}, 'suspend': {'order': 1, 'color': '#88FF88'}, 'suspend_late': {'order': 2, 'color': '#00AA00'}, 'suspend_noirq': {'order': 3, 'color': '#008888'}, 'suspend_machine': {'order': 4, 'color': '#0000FF'}, 'resume_machine': {'order': 5, 'color': '#FF0000'}, 'resume_noirq': {'order': 6, 'color': '#FF9900'}, 'resume_early': {'order': 7, 'color': '#FFCC00'}, 'resume': {'order': 8, 'color': '#FFFF88'}, 'resume_complete': {'order': 9, 'color': '#FFFFCC'}, } errlist = { 'HWERROR' : '.*\[ *Hardware Error *\].*', 'FWBUG' : '.*\[ *Firmware Bug *\].*', 'BUG' : '.*BUG.*', 'ERROR' : '.*ERROR.*', 'WARNING' : '.*WARNING.*', 'IRQ' : '.*genirq: .*', 'TASKFAIL': '.*Freezing of tasks *.*', 'ACPI' : '.*ACPI *(?P[A-Za-z]*) *Error[: ].*', 'DEVFAIL' : '.* failed to (?P[a-z]*) async: .*', 'DISKFULL': '.*No space left on device.*', 'USBERR' : '.*usb .*device .*, error [0-9-]*', 'ATAERR' : ' *ata[0-9\.]*: .*failed.*', 'MEIERR' : ' *mei.*: .*failed.*', 'TPMERR' : '(?i) *tpm *tpm[0-9]*: .*error.*', } def __init__(self, num): idchar = 'abcdefghij' self.start = 0.0 # test start self.end = 0.0 # test end self.tSuspended = 0.0 # low-level suspend start self.tResumed = 0.0 # low-level resume start self.tKernSus = 0.0 # kernel level suspend start self.tKernRes = 0.0 # kernel level resume end self.fwValid = False # is firmware data available self.fwSuspend = 0 # time spent in firmware suspend self.fwResume = 0 # time spent in firmware resume self.html_device_id = 0 self.stamp = 0 self.outfile = '' self.kerror = False self.battery = 0 self.wifi = 0 self.turbostat = 0 self.mcelog = 0 self.enterfail = '' self.currphase = '' self.pstl = dict() # process timeline self.testnumber = num self.idstr = idchar[num] self.dmesgtext = [] # dmesg text file in memory self.dmesg = dict() # root data structure self.errorinfo = {'suspend':[],'resume':[]} self.tLow = [] # time spent in low-level suspends (standby/freeze) self.devpids = [] self.devicegroups = 0 def sortedPhases(self): return sorted(self.dmesg, key=lambda k:self.dmesg[k]['order']) def initDevicegroups(self): # called when phases are all finished being added for phase in sorted(self.dmesg.keys()): if '*' in phase: p = phase.split('*') pnew = '%s%d' % (p[0], len(p)) self.dmesg[pnew] = self.dmesg.pop(phase) self.devicegroups = [] for phase in self.sortedPhases(): self.devicegroups.append([phase]) def nextPhase(self, phase, offset): order = self.dmesg[phase]['order'] + offset for p in self.dmesg: if self.dmesg[p]['order'] == order: return p return '' def lastPhase(self): plist = self.sortedPhases() if len(plist) < 1: return '' return plist[-1] def turbostatInfo(self): tp = TestProps() out = {'syslpi':'N/A','pkgpc10':'N/A'} for line in self.dmesgtext: m = re.match(tp.tstatfmt, line) if not m: continue for i in m.group('t').split('|'): if 'SYS%LPI' in i: out['syslpi'] = i.split('=')[-1]+'%' elif 'pc10' in i: out['pkgpc10'] = i.split('=')[-1]+'%' break return out def extractErrorInfo(self): lf = self.dmesgtext if len(self.dmesgtext) < 1 and sysvals.dmesgfile: lf = sysvals.openlog(sysvals.dmesgfile, 'r') i = 0 list = [] for line in lf: i += 1 m = re.match('[ \t]*(\[ *)(?P[0-9\.]*)(\]) (?P.*)', line) if not m: continue t = float(m.group('ktime')) if t < self.start or t > self.end: continue dir = 'suspend' if t < self.tSuspended else 'resume' msg = m.group('msg') for err in self.errlist: if re.match(self.errlist[err], msg): list.append((msg, err, dir, t, i, i)) self.kerror = True break msglist = [] for msg, type, dir, t, idx1, idx2 in list: msglist.append(msg) sysvals.vprint('kernel %s found in %s at %f' % (type, dir, t)) self.errorinfo[dir].append((type, t, idx1, idx2)) if self.kerror: sysvals.dmesglog = True if len(self.dmesgtext) < 1 and sysvals.dmesgfile: lf.close() return msglist def setStart(self, time): self.start = time def setEnd(self, time): self.end = time def isTraceEventOutsideDeviceCalls(self, pid, time): for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] for dev in list: d = list[dev] if(d['pid'] == pid and time >= d['start'] and time < d['end']): return False return True def sourcePhase(self, start): for phase in self.sortedPhases(): if 'machine' in phase: continue pend = self.dmesg[phase]['end'] if start <= pend: return phase return 'resume_complete' def sourceDevice(self, phaselist, start, end, pid, type): tgtdev = '' for phase in phaselist: list = self.dmesg[phase]['list'] for devname in list: dev = list[devname] # pid must match if dev['pid'] != pid: continue devS = dev['start'] devE = dev['end'] if type == 'device': # device target event is entirely inside the source boundary if(start < devS or start >= devE or end <= devS or end > devE): continue elif type == 'thread': # thread target event will expand the source boundary if start < devS: dev['start'] = start if end > devE: dev['end'] = end tgtdev = dev break return tgtdev def addDeviceFunctionCall(self, displayname, kprobename, proc, pid, start, end, cdata, rdata): # try to place the call in a device phases = self.sortedPhases() tgtdev = self.sourceDevice(phases, start, end, pid, 'device') # calls with device pids that occur outside device bounds are dropped # TODO: include these somehow if not tgtdev and pid in self.devpids: return False # try to place the call in a thread if not tgtdev: tgtdev = self.sourceDevice(phases, start, end, pid, 'thread') # create new thread blocks, expand as new calls are found if not tgtdev: if proc == '<...>': threadname = 'kthread-%d' % (pid) else: threadname = '%s-%d' % (proc, pid) tgtphase = self.sourcePhase(start) self.newAction(tgtphase, threadname, pid, '', start, end, '', ' kth', '') return self.addDeviceFunctionCall(displayname, kprobename, proc, pid, start, end, cdata, rdata) # this should not happen if not tgtdev: sysvals.vprint('[%f - %f] %s-%d %s %s %s' % \ (start, end, proc, pid, kprobename, cdata, rdata)) return False # place the call data inside the src element of the tgtdev if('src' not in tgtdev): tgtdev['src'] = [] dtf = sysvals.dev_tracefuncs ubiquitous = False if kprobename in dtf and 'ub' in dtf[kprobename]: ubiquitous = True title = cdata+' '+rdata mstr = '\(.*\) *(?P.*) *\((?P.*)\+.* arg1=(?P.*)' m = re.match(mstr, title) if m: c = m.group('caller') a = m.group('args').strip() r = m.group('ret') if len(r) > 6: r = '' else: r = 'ret=%s ' % r if ubiquitous and c in dtf and 'ub' in dtf[c]: return False color = sysvals.kprobeColor(kprobename) e = DevFunction(displayname, a, c, r, start, end, ubiquitous, proc, pid, color) tgtdev['src'].append(e) return True def overflowDevices(self): # get a list of devices that extend beyond the end of this test run devlist = [] for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] for devname in list: dev = list[devname] if dev['end'] > self.end: devlist.append(dev) return devlist def mergeOverlapDevices(self, devlist): # merge any devices that overlap devlist for dev in devlist: devname = dev['name'] for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] if devname not in list: continue tdev = list[devname] o = min(dev['end'], tdev['end']) - max(dev['start'], tdev['start']) if o <= 0: continue dev['end'] = tdev['end'] if 'src' not in dev or 'src' not in tdev: continue dev['src'] += tdev['src'] del list[devname] def usurpTouchingThread(self, name, dev): # the caller test has priority of this thread, give it to him for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] if name in list: tdev = list[name] if tdev['start'] - dev['end'] < 0.1: dev['end'] = tdev['end'] if 'src' not in dev: dev['src'] = [] if 'src' in tdev: dev['src'] += tdev['src'] del list[name] break def stitchTouchingThreads(self, testlist): # merge any threads between tests that touch for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] for devname in list: dev = list[devname] if 'htmlclass' not in dev or 'kth' not in dev['htmlclass']: continue for data in testlist: data.usurpTouchingThread(devname, dev) def optimizeDevSrc(self): # merge any src call loops to reduce timeline size for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] for dev in list: if 'src' not in list[dev]: continue src = list[dev]['src'] p = 0 for e in sorted(src, key=lambda event: event.time): if not p or not e.repeat(p): p = e continue # e is another iteration of p, move it into p p.end = e.end p.length = p.end - p.time p.count += 1 src.remove(e) def trimTimeVal(self, t, t0, dT, left): if left: if(t > t0): if(t - dT < t0): return t0 return t - dT else: return t else: if(t < t0 + dT): if(t > t0): return t0 + dT return t + dT else: return t def trimTime(self, t0, dT, left): self.tSuspended = self.trimTimeVal(self.tSuspended, t0, dT, left) self.tResumed = self.trimTimeVal(self.tResumed, t0, dT, left) self.start = self.trimTimeVal(self.start, t0, dT, left) self.tKernSus = self.trimTimeVal(self.tKernSus, t0, dT, left) self.tKernRes = self.trimTimeVal(self.tKernRes, t0, dT, left) self.end = self.trimTimeVal(self.end, t0, dT, left) for phase in self.sortedPhases(): p = self.dmesg[phase] p['start'] = self.trimTimeVal(p['start'], t0, dT, left) p['end'] = self.trimTimeVal(p['end'], t0, dT, left) list = p['list'] for name in list: d = list[name] d['start'] = self.trimTimeVal(d['start'], t0, dT, left) d['end'] = self.trimTimeVal(d['end'], t0, dT, left) d['length'] = d['end'] - d['start'] if('ftrace' in d): cg = d['ftrace'] cg.start = self.trimTimeVal(cg.start, t0, dT, left) cg.end = self.trimTimeVal(cg.end, t0, dT, left) for line in cg.list: line.time = self.trimTimeVal(line.time, t0, dT, left) if('src' in d): for e in d['src']: e.time = self.trimTimeVal(e.time, t0, dT, left) for dir in ['suspend', 'resume']: list = [] for e in self.errorinfo[dir]: type, tm, idx1, idx2 = e tm = self.trimTimeVal(tm, t0, dT, left) list.append((type, tm, idx1, idx2)) self.errorinfo[dir] = list def trimFreezeTime(self, tZero): # trim out any standby or freeze clock time lp = '' for phase in self.sortedPhases(): if 'resume_machine' in phase and 'suspend_machine' in lp: tS, tR = self.dmesg[lp]['end'], self.dmesg[phase]['start'] tL = tR - tS if tL > 0: left = True if tR > tZero else False self.trimTime(tS, tL, left) self.tLow.append('%.0f'%(tL*1000)) lp = phase def getTimeValues(self): sktime = (self.tSuspended - self.tKernSus) * 1000 rktime = (self.tKernRes - self.tResumed) * 1000 return (sktime, rktime) def setPhase(self, phase, ktime, isbegin, order=-1): if(isbegin): # phase start over current phase if self.currphase: if 'resume_machine' not in self.currphase: sysvals.vprint('WARNING: phase %s failed to end' % self.currphase) self.dmesg[self.currphase]['end'] = ktime phases = self.dmesg.keys() color = self.phasedef[phase]['color'] count = len(phases) if order < 0 else order # create unique name for every new phase while phase in phases: phase += '*' self.dmesg[phase] = {'list': dict(), 'start': -1.0, 'end': -1.0, 'row': 0, 'color': color, 'order': count} self.dmesg[phase]['start'] = ktime self.currphase = phase else: # phase end without a start if phase not in self.currphase: if self.currphase: sysvals.vprint('WARNING: %s ended instead of %s, ftrace corruption?' % (phase, self.currphase)) else: sysvals.vprint('WARNING: %s ended without a start, ftrace corruption?' % phase) return phase phase = self.currphase self.dmesg[phase]['end'] = ktime self.currphase = '' return phase def sortedDevices(self, phase): list = self.dmesg[phase]['list'] return sorted(list, key=lambda k:list[k]['start']) def fixupInitcalls(self, phase): # if any calls never returned, clip them at system resume end phaselist = self.dmesg[phase]['list'] for devname in phaselist: dev = phaselist[devname] if(dev['end'] < 0): for p in self.sortedPhases(): if self.dmesg[p]['end'] > dev['start']: dev['end'] = self.dmesg[p]['end'] break sysvals.vprint('%s (%s): callback didnt return' % (devname, phase)) def deviceFilter(self, devicefilter): for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] rmlist = [] for name in list: keep = False for filter in devicefilter: if filter in name or \ ('drv' in list[name] and filter in list[name]['drv']): keep = True if not keep: rmlist.append(name) for name in rmlist: del list[name] def fixupInitcallsThatDidntReturn(self): # if any calls never returned, clip them at system resume end for phase in self.sortedPhases(): self.fixupInitcalls(phase) def phaseOverlap(self, phases): rmgroups = [] newgroup = [] for group in self.devicegroups: for phase in phases: if phase not in group: continue for p in group: if p not in newgroup: newgroup.append(p) if group not in rmgroups: rmgroups.append(group) for group in rmgroups: self.devicegroups.remove(group) self.devicegroups.append(newgroup) def newActionGlobal(self, name, start, end, pid=-1, color=''): # which phase is this device callback or action in phases = self.sortedPhases() targetphase = 'none' htmlclass = '' overlap = 0.0 myphases = [] for phase in phases: pstart = self.dmesg[phase]['start'] pend = self.dmesg[phase]['end'] # see if the action overlaps this phase o = max(0, min(end, pend) - max(start, pstart)) if o > 0: myphases.append(phase) # set the target phase to the one that overlaps most if o > overlap: if overlap > 0 and phase == 'post_resume': continue targetphase = phase overlap = o # if no target phase was found, pin it to the edge if targetphase == 'none': p0start = self.dmesg[phases[0]]['start'] if start <= p0start: targetphase = phases[0] else: targetphase = phases[-1] if pid == -2: htmlclass = ' bg' elif pid == -3: htmlclass = ' ps' if len(myphases) > 1: htmlclass = ' bg' self.phaseOverlap(myphases) if targetphase in phases: newname = self.newAction(targetphase, name, pid, '', start, end, '', htmlclass, color) return (targetphase, newname) return False def newAction(self, phase, name, pid, parent, start, end, drv, htmlclass='', color=''): # new device callback for a specific phase self.html_device_id += 1 devid = '%s%d' % (self.idstr, self.html_device_id) list = self.dmesg[phase]['list'] length = -1.0 if(start >= 0 and end >= 0): length = end - start if pid == -2: i = 2 origname = name while(name in list): name = '%s[%d]' % (origname, i) i += 1 list[name] = {'name': name, 'start': start, 'end': end, 'pid': pid, 'par': parent, 'length': length, 'row': 0, 'id': devid, 'drv': drv } if htmlclass: list[name]['htmlclass'] = htmlclass if color: list[name]['color'] = color return name def deviceChildren(self, devname, phase): devlist = [] list = self.dmesg[phase]['list'] for child in list: if(list[child]['par'] == devname): devlist.append(child) return devlist def maxDeviceNameSize(self, phase): size = 0 for name in self.dmesg[phase]['list']: if len(name) > size: size = len(name) return size def printDetails(self): sysvals.vprint('Timeline Details:') sysvals.vprint(' test start: %f' % self.start) sysvals.vprint('kernel suspend start: %f' % self.tKernSus) tS = tR = False for phase in self.sortedPhases(): devlist = self.dmesg[phase]['list'] dc, ps, pe = len(devlist), self.dmesg[phase]['start'], self.dmesg[phase]['end'] if not tS and ps >= self.tSuspended: sysvals.vprint(' machine suspended: %f' % self.tSuspended) tS = True if not tR and ps >= self.tResumed: sysvals.vprint(' machine resumed: %f' % self.tResumed) tR = True sysvals.vprint('%20s: %f - %f (%d devices)' % (phase, ps, pe, dc)) if sysvals.devdump: sysvals.vprint(''.join('-' for i in range(80))) maxname = '%d' % self.maxDeviceNameSize(phase) fmt = '%3d) %'+maxname+'s - %f - %f' c = 1 for name in sorted(devlist): s = devlist[name]['start'] e = devlist[name]['end'] sysvals.vprint(fmt % (c, name, s, e)) c += 1 sysvals.vprint(''.join('-' for i in range(80))) sysvals.vprint(' kernel resume end: %f' % self.tKernRes) sysvals.vprint(' test end: %f' % self.end) def deviceChildrenAllPhases(self, devname): devlist = [] for phase in self.sortedPhases(): list = self.deviceChildren(devname, phase) for dev in sorted(list): if dev not in devlist: devlist.append(dev) return devlist def masterTopology(self, name, list, depth): node = DeviceNode(name, depth) for cname in list: # avoid recursions if name == cname: continue clist = self.deviceChildrenAllPhases(cname) cnode = self.masterTopology(cname, clist, depth+1) node.children.append(cnode) return node def printTopology(self, node): html = '' if node.name: info = '' drv = '' for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] if node.name in list: s = list[node.name]['start'] e = list[node.name]['end'] if list[node.name]['drv']: drv = ' {'+list[node.name]['drv']+'}' info += ('

  • %s: %.3fms
    • ' % (phase, (e-s)*1000)) html += '
  • '+node.name+drv+'' if info: html += '
      '+info+'
    ' html += '
    • ' if len(node.children) > 0: html += '
      ' for cnode in node.children: html += self.printTopology(cnode) html += '
    ' return html def rootDeviceList(self): # list of devices graphed real = [] for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] for dev in sorted(list): if list[dev]['pid'] >= 0 and dev not in real: real.append(dev) # list of top-most root devices rootlist = [] for phase in self.sortedPhases(): list = self.dmesg[phase]['list'] for dev in sorted(list): pdev = list[dev]['par'] pid = list[dev]['pid'] if(pid < 0 or re.match('[0-9]*-[0-9]*\.[0-9]*[\.0-9]*\:[\.0-9]*$', pdev)): continue if pdev and pdev not in real and pdev not in rootlist: rootlist.append(pdev) return rootlist def deviceTopology(self): rootlist = self.rootDeviceList() master = self.masterTopology('', rootlist, 0) return self.printTopology(master) def selectTimelineDevices(self, widfmt, tTotal, mindevlen): # only select devices that will actually show up in html self.tdevlist = dict() for phase in self.dmesg: devlist = [] list = self.dmesg[phase]['list'] for dev in list: length = (list[dev]['end'] - list[dev]['start']) * 1000 width = widfmt % (((list[dev]['end']-list[dev]['start'])*100)/tTotal) if width != '0.000000' and length >= mindevlen: devlist.append(dev) self.tdevlist[phase] = devlist def addHorizontalDivider(self, devname, devend): phase = 'suspend_prepare' self.newAction(phase, devname, -2, '', \ self.start, devend, '', ' sec', '') if phase not in self.tdevlist: self.tdevlist[phase] = [] self.tdevlist[phase].append(devname) d = DevItem(0, phase, self.dmesg[phase]['list'][devname]) return d def addProcessUsageEvent(self, name, times): # get the start and end times for this process maxC = 0 tlast = 0 start = -1 end = -1 for t in sorted(times): if tlast == 0: tlast = t continue if name in self.pstl[t]: if start == -1 or tlast < start: start = tlast if end == -1 or t > end: end = t tlast = t if start == -1 or end == -1: return 0 # add a new action for this process and get the object out = self.newActionGlobal(name, start, end, -3) if not out: return 0 phase, devname = out dev = self.dmesg[phase]['list'][devname] # get the cpu exec data tlast = 0 clast = 0 cpuexec = dict() for t in sorted(times): if tlast == 0 or t <= start or t > end: tlast = t continue list = self.pstl[t] c = 0 if name in list: c = list[name] if c > maxC: maxC = c if c != clast: key = (tlast, t) cpuexec[key] = c tlast = t clast = c dev['cpuexec'] = cpuexec return maxC def createProcessUsageEvents(self): # get an array of process names proclist = [] for t in sorted(self.pstl): pslist = self.pstl[t] for ps in sorted(pslist): if ps not in proclist: proclist.append(ps) # get a list of data points for suspend and resume tsus = [] tres = [] for t in sorted(self.pstl): if t < self.tSuspended: tsus.append(t) else: tres.append(t) # process the events for suspend and resume if len(proclist) > 0: sysvals.vprint('Process Execution:') for ps in proclist: c = self.addProcessUsageEvent(ps, tsus) if c > 0: sysvals.vprint('%25s (sus): %d' % (ps, c)) c = self.addProcessUsageEvent(ps, tres) if c > 0: sysvals.vprint('%25s (res): %d' % (ps, c)) def handleEndMarker(self, time): dm = self.dmesg self.setEnd(time) self.initDevicegroups() # give suspend_prepare an end if needed if 'suspend_prepare' in dm and dm['suspend_prepare']['end'] < 0: dm['suspend_prepare']['end'] = time # assume resume machine ends at next phase start if 'resume_machine' in dm and dm['resume_machine']['end'] < 0: np = self.nextPhase('resume_machine', 1) if np: dm['resume_machine']['end'] = dm[np]['start'] # if kernel resume end not found, assume its the end marker if self.tKernRes == 0.0: self.tKernRes = time # if kernel suspend start not found, assume its the end marker if self.tKernSus == 0.0: self.tKernSus = time # set resume complete to end at end marker if 'resume_complete' in dm: dm['resume_complete']['end'] = time def debugPrint(self): for p in self.sortedPhases(): list = self.dmesg[p]['list'] for devname in sorted(list): dev = list[devname] if 'ftrace' in dev: dev['ftrace'].debugPrint(' [%s]' % devname) # Class: DevFunction # Description: # A container for kprobe function data we want in the dev timeline class DevFunction: def __init__(self, name, args, caller, ret, start, end, u, proc, pid, color): self.row = 0 self.count = 1 self.name = name self.args = args self.caller = caller self.ret = ret self.time = start self.length = end - start self.end = end self.ubiquitous = u self.proc = proc self.pid = pid self.color = color def title(self): cnt = '' if self.count > 1: cnt = '(x%d)' % self.count l = '%0.3fms' % (self.length * 1000) if self.ubiquitous: title = '%s(%s)%s <- %s, %s(%s)' % \ (self.name, self.args, cnt, self.caller, self.ret, l) else: title = '%s(%s) %s%s(%s)' % (self.name, self.args, self.ret, cnt, l) return title.replace('"', '') def text(self): if self.count > 1: text = '%s(x%d)' % (self.name, self.count) else: text = self.name return text def repeat(self, tgt): # is the tgt call just a repeat of this call (e.g. are we in a loop) dt = self.time - tgt.end # only combine calls if -all- attributes are identical if tgt.caller == self.caller and \ tgt.name == self.name and tgt.args == self.args and \ tgt.proc == self.proc and tgt.pid == self.pid and \ tgt.ret == self.ret and dt >= 0 and \ dt <= sysvals.callloopmaxgap and \ self.length < sysvals.callloopmaxlen: return True return False # Class: FTraceLine # Description: # A container for a single line of ftrace data. There are six basic types: # callgraph line: # call: " dpm_run_callback() {" # return: " }" # leaf: " dpm_run_callback();" # trace event: # tracing_mark_write: SUSPEND START or RESUME COMPLETE # suspend_resume: phase or custom exec block data # device_pm_callback: device callback info class FTraceLine: def __init__(self, t, m='', d=''): self.length = 0.0 self.fcall = False self.freturn = False self.fevent = False self.fkprobe = False self.depth = 0 self.name = '' self.type = '' self.time = float(t) if not m and not d: return # is this a trace event if(d == 'traceevent' or re.match('^ *\/\* *(?P.*) \*\/ *$', m)): if(d == 'traceevent'): # nop format trace event msg = m else: # function_graph format trace event em = re.match('^ *\/\* *(?P.*) \*\/ *$', m) msg = em.group('msg') emm = re.match('^(?P.*?): (?P.*)', msg) if(emm): self.name = emm.group('msg') self.type = emm.group('call') else: self.name = msg km = re.match('^(?P.*)_cal$', self.type) if km: self.fcall = True self.fkprobe = True self.type = km.group('n') return km = re.match('^(?P.*)_ret$', self.type) if km: self.freturn = True self.fkprobe = True self.type = km.group('n') return self.fevent = True return # convert the duration to seconds if(d): self.length = float(d)/1000000 # the indentation determines the depth match = re.match('^(?P *)(?P.*)$', m) if(not match): return self.depth = self.getDepth(match.group('d')) m = match.group('o') # function return if(m[0] == '}'): self.freturn = True if(len(m) > 1): # includes comment with function name match = re.match('^} *\/\* *(?P.*) *\*\/$', m) if(match): self.name = match.group('n').strip() # function call else: self.fcall = True # function call with children if(m[-1] == '{'): match = re.match('^(?P.*) *\(.*', m) if(match): self.name = match.group('n').strip() # function call with no children (leaf) elif(m[-1] == ';'): self.freturn = True match = re.match('^(?P.*) *\(.*', m) if(match): self.name = match.group('n').strip() # something else (possibly a trace marker) else: self.name = m def isCall(self): return self.fcall and not self.freturn def isReturn(self): return self.freturn and not self.fcall def isLeaf(self): return self.fcall and self.freturn def getDepth(self, str): return len(str)/2 def debugPrint(self, info=''): if self.isLeaf(): pprint(' -- %12.6f (depth=%02d): %s(); (%.3f us) %s' % (self.time, \ self.depth, self.name, self.length*1000000, info)) elif self.freturn: pprint(' -- %12.6f (depth=%02d): %s} (%.3f us) %s' % (self.time, \ self.depth, self.name, self.length*1000000, info)) else: pprint(' -- %12.6f (depth=%02d): %s() { (%.3f us) %s' % (self.time, \ self.depth, self.name, self.length*1000000, info)) def startMarker(self): # Is this the starting line of a suspend? if not self.fevent: return False if sysvals.usetracemarkers: if(self.name == 'SUSPEND START'): return True return False else: if(self.type == 'suspend_resume' and re.match('suspend_enter\[.*\] begin', self.name)): return True return False def endMarker(self): # Is this the ending line of a resume? if not self.fevent: return False if sysvals.usetracemarkers: if(self.name == 'RESUME COMPLETE'): return True return False else: if(self.type == 'suspend_resume' and re.match('thaw_processes\[.*\] end', self.name)): return True return False # Class: FTraceCallGraph # Description: # A container for the ftrace callgraph of a single recursive function. # This can be a dpm_run_callback, dpm_prepare, or dpm_complete callgraph # Each instance is tied to a single device in a single phase, and is # comprised of an ordered list of FTraceLine objects class FTraceCallGraph: vfname = 'missing_function_name' def __init__(self, pid, sv): self.id = '' self.invalid = False self.name = '' self.partial = False self.ignore = False self.start = -1.0 self.end = -1.0 self.list = [] self.depth = 0 self.pid = pid self.sv = sv def addLine(self, line): # if this is already invalid, just leave if(self.invalid): if(line.depth == 0 and line.freturn): return 1 return 0 # invalidate on bad depth if(self.depth < 0): self.invalidate(line) return 0 # ignore data til we return to the current depth if self.ignore: if line.depth > self.depth: return 0 else: self.list[-1].freturn = True self.list[-1].length = line.time - self.list[-1].time self.ignore = False # if this is a return at self.depth, no more work is needed if line.depth == self.depth and line.isReturn(): if line.depth == 0: self.end = line.time return 1 return 0 # compare current depth with this lines pre-call depth prelinedep = line.depth if line.isReturn(): prelinedep += 1 last = 0 lasttime = line.time if len(self.list) > 0: last = self.list[-1] lasttime = last.time if last.isLeaf(): lasttime += last.length # handle low misalignments by inserting returns mismatch = prelinedep - self.depth warning = self.sv.verbose and abs(mismatch) > 1 info = [] if mismatch < 0: idx = 0 # add return calls to get the depth down while prelinedep < self.depth: self.depth -= 1 if idx == 0 and last and last.isCall(): # special case, turn last call into a leaf last.depth = self.depth last.freturn = True last.length = line.time - last.time if warning: info.append(('[make leaf]', last)) else: vline = FTraceLine(lasttime) vline.depth = self.depth vline.name = self.vfname vline.freturn = True self.list.append(vline) if warning: if idx == 0: info.append(('', last)) info.append(('[add return]', vline)) idx += 1 if warning: info.append(('', line)) # handle high misalignments by inserting calls elif mismatch > 0: idx = 0 if warning: info.append(('', last)) # add calls to get the depth up while prelinedep > self.depth: if idx == 0 and line.isReturn(): # special case, turn this return into a leaf line.fcall = True prelinedep -= 1 if warning: info.append(('[make leaf]', line)) else: vline = FTraceLine(lasttime) vline.depth = self.depth vline.name = self.vfname vline.fcall = True self.list.append(vline) self.depth += 1 if not last: self.start = vline.time if warning: info.append(('[add call]', vline)) idx += 1 if warning and ('[make leaf]', line) not in info: info.append(('', line)) if warning: pprint('WARNING: ftrace data missing, corrections made:') for i in info: t, obj = i if obj: obj.debugPrint(t) # process the call and set the new depth skipadd = False md = self.sv.max_graph_depth if line.isCall(): # ignore blacklisted/overdepth funcs if (md and self.depth >= md - 1) or (line.name in self.sv.cgblacklist): self.ignore = True else: self.depth += 1 elif line.isReturn(): self.depth -= 1 # remove blacklisted/overdepth/empty funcs that slipped through if (last and last.isCall() and last.depth == line.depth) or \ (md and last and last.depth >= md) or \ (line.name in self.sv.cgblacklist): while len(self.list) > 0 and self.list[-1].depth > line.depth: self.list.pop(-1) if len(self.list) == 0: self.invalid = True return 1 self.list[-1].freturn = True self.list[-1].length = line.time - self.list[-1].time self.list[-1].name = line.name skipadd = True if len(self.list) < 1: self.start = line.time # check for a mismatch that returned all the way to callgraph end res = 1 if mismatch < 0 and self.list[-1].depth == 0 and self.list[-1].freturn: line = self.list[-1] skipadd = True res = -1 if not skipadd: self.list.append(line) if(line.depth == 0 and line.freturn): if(self.start < 0): self.start = line.time self.end = line.time if line.fcall: self.end += line.length if self.list[0].name == self.vfname: self.invalid = True if res == -1: self.partial = True return res return 0 def invalidate(self, line): if(len(self.list) > 0): first = self.list[0] self.list = [] self.list.append(first) self.invalid = True id = 'task %s' % (self.pid) window = '(%f - %f)' % (self.start, line.time) if(self.depth < 0): pprint('Data misalignment for '+id+\ ' (buffer overflow), ignoring this callback') else: pprint('Too much data for '+id+\ ' '+window+', ignoring this callback') def slice(self, dev): minicg = FTraceCallGraph(dev['pid'], self.sv) minicg.name = self.name mydepth = -1 good = False for l in self.list: if(l.time < dev['start'] or l.time > dev['end']): continue if mydepth < 0: if l.name == 'mutex_lock' and l.freturn: mydepth = l.depth continue elif l.depth == mydepth and l.name == 'mutex_unlock' and l.fcall: good = True break l.depth -= mydepth minicg.addLine(l) if not good or len(minicg.list) < 1: return 0 return minicg def repair(self, enddepth): # bring the depth back to 0 with additional returns fixed = False last = self.list[-1] for i in reversed(range(enddepth)): t = FTraceLine(last.time) t.depth = i t.freturn = True fixed = self.addLine(t) if fixed != 0: self.end = last.time return True return False def postProcess(self): if len(self.list) > 0: self.name = self.list[0].name stack = dict() cnt = 0 last = 0 for l in self.list: # ftrace bug: reported duration is not reliable # check each leaf and clip it at max possible length if last and last.isLeaf(): if last.length > l.time - last.time: last.length = l.time - last.time if l.isCall(): stack[l.depth] = l cnt += 1 elif l.isReturn(): if(l.depth not in stack): if self.sv.verbose: pprint('Post Process Error: Depth missing') l.debugPrint() return False # calculate call length from call/return lines cl = stack[l.depth] cl.length = l.time - cl.time if cl.name == self.vfname: cl.name = l.name stack.pop(l.depth) l.length = 0 cnt -= 1 last = l if(cnt == 0): # trace caught the whole call tree return True elif(cnt < 0): if self.sv.verbose: pprint('Post Process Error: Depth is less than 0') return False # trace ended before call tree finished return self.repair(cnt) def deviceMatch(self, pid, data): found = '' # add the callgraph data to the device hierarchy borderphase = { 'dpm_prepare': 'suspend_prepare', 'dpm_complete': 'resume_complete' } if(self.name in borderphase): p = borderphase[self.name] list = data.dmesg[p]['list'] for devname in list: dev = list[devname] if(pid == dev['pid'] and self.start <= dev['start'] and self.end >= dev['end']): cg = self.slice(dev) if cg: dev['ftrace'] = cg found = devname return found for p in data.sortedPhases(): if(data.dmesg[p]['start'] <= self.start and self.start <= data.dmesg[p]['end']): list = data.dmesg[p]['list'] for devname in sorted(list, key=lambda k:list[k]['start']): dev = list[devname] if(pid == dev['pid'] and self.start <= dev['start'] and self.end >= dev['end']): dev['ftrace'] = self found = devname break break return found def newActionFromFunction(self, data): name = self.name if name in ['dpm_run_callback', 'dpm_prepare', 'dpm_complete']: return fs = self.start fe = self.end if fs < data.start or fe > data.end: return phase = '' for p in data.sortedPhases(): if(data.dmesg[p]['start'] <= self.start and self.start < data.dmesg[p]['end']): phase = p break if not phase: return out = data.newActionGlobal(name, fs, fe, -2) if out: phase, myname = out data.dmesg[phase]['list'][myname]['ftrace'] = self def debugPrint(self, info=''): pprint('%s pid=%d [%f - %f] %.3f us' % \ (self.name, self.pid, self.start, self.end, (self.end - self.start)*1000000)) for l in self.list: if l.isLeaf(): pprint('%f (%02d): %s(); (%.3f us)%s' % (l.time, \ l.depth, l.name, l.length*1000000, info)) elif l.freturn: pprint('%f (%02d): %s} (%.3f us)%s' % (l.time, \ l.depth, l.name, l.length*1000000, info)) else: pprint('%f (%02d): %s() { (%.3f us)%s' % (l.time, \ l.depth, l.name, l.length*1000000, info)) pprint(' ') class DevItem: def __init__(self, test, phase, dev): self.test = test self.phase = phase self.dev = dev def isa(self, cls): if 'htmlclass' in self.dev and cls in self.dev['htmlclass']: return True return False # Class: Timeline # Description: # A container for a device timeline which calculates # all the html properties to display it correctly class Timeline: html_tblock = '
    \n' html_device = '
    {6}
    \n' html_phase = '
    {5}
    \n' html_phaselet = '
    \n' html_legend = '
     {2}
    \n' def __init__(self, rowheight, scaleheight): self.html = '' self.height = 0 # total timeline height self.scaleH = scaleheight # timescale (top) row height self.rowH = rowheight # device row height self.bodyH = 0 # body height self.rows = 0 # total timeline rows self.rowlines = dict() self.rowheight = dict() def createHeader(self, sv, stamp): if(not stamp['time']): return self.html += '
    %s v%s
    ' \ % (sv.title, sv.version) if sv.logmsg and sv.testlog: self.html += '' if sv.dmesglog: self.html += '' if sv.ftracelog: self.html += '' headline_stamp = '
    {0} {1} {2} {3}
    \n' self.html += headline_stamp.format(stamp['host'], stamp['kernel'], stamp['mode'], stamp['time']) if 'man' in stamp and 'plat' in stamp and 'cpu' in stamp and \ stamp['man'] and stamp['plat'] and stamp['cpu']: headline_sysinfo = '
    {0} {1} with {2}
    \n' self.html += headline_sysinfo.format(stamp['man'], stamp['plat'], stamp['cpu']) # Function: getDeviceRows # Description: # determine how may rows the device funcs will take # Arguments: # rawlist: the list of devices/actions for a single phase # Output: # The total number of rows needed to display this phase of the timeline def getDeviceRows(self, rawlist): # clear all rows and set them to undefined sortdict = dict() for item in rawlist: item.row = -1 sortdict[item] = item.length sortlist = sorted(sortdict, key=sortdict.get, reverse=True) remaining = len(sortlist) rowdata = dict() row = 1 # try to pack each row with as many ranges as possible while(remaining > 0): if(row not in rowdata): rowdata[row] = [] for i in sortlist: if(i.row >= 0): continue s = i.time e = i.time + i.length valid = True for ritem in rowdata[row]: rs = ritem.time re = ritem.time + ritem.length if(not (((s <= rs) and (e <= rs)) or ((s >= re) and (e >= re)))): valid = False break if(valid): rowdata[row].append(i) i.row = row remaining -= 1 row += 1 return row # Function: getPhaseRows # Description: # Organize the timeline entries into the smallest # number of rows possible, with no entry overlapping # Arguments: # devlist: the list of devices/actions in a group of contiguous phases # Output: # The total number of rows needed to display this phase of the timeline def getPhaseRows(self, devlist, row=0, sortby='length'): # clear all rows and set them to undefined remaining = len(devlist) rowdata = dict() sortdict = dict() myphases = [] # initialize all device rows to -1 and calculate devrows for item in devlist: dev = item.dev tp = (item.test, item.phase) if tp not in myphases: myphases.append(tp) dev['row'] = -1 if sortby == 'start': # sort by start 1st, then length 2nd sortdict[item] = (-1*float(dev['start']), float(dev['end']) - float(dev['start'])) else: # sort by length 1st, then name 2nd sortdict[item] = (float(dev['end']) - float(dev['start']), item.dev['name']) if 'src' in dev: dev['devrows'] = self.getDeviceRows(dev['src']) # sort the devlist by length so that large items graph on top sortlist = sorted(sortdict, key=sortdict.get, reverse=True) orderedlist = [] for item in sortlist: if item.dev['pid'] == -2: orderedlist.append(item) for item in sortlist: if item not in orderedlist: orderedlist.append(item) # try to pack each row with as many devices as possible while(remaining > 0): rowheight = 1 if(row not in rowdata): rowdata[row] = [] for item in orderedlist: dev = item.dev if(dev['row'] < 0): s = dev['start'] e = dev['end'] valid = True for ritem in rowdata[row]: rs = ritem.dev['start'] re = ritem.dev['end'] if(not (((s <= rs) and (e <= rs)) or ((s >= re) and (e >= re)))): valid = False break if(valid): rowdata[row].append(item) dev['row'] = row remaining -= 1 if 'devrows' in dev and dev['devrows'] > rowheight: rowheight = dev['devrows'] for t, p in myphases: if t not in self.rowlines or t not in self.rowheight: self.rowlines[t] = dict() self.rowheight[t] = dict() if p not in self.rowlines[t] or p not in self.rowheight[t]: self.rowlines[t][p] = dict() self.rowheight[t][p] = dict() rh = self.rowH # section headers should use a different row height if len(rowdata[row]) == 1 and \ 'htmlclass' in rowdata[row][0].dev and \ 'sec' in rowdata[row][0].dev['htmlclass']: rh = 15 self.rowlines[t][p][row] = rowheight self.rowheight[t][p][row] = rowheight * rh row += 1 if(row > self.rows): self.rows = int(row) return row def phaseRowHeight(self, test, phase, row): return self.rowheight[test][phase][row] def phaseRowTop(self, test, phase, row): top = 0 for i in sorted(self.rowheight[test][phase]): if i >= row: break top += self.rowheight[test][phase][i] return top def calcTotalRows(self): # Calculate the heights and offsets for the header and rows maxrows = 0 standardphases = [] for t in self.rowlines: for p in self.rowlines[t]: total = 0 for i in sorted(self.rowlines[t][p]): total += self.rowlines[t][p][i] if total > maxrows: maxrows = total if total == len(self.rowlines[t][p]): standardphases.append((t, p)) self.height = self.scaleH + (maxrows*self.rowH) self.bodyH = self.height - self.scaleH # if there is 1 line per row, draw them the standard way for t, p in standardphases: for i in sorted(self.rowheight[t][p]): self.rowheight[t][p][i] = float(self.bodyH)/len(self.rowlines[t][p]) def createZoomBox(self, mode='command', testcount=1): # Create bounding box, add buttons html_zoombox = '
    \n' html_timeline = '
    \n
    \n' html_devlist1 = '' html_devlist2 = '\n' if mode != 'command': if testcount > 1: self.html += html_devlist2 self.html += html_devlist1.format('1') else: self.html += html_devlist1.format('') self.html += html_zoombox self.html += html_timeline.format('dmesg', self.height) # Function: createTimeScale # Description: # Create the timescale for a timeline block # Arguments: # m0: start time (mode begin) # mMax: end time (mode end) # tTotal: total timeline time # mode: suspend or resume # Output: # The html code needed to display the time scale def createTimeScale(self, m0, mMax, tTotal, mode): timescale = '
    {1}
    \n' rline = '
    {0}
    \n' output = '
    \n' # set scale for timeline mTotal = mMax - m0 tS = 0.1 if(tTotal <= 0): return output+'
    \n' if(tTotal > 4): tS = 1 divTotal = int(mTotal/tS) + 1 divEdge = (mTotal - tS*(divTotal-1))*100/mTotal for i in range(divTotal): htmlline = '' if(mode == 'suspend'): pos = '%0.3f' % (100 - ((float(i)*tS*100)/mTotal) - divEdge) val = '%0.fms' % (float(i-divTotal+1)*tS*1000) if(i == divTotal - 1): val = mode htmlline = timescale.format(pos, val) else: pos = '%0.3f' % (100 - ((float(i)*tS*100)/mTotal)) val = '%0.fms' % (float(i)*tS*1000) htmlline = timescale.format(pos, val) if(i == 0): htmlline = rline.format(mode) output += htmlline self.html += output+'
    \n' # Class: TestProps # Description: # A list of values describing the properties of these test runs class TestProps: stampfmt = '# [a-z]*-(?P[0-9]{2})(?P[0-9]{2})(?P[0-9]{2})-'+\ '(?P[0-9]{2})(?P[0-9]{2})(?P[0-9]{2})'+\ ' (?P.*) (?P.*) (?P.*)$' batteryfmt = '^# battery (?P\w*) (?P\d*) (?P\w*) (?P\d*)' wififmt = '^# wifi (?P.*)' tstatfmt = '^# turbostat (?P\S*)' mcelogfmt = '^# mcelog (?P\S*)' testerrfmt = '^# enter_sleep_error (?P.*)' sysinfofmt = '^# sysinfo .*' cmdlinefmt = '^# command \| (?P.*)' kparamsfmt = '^# kparams \| (?P.*)' devpropfmt = '# Device Properties: .*' pinfofmt = '# platform-(?P[a-z,A-Z,0-9]*): (?P.*)' tracertypefmt = '# tracer: (?P.*)' firmwarefmt = '# fwsuspend (?P[0-9]*) fwresume (?P[0-9]*)$' procexecfmt = 'ps - (?P.*)$' ftrace_line_fmt_fg = \ '^ *(?P
    \n' # timeline is finished devtl.html += '
    \n\n' # draw a legend which describes the phases by color if sysvals.suspendmode != 'command': phasedef = testruns[-1].phasedef devtl.html += '
    \n' pdelta = 100.0/len(phasedef.keys()) pmargin = pdelta / 4.0 for phase in sorted(phasedef, key=lambda k:phasedef[k]['order']): id, p = '', phasedef[phase] for word in phase.split('_'): id += word[0] order = '%.2f' % ((p['order'] * pdelta) + pmargin) name = phase.replace('_', '  ') devtl.html += devtl.html_legend.format(order, p['color'], name, id) devtl.html += '
    \n' hf = open(sysvals.htmlfile, 'w') addCSS(hf, sysvals, len(testruns), kerror) # write the device timeline hf.write(devtl.html) hf.write('
    \n') hf.write('\n') # write the ftrace data (callgraph) if sysvals.cgtest >= 0 and len(testruns) > sysvals.cgtest: data = testruns[sysvals.cgtest] else: data = testruns[-1] if sysvals.usecallgraph: addCallgraphs(sysvals, hf, data) # add the test log as a hidden div if sysvals.testlog and sysvals.logmsg: hf.write('\n') # add the dmesg log as a hidden div if sysvals.dmesglog and sysvals.dmesgfile: hf.write('\n') # add the ftrace log as a hidden div if sysvals.ftracelog and sysvals.ftracefile: hf.write('\n') # write the footer and close addScriptCode(hf, testruns) hf.write('\n\n') hf.close() return True def addCSS(hf, sv, testcount=1, kerror=False, extra=''): kernel = sv.stamp['kernel'] host = sv.hostname[0].upper()+sv.hostname[1:] mode = sv.suspendmode if sv.suspendmode in suspendmodename: mode = suspendmodename[sv.suspendmode] title = host+' '+mode+' '+kernel # various format changes by flags cgchk = 'checked' cgnchk = 'not(:checked)' if sv.cgexp: cgchk = 'not(:checked)' cgnchk = 'checked' hoverZ = 'z-index:8;' if sv.usedevsrc: hoverZ = '' devlistpos = 'absolute' if testcount > 1: devlistpos = 'relative' scaleTH = 20 if kerror: scaleTH = 60 # write the html header first (html head, css code, up to body start) html_header = '\n\n\n\ \n\ '+title+'\n\ \n\n\n' hf.write(html_header) # Function: addScriptCode # Description: # Adds the javascript code to the output html # Arguments: # hf: the open html file pointer # testruns: array of Data objects from parseKernelLog or parseTraceLog def addScriptCode(hf, testruns): t0 = testruns[0].start * 1000 tMax = testruns[-1].end * 1000 # create an array in javascript memory with the device details detail = ' var devtable = [];\n' for data in testruns: topo = data.deviceTopology() detail += ' devtable[%d] = "%s";\n' % (data.testnumber, topo) detail += ' var bounds = [%f,%f];\n' % (t0, tMax) # add the code which will manipulate the data in the browser script_code = \ '\n' hf.write(script_code); def setRuntimeSuspend(before=True): global sysvals sv = sysvals if sv.rs == 0: return if before: # runtime suspend disable or enable if sv.rs > 0: sv.rstgt, sv.rsval, sv.rsdir = 'on', 'auto', 'enabled' else: sv.rstgt, sv.rsval, sv.rsdir = 'auto', 'on', 'disabled' pprint('CONFIGURING RUNTIME SUSPEND...') sv.rslist = deviceInfo(sv.rstgt) for i in sv.rslist: sv.setVal(sv.rsval, i) pprint('runtime suspend %s on all devices (%d changed)' % (sv.rsdir, len(sv.rslist))) pprint('waiting 5 seconds...') time.sleep(5) else: # runtime suspend re-enable or re-disable for i in sv.rslist: sv.setVal(sv.rstgt, i) pprint('runtime suspend settings restored on %d devices' % len(sv.rslist)) # Function: executeSuspend # Description: # Execute system suspend through the sysfs interface, then copy the output # dmesg and ftrace files to the test output directory. def executeSuspend(): pm = ProcessMonitor() tp = sysvals.tpath wifi = sysvals.checkWifi() testdata = [] battery = True if getBattery() else False # run these commands to prepare the system for suspend if sysvals.display: pprint('SET DISPLAY TO %s' % sysvals.display.upper()) displayControl(sysvals.display) time.sleep(1) if sysvals.sync: pprint('SYNCING FILESYSTEMS') call('sync', shell=True) # mark the start point in the kernel ring buffer just as we start sysvals.initdmesg() # start ftrace if(sysvals.usecallgraph or sysvals.usetraceevents): pprint('START TRACING') sysvals.fsetVal('1', 'tracing_on') if sysvals.useprocmon: pm.start() # execute however many s/r runs requested for count in range(1,sysvals.execcount+1): # x2delay in between test runs if(count > 1 and sysvals.x2delay > 0): sysvals.fsetVal('WAIT %d' % sysvals.x2delay, 'trace_marker') time.sleep(sysvals.x2delay/1000.0) sysvals.fsetVal('WAIT END', 'trace_marker') # start message if sysvals.testcommand != '': pprint('COMMAND START') else: if(sysvals.rtcwake): pprint('SUSPEND START') else: pprint('SUSPEND START (press a key to resume)') sysvals.mcelog(True) bat1 = getBattery() if battery else False # set rtcwake if(sysvals.rtcwake): pprint('will issue an rtcwake in %d seconds' % sysvals.rtcwaketime) sysvals.rtcWakeAlarmOn() # start of suspend trace marker if(sysvals.usecallgraph or sysvals.usetraceevents): sysvals.fsetVal('SUSPEND START', 'trace_marker') # predelay delay if(count == 1 and sysvals.predelay > 0): sysvals.fsetVal('WAIT %d' % sysvals.predelay, 'trace_marker') time.sleep(sysvals.predelay/1000.0) sysvals.fsetVal('WAIT END', 'trace_marker') # initiate suspend or command tdata = {'error': ''} if sysvals.testcommand != '': res = call(sysvals.testcommand+' 2>&1', shell=True); if res != 0: tdata['error'] = 'cmd returned %d' % res else: mode = sysvals.suspendmode if sysvals.memmode and os.path.exists(sysvals.mempowerfile): mode = 'mem' pf = open(sysvals.mempowerfile, 'w') pf.write(sysvals.memmode) pf.close() if sysvals.diskmode and os.path.exists(sysvals.diskpowerfile): mode = 'disk' pf = open(sysvals.diskpowerfile, 'w') pf.write(sysvals.diskmode) pf.close() if mode == 'freeze' and sysvals.haveTurbostat(): # execution will pause here turbo = sysvals.turbostat() if turbo: tdata['turbo'] = turbo else: pf = open(sysvals.powerfile, 'w') pf.write(mode) # execution will pause here try: pf.close() except Exception as e: tdata['error'] = str(e) if(sysvals.rtcwake): sysvals.rtcWakeAlarmOff() # postdelay delay if(count == sysvals.execcount and sysvals.postdelay > 0): sysvals.fsetVal('WAIT %d' % sysvals.postdelay, 'trace_marker') time.sleep(sysvals.postdelay/1000.0) sysvals.fsetVal('WAIT END', 'trace_marker') # return from suspend pprint('RESUME COMPLETE') if(sysvals.usecallgraph or sysvals.usetraceevents): sysvals.fsetVal('RESUME COMPLETE', 'trace_marker') if(sysvals.suspendmode == 'mem' or sysvals.suspendmode == 'command'): tdata['fw'] = getFPDT(False) mcelog = sysvals.mcelog() if mcelog: tdata['mcelog'] = mcelog bat2 = getBattery() if battery else False if battery and bat1 and bat2: tdata['bat'] = (bat1, bat2) if 'device' in wifi and 'ip' in wifi: tdata['wifi'] = (wifi, sysvals.checkWifi()) testdata.append(tdata) # stop ftrace if(sysvals.usecallgraph or sysvals.usetraceevents): if sysvals.useprocmon: pm.stop() sysvals.fsetVal('0', 'tracing_on') # grab a copy of the dmesg output pprint('CAPTURING DMESG') sysvals.getdmesg(testdata) # grab a copy of the ftrace output if(sysvals.usecallgraph or sysvals.usetraceevents): pprint('CAPTURING TRACE') op = sysvals.writeDatafileHeader(sysvals.ftracefile, testdata) fp = open(tp+'trace', 'r') for line in fp: op.write(line) op.close() sysvals.fsetVal('', 'trace') sysvals.platforminfo() return testdata def readFile(file): if os.path.islink(file): return os.readlink(file).split('/')[-1] else: return sysvals.getVal(file).strip() # Function: ms2nice # Description: # Print out a very concise time string in minutes and seconds # Output: # The time string, e.g. "1901m16s" def ms2nice(val): val = int(val) h = val // 3600000 m = (val // 60000) % 60 s = (val // 1000) % 60 if h > 0: return '%d:%02d:%02d' % (h, m, s) if m > 0: return '%02d:%02d' % (m, s) return '%ds' % s def yesno(val): list = {'enabled':'A', 'disabled':'S', 'auto':'E', 'on':'D', 'active':'A', 'suspended':'S', 'suspending':'S'} if val not in list: return ' ' return list[val] # Function: deviceInfo # Description: # Detect all the USB hosts and devices currently connected and add # a list of USB device names to sysvals for better timeline readability def deviceInfo(output=''): if not output: pprint('LEGEND\n'\ '---------------------------------------------------------------------------------------------\n'\ ' A = async/sync PM queue (A/S) C = runtime active children\n'\ ' R = runtime suspend enabled/disabled (E/D) rACTIVE = runtime active (min/sec)\n'\ ' S = runtime status active/suspended (A/S) rSUSPEND = runtime suspend (min/sec)\n'\ ' U = runtime usage count\n'\ '---------------------------------------------------------------------------------------------\n'\ 'DEVICE NAME A R S U C rACTIVE rSUSPEND\n'\ '---------------------------------------------------------------------------------------------') res = [] tgtval = 'runtime_status' lines = dict() for dirname, dirnames, filenames in os.walk('/sys/devices'): if(not re.match('.*/power', dirname) or 'control' not in filenames or tgtval not in filenames): continue name = '' dirname = dirname[:-6] device = dirname.split('/')[-1] power = dict() power[tgtval] = readFile('%s/power/%s' % (dirname, tgtval)) # only list devices which support runtime suspend if power[tgtval] not in ['active', 'suspended', 'suspending']: continue for i in ['product', 'driver', 'subsystem']: file = '%s/%s' % (dirname, i) if os.path.exists(file): name = readFile(file) break for i in ['async', 'control', 'runtime_status', 'runtime_usage', 'runtime_active_kids', 'runtime_active_time', 'runtime_suspended_time']: if i in filenames: power[i] = readFile('%s/power/%s' % (dirname, i)) if output: if power['control'] == output: res.append('%s/power/control' % dirname) continue lines[dirname] = '%-26s %-26s %1s %1s %1s %1s %1s %10s %10s' % \ (device[:26], name[:26], yesno(power['async']), \ yesno(power['control']), \ yesno(power['runtime_status']), \ power['runtime_usage'], \ power['runtime_active_kids'], \ ms2nice(power['runtime_active_time']), \ ms2nice(power['runtime_suspended_time'])) for i in sorted(lines): print(lines[i]) return res # Function: getModes # Description: # Determine the supported power modes on this system # Output: # A string list of the available modes def getModes(): modes = [] if(os.path.exists(sysvals.powerfile)): fp = open(sysvals.powerfile, 'r') modes = fp.read().split() fp.close() if(os.path.exists(sysvals.mempowerfile)): deep = False fp = open(sysvals.mempowerfile, 'r') for m in fp.read().split(): memmode = m.strip('[]') if memmode == 'deep': deep = True else: modes.append('mem-%s' % memmode) fp.close() if 'mem' in modes and not deep: modes.remove('mem') if('disk' in modes and os.path.exists(sysvals.diskpowerfile)): fp = open(sysvals.diskpowerfile, 'r') for m in fp.read().split(): modes.append('disk-%s' % m.strip('[]')) fp.close() return modes # Function: dmidecode # Description: # Read the bios tables and pull out system info # Arguments: # mempath: /dev/mem or custom mem path # fatal: True to exit on error, False to return empty dict # Output: # A dict object with all available key/values def dmidecode(mempath, fatal=False): out = dict() # the list of values to retrieve, with hardcoded (type, idx) info = { 'bios-vendor': (0, 4), 'bios-version': (0, 5), 'bios-release-date': (0, 8), 'system-manufacturer': (1, 4), 'system-product-name': (1, 5), 'system-version': (1, 6), 'system-serial-number': (1, 7), 'baseboard-manufacturer': (2, 4), 'baseboard-product-name': (2, 5), 'baseboard-version': (2, 6), 'baseboard-serial-number': (2, 7), 'chassis-manufacturer': (3, 4), 'chassis-type': (3, 5), 'chassis-version': (3, 6), 'chassis-serial-number': (3, 7), 'processor-manufacturer': (4, 7), 'processor-version': (4, 16), } if(not os.path.exists(mempath)): if(fatal): doError('file does not exist: %s' % mempath) return out if(not os.access(mempath, os.R_OK)): if(fatal): doError('file is not readable: %s' % mempath) return out # by default use legacy scan, but try to use EFI first memaddr = 0xf0000 memsize = 0x10000 for ep in ['/sys/firmware/efi/systab', '/proc/efi/systab']: if not os.path.exists(ep) or not os.access(ep, os.R_OK): continue fp = open(ep, 'r') buf = fp.read() fp.close() i = buf.find('SMBIOS=') if i >= 0: try: memaddr = int(buf[i+7:], 16) memsize = 0x20 except: continue # read in the memory for scanning try: fp = open(mempath, 'rb') fp.seek(memaddr) buf = fp.read(memsize) except: if(fatal): doError('DMI table is unreachable, sorry') else: pprint('WARNING: /dev/mem is not readable, ignoring DMI data') return out fp.close() # search for either an SM table or DMI table i = base = length = num = 0 while(i < memsize): if buf[i:i+4] == b'_SM_' and i < memsize - 16: length = struct.unpack('H', buf[i+22:i+24])[0] base, num = struct.unpack('IH', buf[i+24:i+30]) break elif buf[i:i+5] == b'_DMI_': length = struct.unpack('H', buf[i+6:i+8])[0] base, num = struct.unpack('IH', buf[i+8:i+14]) break i += 16 if base == 0 and length == 0 and num == 0: if(fatal): doError('Neither SMBIOS nor DMI were found') else: return out # read in the SM or DMI table try: fp = open(mempath, 'rb') fp.seek(base) buf = fp.read(length) except: if(fatal): doError('DMI table is unreachable, sorry') else: pprint('WARNING: /dev/mem is not readable, ignoring DMI data') return out fp.close() # scan the table for the values we want count = i = 0 while(count < num and i <= len(buf) - 4): type, size, handle = struct.unpack('BBH', buf[i:i+4]) n = i + size while n < len(buf) - 1: if 0 == struct.unpack('H', buf[n:n+2])[0]: break n += 1 data = buf[i+size:n+2].split(b'\0') for name in info: itype, idxadr = info[name] if itype == type: idx = struct.unpack('B', buf[i+idxadr:i+idxadr+1])[0] if idx > 0 and idx < len(data) - 1: s = data[idx-1].decode('utf-8') if s.strip() and s.strip().lower() != 'to be filled by o.e.m.': out[name] = s i = n + 2 count += 1 return out def getBattery(): p, charge, bat = '/sys/class/power_supply', 0, {} if not os.path.exists(p): return False for d in os.listdir(p): type = sysvals.getVal(os.path.join(p, d, 'type')).strip().lower() if type != 'battery': continue for v in ['status', 'energy_now', 'capacity_now']: bat[v] = sysvals.getVal(os.path.join(p, d, v)).strip().lower() break if 'status' not in bat: return False ac = False if 'discharging' in bat['status'] else True for v in ['energy_now', 'capacity_now']: if v in bat and bat[v]: charge = int(bat[v]) return (ac, charge) def displayControl(cmd): xset, ret = 'timeout 10 xset -d :0.0 {0}', 0 if sysvals.sudouser: xset = 'sudo -u %s %s' % (sysvals.sudouser, xset) if cmd == 'init': ret = call(xset.format('dpms 0 0 0'), shell=True) if not ret: ret = call(xset.format('s off'), shell=True) elif cmd == 'reset': ret = call(xset.format('s reset'), shell=True) elif cmd in ['on', 'off', 'standby', 'suspend']: b4 = displayControl('stat') ret = call(xset.format('dpms force %s' % cmd), shell=True) if not ret: curr = displayControl('stat') sysvals.vprint('Display Switched: %s -> %s' % (b4, curr)) if curr != cmd: sysvals.vprint('WARNING: Display failed to change to %s' % cmd) if ret: sysvals.vprint('WARNING: Display failed to change to %s with xset' % cmd) return ret elif cmd == 'stat': fp = Popen(xset.format('q').split(' '), stdout=PIPE).stdout ret = 'unknown' for line in fp: m = re.match('[\s]*Monitor is (?P.*)', ascii(line)) if(m and len(m.group('m')) >= 2): out = m.group('m').lower() ret = out[3:] if out[0:2] == 'in' else out break fp.close() return ret # Function: getFPDT # Description: # Read the acpi bios tables and pull out FPDT, the firmware data # Arguments: # output: True to output the info to stdout, False otherwise def getFPDT(output): rectype = {} rectype[0] = 'Firmware Basic Boot Performance Record' rectype[1] = 'S3 Performance Table Record' prectype = {} prectype[0] = 'Basic S3 Resume Performance Record' prectype[1] = 'Basic S3 Suspend Performance Record' sysvals.rootCheck(True) if(not os.path.exists(sysvals.fpdtpath)): if(output): doError('file does not exist: %s' % sysvals.fpdtpath) return False if(not os.access(sysvals.fpdtpath, os.R_OK)): if(output): doError('file is not readable: %s' % sysvals.fpdtpath) return False if(not os.path.exists(sysvals.mempath)): if(output): doError('file does not exist: %s' % sysvals.mempath) return False if(not os.access(sysvals.mempath, os.R_OK)): if(output): doError('file is not readable: %s' % sysvals.mempath) return False fp = open(sysvals.fpdtpath, 'rb') buf = fp.read() fp.close() if(len(buf) < 36): if(output): doError('Invalid FPDT table data, should '+\ 'be at least 36 bytes') return False table = struct.unpack('4sIBB6s8sI4sI', buf[0:36]) if(output): pprint('\n'\ 'Firmware Performance Data Table (%s)\n'\ ' Signature : %s\n'\ ' Table Length : %u\n'\ ' Revision : %u\n'\ ' Checksum : 0x%x\n'\ ' OEM ID : %s\n'\ ' OEM Table ID : %s\n'\ ' OEM Revision : %u\n'\ ' Creator ID : %s\n'\ ' Creator Revision : 0x%x\n'\ '' % (ascii(table[0]), ascii(table[0]), table[1], table[2], table[3], ascii(table[4]), ascii(table[5]), table[6], ascii(table[7]), table[8])) if(table[0] != b'FPDT'): if(output): doError('Invalid FPDT table') return False if(len(buf) <= 36): return False i = 0 fwData = [0, 0] records = buf[36:] try: fp = open(sysvals.mempath, 'rb') except: pprint('WARNING: /dev/mem is not readable, ignoring the FPDT data') return False while(i < len(records)): header = struct.unpack('HBB', records[i:i+4]) if(header[0] not in rectype): i += header[1] continue if(header[1] != 16): i += header[1] continue addr = struct.unpack('Q', records[i+8:i+16])[0] try: fp.seek(addr) first = fp.read(8) except: if(output): pprint('Bad address 0x%x in %s' % (addr, sysvals.mempath)) return [0, 0] rechead = struct.unpack('4sI', first) recdata = fp.read(rechead[1]-8) if(rechead[0] == b'FBPT'): record = struct.unpack('HBBIQQQQQ', recdata[:48]) if(output): pprint('%s (%s)\n'\ ' Reset END : %u ns\n'\ ' OS Loader LoadImage Start : %u ns\n'\ ' OS Loader StartImage Start : %u ns\n'\ ' ExitBootServices Entry : %u ns\n'\ ' ExitBootServices Exit : %u ns'\ '' % (rectype[header[0]], ascii(rechead[0]), record[4], record[5], record[6], record[7], record[8])) elif(rechead[0] == b'S3PT'): if(output): pprint('%s (%s)' % (rectype[header[0]], ascii(rechead[0]))) j = 0 while(j < len(recdata)): prechead = struct.unpack('HBB', recdata[j:j+4]) if(prechead[0] not in prectype): continue if(prechead[0] == 0): record = struct.unpack('IIQQ', recdata[j:j+prechead[1]]) fwData[1] = record[2] if(output): pprint(' %s\n'\ ' Resume Count : %u\n'\ ' FullResume : %u ns\n'\ ' AverageResume : %u ns'\ '' % (prectype[prechead[0]], record[1], record[2], record[3])) elif(prechead[0] == 1): record = struct.unpack('QQ', recdata[j+4:j+prechead[1]]) fwData[0] = record[1] - record[0] if(output): pprint(' %s\n'\ ' SuspendStart : %u ns\n'\ ' SuspendEnd : %u ns\n'\ ' SuspendTime : %u ns'\ '' % (prectype[prechead[0]], record[0], record[1], fwData[0])) j += prechead[1] if(output): pprint('') i += header[1] fp.close() return fwData # Function: statusCheck # Description: # Verify that the requested command and options will work, and # print the results to the terminal # Output: # True if the test will work, False if not def statusCheck(probecheck=False): status = '' pprint('Checking this system (%s)...' % platform.node()) # check we have root access res = sysvals.colorText('NO (No features of this tool will work!)') if(sysvals.rootCheck(False)): res = 'YES' pprint(' have root access: %s' % res) if(res != 'YES'): pprint(' Try running this script with sudo') return 'missing root access' # check sysfs is mounted res = sysvals.colorText('NO (No features of this tool will work!)') if(os.path.exists(sysvals.powerfile)): res = 'YES' pprint(' is sysfs mounted: %s' % res) if(res != 'YES'): return 'sysfs is missing' # check target mode is a valid mode if sysvals.suspendmode != 'command': res = sysvals.colorText('NO') modes = getModes() if(sysvals.suspendmode in modes): res = 'YES' else: status = '%s mode is not supported' % sysvals.suspendmode pprint(' is "%s" a valid power mode: %s' % (sysvals.suspendmode, res)) if(res == 'NO'): pprint(' valid power modes are: %s' % modes) pprint(' please choose one with -m') # check if ftrace is available res = sysvals.colorText('NO') ftgood = sysvals.verifyFtrace() if(ftgood): res = 'YES' elif(sysvals.usecallgraph): status = 'ftrace is not properly supported' pprint(' is ftrace supported: %s' % res) # check if kprobes are available if sysvals.usekprobes: res = sysvals.colorText('NO') sysvals.usekprobes = sysvals.verifyKprobes() if(sysvals.usekprobes): res = 'YES' else: sysvals.usedevsrc = False pprint(' are kprobes supported: %s' % res) # what data source are we using res = 'DMESG' if(ftgood): sysvals.usetraceevents = True for e in sysvals.traceevents: if not os.path.exists(sysvals.epath+e): sysvals.usetraceevents = False if(sysvals.usetraceevents): res = 'FTRACE (all trace events found)' pprint(' timeline data source: %s' % res) # check if rtcwake res = sysvals.colorText('NO') if(sysvals.rtcpath != ''): res = 'YES' elif(sysvals.rtcwake): status = 'rtcwake is not properly supported' pprint(' is rtcwake supported: %s' % res) if not probecheck: return status # verify kprobes if sysvals.usekprobes: for name in sysvals.tracefuncs: sysvals.defaultKprobe(name, sysvals.tracefuncs[name]) if sysvals.usedevsrc: for name in sysvals.dev_tracefuncs: sysvals.defaultKprobe(name, sysvals.dev_tracefuncs[name]) sysvals.addKprobes(True) return status # Function: doError # Description: # generic error function for catastrphic failures # Arguments: # msg: the error message to print # help: True if printHelp should be called after, False otherwise def doError(msg, help=False): if(help == True): printHelp() pprint('ERROR: %s\n' % msg) sysvals.outputResult({'error':msg}) sys.exit(1) # Function: getArgInt # Description: # pull out an integer argument from the command line with checks def getArgInt(name, args, min, max, main=True): if main: try: arg = next(args) except: doError(name+': no argument supplied', True) else: arg = args try: val = int(arg) except: doError(name+': non-integer value given', True) if(val < min or val > max): doError(name+': value should be between %d and %d' % (min, max), True) return val # Function: getArgFloat # Description: # pull out a float argument from the command line with checks def getArgFloat(name, args, min, max, main=True): if main: try: arg = next(args) except: doError(name+': no argument supplied', True) else: arg = args try: val = float(arg) except: doError(name+': non-numerical value given', True) if(val < min or val > max): doError(name+': value should be between %f and %f' % (min, max), True) return val def processData(live=False): pprint('PROCESSING DATA') sysvals.vprint('usetraceevents=%s, usetracemarkers=%s, usekprobes=%s' % \ (sysvals.usetraceevents, sysvals.usetracemarkers, sysvals.usekprobes)) error = '' if(sysvals.usetraceevents): testruns, error = parseTraceLog(live) if sysvals.dmesgfile: for data in testruns: data.extractErrorInfo() else: testruns = loadKernelLog() for data in testruns: parseKernelLog(data) if(sysvals.ftracefile and (sysvals.usecallgraph or sysvals.usetraceevents)): appendIncompleteTraceLog(testruns) shown = ['bios', 'biosdate', 'cpu', 'host', 'kernel', 'man', 'memfr', 'memsz', 'mode', 'numcpu', 'plat', 'time'] sysvals.vprint('System Info:') for key in sorted(sysvals.stamp): if key in shown: sysvals.vprint(' %-8s : %s' % (key.upper(), sysvals.stamp[key])) if sysvals.kparams: sysvals.vprint('Kparams:\n %s' % sysvals.kparams) sysvals.vprint('Command:\n %s' % sysvals.cmdline) for data in testruns: if data.mcelog: sysvals.vprint('MCELOG Data:') for line in data.mcelog.split('\n'): sysvals.vprint(' %s' % line) if data.turbostat: idx, s = 0, 'Turbostat:\n ' for val in data.turbostat.split('|'): idx += len(val) + 1 if idx >= 80: idx = 0 s += '\n ' s += val + ' ' sysvals.vprint(s) if data.battery: a1, c1, a2, c2 = data.battery s = 'Battery:\n Before - AC: %s, Charge: %d\n After - AC: %s, Charge: %d' % \ (a1, int(c1), a2, int(c2)) sysvals.vprint(s) if data.wifi: w = data.wifi.replace('|', ' ').split(',') s = 'Wifi:\n Before %s\n After %s' % \ (w[0], w[1]) sysvals.vprint(s) data.printDetails() if len(sysvals.platinfo) > 0: sysvals.vprint('\nPlatform Info:') for info in sysvals.platinfo: sysvals.vprint(info[0]+' - '+info[1]) sysvals.vprint(info[2]) sysvals.vprint('') if sysvals.cgdump: for data in testruns: data.debugPrint() sys.exit(0) if len(testruns) < 1: pprint('ERROR: Not enough test data to build a timeline') return (testruns, {'error': 'timeline generation failed'}) sysvals.vprint('Creating the html timeline (%s)...' % sysvals.htmlfile) createHTML(testruns, error) pprint('DONE') data = testruns[0] stamp = data.stamp stamp['suspend'], stamp['resume'] = data.getTimeValues() if data.fwValid: stamp['fwsuspend'], stamp['fwresume'] = data.fwSuspend, data.fwResume if error: stamp['error'] = error return (testruns, stamp) # Function: rerunTest # Description: # generate an output from an existing set of ftrace/dmesg logs def rerunTest(htmlfile=''): if sysvals.ftracefile: doesTraceLogHaveTraceEvents() if not sysvals.dmesgfile and not sysvals.usetraceevents: doError('recreating this html output requires a dmesg file') if htmlfile: sysvals.htmlfile = htmlfile else: sysvals.setOutputFile() if os.path.exists(sysvals.htmlfile): if not os.path.isfile(sysvals.htmlfile): doError('a directory already exists with this name: %s' % sysvals.htmlfile) elif not os.access(sysvals.htmlfile, os.W_OK): doError('missing permission to write to %s' % sysvals.htmlfile) testruns, stamp = processData(False) sysvals.logmsg = '' return stamp # Function: runTest # Description: # execute a suspend/resume, gather the logs, and generate the output def runTest(n=0): # prepare for the test sysvals.initFtrace() sysvals.initTestOutput('suspend') # execute the test testdata = executeSuspend() sysvals.cleanupFtrace() if sysvals.skiphtml: sysvals.sudoUserchown(sysvals.testdir) return if not testdata[0]['error']: testruns, stamp = processData(True) for data in testruns: del data else: stamp = testdata[0] sysvals.sudoUserchown(sysvals.testdir) sysvals.outputResult(stamp, n) if 'error' in stamp: return 2 return 0 def find_in_html(html, start, end, firstonly=True): n, out = 0, [] while n < len(html): m = re.search(start, html[n:]) if not m: break i = m.end() m = re.search(end, html[n+i:]) if not m: break j = m.start() str = html[n+i:n+i+j] if end == 'ms': num = re.search(r'[-+]?\d*\.\d+|\d+', str) str = num.group() if num else 'NaN' if firstonly: return str out.append(str) n += i+j if firstonly: return '' return out def data_from_html(file, outpath, issues, fulldetail=False): html = open(file, 'r').read() sysvals.htmlfile = os.path.relpath(file, outpath) # extract general info suspend = find_in_html(html, 'Kernel Suspend', 'ms') resume = find_in_html(html, 'Kernel Resume', 'ms') sysinfo = find_in_html(html, '
    ', '
    ') line = find_in_html(html, '
    ', '
    ') stmp = line.split() if not suspend or not resume or len(stmp) != 8: return False try: dt = datetime.strptime(' '.join(stmp[3:]), '%B %d %Y, %I:%M:%S %p') except: return False sysvals.hostname = stmp[0] tstr = dt.strftime('%Y/%m/%d %H:%M:%S') error = find_in_html(html, '') if error: m = re.match('[a-z]* failed in (?P

    [a-z0-9_]*) phase', error) if m: result = 'fail in %s' % m.group('p') else: result = 'fail' else: result = 'pass' # extract error info ilist = [] extra = dict() log = find_in_html(html, '

    ').strip() if log: d = Data(0) d.end = 999999999 d.dmesgtext = log.split('\n') msglist = d.extractErrorInfo() for msg in msglist: sysvals.errorSummary(issues, msg) if stmp[2] == 'freeze': extra = d.turbostatInfo() elist = dict() for dir in d.errorinfo: for err in d.errorinfo[dir]: if err[0] not in elist: elist[err[0]] = 0 elist[err[0]] += 1 for i in elist: ilist.append('%sx%d' % (i, elist[i]) if elist[i] > 1 else i) low = find_in_html(html, 'freeze time: ', ' ms') if low and '|' in low: issue = 'FREEZEx%d' % len(low.split('|')) match = [i for i in issues if i['match'] == issue] if len(match) > 0: match[0]['count'] += 1 if sysvals.hostname not in match[0]['urls']: match[0]['urls'][sysvals.hostname] = [sysvals.htmlfile] elif sysvals.htmlfile not in match[0]['urls'][sysvals.hostname]: match[0]['urls'][sysvals.hostname].append(sysvals.htmlfile) else: issues.append({ 'match': issue, 'count': 1, 'line': issue, 'urls': {sysvals.hostname: [sysvals.htmlfile]}, }) ilist.append(issue) # extract device info devices = dict() for line in html.split('\n'): m = re.match(' *
    .*)\" class=\"thread.*', line) if not m or 'thread kth' in line or 'thread sec' in line: continue m = re.match('(?P.*) \((?P[0-9,\.]*) ms\) (?P

    .*)', m.group('title')) if not m: continue name, time, phase = m.group('n'), m.group('t'), m.group('p') if ' async' in name or ' sync' in name: name = ' '.join(name.split(' ')[:-1]) if phase.startswith('suspend'): d = 'suspend' elif phase.startswith('resume'): d = 'resume' else: continue if d not in devices: devices[d] = dict() if name not in devices[d]: devices[d][name] = 0.0 devices[d][name] += float(time) # create worst device info worst = dict() for d in ['suspend', 'resume']: worst[d] = {'name':'', 'time': 0.0} dev = devices[d] if d in devices else 0 if dev and len(dev.keys()) > 0: n = sorted(dev, key=lambda k:(dev[k], k), reverse=True)[0] worst[d]['name'], worst[d]['time'] = n, dev[n] data = { 'mode': stmp[2], 'host': stmp[0], 'kernel': stmp[1], 'sysinfo': sysinfo, 'time': tstr, 'result': result, 'issues': ' '.join(ilist), 'suspend': suspend, 'resume': resume, 'devlist': devices, 'sus_worst': worst['suspend']['name'], 'sus_worsttime': worst['suspend']['time'], 'res_worst': worst['resume']['name'], 'res_worsttime': worst['resume']['time'], 'url': sysvals.htmlfile, } for key in extra: data[key] = extra[key] if fulldetail: data['funclist'] = find_in_html(html, '

    (%s: %s), use "true/false" or "1/0"' % (name, value), True) return False # Function: configFromFile # Description: # Configure the script via the info in a config file def configFromFile(file): Config = configparser.ConfigParser() Config.read(file) sections = Config.sections() overridekprobes = False overridedevkprobes = False if 'Settings' in sections: for opt in Config.options('Settings'): value = Config.get('Settings', opt).lower() option = opt.lower() if(option == 'verbose'): sysvals.verbose = checkArgBool(option, value) elif(option == 'addlogs'): sysvals.dmesglog = sysvals.ftracelog = checkArgBool(option, value) elif(option == 'dev'): sysvals.usedevsrc = checkArgBool(option, value) elif(option == 'proc'): sysvals.useprocmon = checkArgBool(option, value) elif(option == 'x2'): if checkArgBool(option, value): sysvals.execcount = 2 elif(option == 'callgraph'): sysvals.usecallgraph = checkArgBool(option, value) elif(option == 'override-timeline-functions'): overridekprobes = checkArgBool(option, value) elif(option == 'override-dev-timeline-functions'): overridedevkprobes = checkArgBool(option, value) elif(option == 'skiphtml'): sysvals.skiphtml = checkArgBool(option, value) elif(option == 'sync'): sysvals.sync = checkArgBool(option, value) elif(option == 'rs' or option == 'runtimesuspend'): if value in switchvalues: if value in switchoff: sysvals.rs = -1 else: sysvals.rs = 1 else: doError('invalid value --> (%s: %s), use "enable/disable"' % (option, value), True) elif(option == 'display'): disopt = ['on', 'off', 'standby', 'suspend'] if value not in disopt: doError('invalid value --> (%s: %s), use %s' % (option, value, disopt), True) sysvals.display = value elif(option == 'gzip'): sysvals.gzip = checkArgBool(option, value) elif(option == 'cgfilter'): sysvals.setCallgraphFilter(value) elif(option == 'cgskip'): if value in switchoff: sysvals.cgskip = '' else: sysvals.cgskip = sysvals.configFile(val) if(not sysvals.cgskip): doError('%s does not exist' % sysvals.cgskip) elif(option == 'cgtest'): sysvals.cgtest = getArgInt('cgtest', value, 0, 1, False) elif(option == 'cgphase'): d = Data(0) if value not in d.sortedPhases(): doError('invalid phase --> (%s: %s), valid phases are %s'\ % (option, value, d.sortedPhases()), True) sysvals.cgphase = value elif(option == 'fadd'): file = sysvals.configFile(value) if(not file): doError('%s does not exist' % value) sysvals.addFtraceFilterFunctions(file) elif(option == 'result'): sysvals.result = value elif(option == 'multi'): nums = value.split() if len(nums) != 2: doError('multi requires 2 integers (exec_count and delay)', True) sysvals.multitest['run'] = True sysvals.multitest['count'] = getArgInt('multi: n d (exec count)', nums[0], 2, 1000000, False) sysvals.multitest['delay'] = getArgInt('multi: n d (delay between tests)', nums[1], 0, 3600, False) elif(option == 'devicefilter'): sysvals.setDeviceFilter(value) elif(option == 'expandcg'): sysvals.cgexp = checkArgBool(option, value) elif(option == 'srgap'): if checkArgBool(option, value): sysvals.srgap = 5 elif(option == 'mode'): sysvals.suspendmode = value elif(option == 'command' or option == 'cmd'): sysvals.testcommand = value elif(option == 'x2delay'): sysvals.x2delay = getArgInt('x2delay', value, 0, 60000, False) elif(option == 'predelay'): sysvals.predelay = getArgInt('predelay', value, 0, 60000, False) elif(option == 'postdelay'): sysvals.postdelay = getArgInt('postdelay', value, 0, 60000, False) elif(option == 'maxdepth'): sysvals.max_graph_depth = getArgInt('maxdepth', value, 0, 1000, False) elif(option == 'rtcwake'): if value in switchoff: sysvals.rtcwake = False else: sysvals.rtcwake = True sysvals.rtcwaketime = getArgInt('rtcwake', value, 0, 3600, False) elif(option == 'timeprec'): sysvals.setPrecision(getArgInt('timeprec', value, 0, 6, False)) elif(option == 'mindev'): sysvals.mindevlen = getArgFloat('mindev', value, 0.0, 10000.0, False) elif(option == 'callloop-maxgap'): sysvals.callloopmaxgap = getArgFloat('callloop-maxgap', value, 0.0, 1.0, False) elif(option == 'callloop-maxlen'): sysvals.callloopmaxgap = getArgFloat('callloop-maxlen', value, 0.0, 1.0, False) elif(option == 'mincg'): sysvals.mincglen = getArgFloat('mincg', value, 0.0, 10000.0, False) elif(option == 'bufsize'): sysvals.bufsize = getArgInt('bufsize', value, 1, 1024*1024*8, False) elif(option == 'output-dir'): sysvals.outdir = sysvals.setOutputFolder(value) if sysvals.suspendmode == 'command' and not sysvals.testcommand: doError('No command supplied for mode "command"') # compatibility errors if sysvals.usedevsrc and sysvals.usecallgraph: doError('-dev is not compatible with -f') if sysvals.usecallgraph and sysvals.useprocmon: doError('-proc is not compatible with -f') if overridekprobes: sysvals.tracefuncs = dict() if overridedevkprobes: sysvals.dev_tracefuncs = dict() kprobes = dict() kprobesec = 'dev_timeline_functions_'+platform.machine() if kprobesec in sections: for name in Config.options(kprobesec): text = Config.get(kprobesec, name) kprobes[name] = (text, True) kprobesec = 'timeline_functions_'+platform.machine() if kprobesec in sections: for name in Config.options(kprobesec): if name in kprobes: doError('Duplicate timeline function found "%s"' % (name)) text = Config.get(kprobesec, name) kprobes[name] = (text, False) for name in kprobes: function = name format = name color = '' args = dict() text, dev = kprobes[name] data = text.split() i = 0 for val in data: # bracketted strings are special formatting, read them separately if val[0] == '[' and val[-1] == ']': for prop in val[1:-1].split(','): p = prop.split('=') if p[0] == 'color': try: color = int(p[1], 16) color = '#'+p[1] except: color = p[1] continue # first real arg should be the format string if i == 0: format = val # all other args are actual function args else: d = val.split('=') args[d[0]] = d[1] i += 1 if not function or not format: doError('Invalid kprobe: %s' % name) for arg in re.findall('{(?P[a-z,A-Z,0-9]*)}', format): if arg not in args: doError('Kprobe "%s" is missing argument "%s"' % (name, arg)) if (dev and name in sysvals.dev_tracefuncs) or (not dev and name in sysvals.tracefuncs): doError('Duplicate timeline function found "%s"' % (name)) kp = { 'name': name, 'func': function, 'format': format, sysvals.archargs: args } if color: kp['color'] = color if dev: sysvals.dev_tracefuncs[name] = kp else: sysvals.tracefuncs[name] = kp # Function: printHelp # Description: # print out the help text def printHelp(): pprint('\n%s v%s\n'\ 'Usage: sudo sleepgraph \n'\ '\n'\ 'Description:\n'\ ' This tool is designed to assist kernel and OS developers in optimizing\n'\ ' their linux stack\'s suspend/resume time. Using a kernel image built\n'\ ' with a few extra options enabled, the tool will execute a suspend and\n'\ ' capture dmesg and ftrace data until resume is complete. This data is\n'\ ' transformed into a device timeline and an optional callgraph to give\n'\ ' a detailed view of which devices/subsystems are taking the most\n'\ ' time in suspend/resume.\n'\ '\n'\ ' If no specific command is given, the default behavior is to initiate\n'\ ' a suspend/resume and capture the dmesg/ftrace output as an html timeline.\n'\ '\n'\ ' Generates output files in subdirectory: suspend-yymmdd-HHMMSS\n'\ ' HTML output: _.html\n'\ ' raw dmesg output: __dmesg.txt\n'\ ' raw ftrace output: __ftrace.txt\n'\ '\n'\ 'Options:\n'\ ' -h Print this help text\n'\ ' -v Print the current tool version\n'\ ' -config fn Pull arguments and config options from file fn\n'\ ' -verbose Print extra information during execution and analysis\n'\ ' -m mode Mode to initiate for suspend (default: %s)\n'\ ' -o name Overrides the output subdirectory name when running a new test\n'\ ' default: suspend-{date}-{time}\n'\ ' -rtcwake t Wakeup t seconds after suspend, set t to "off" to disable (default: 15)\n'\ ' -addlogs Add the dmesg and ftrace logs to the html output\n'\ ' -noturbostat Dont use turbostat in freeze mode (default: disabled)\n'\ ' -srgap Add a visible gap in the timeline between sus/res (default: disabled)\n'\ ' -skiphtml Run the test and capture the trace logs, but skip the timeline (default: disabled)\n'\ ' -result fn Export a results table to a text file for parsing.\n'\ ' [testprep]\n'\ ' -sync Sync the filesystems before starting the test\n'\ ' -rs on/off Enable/disable runtime suspend for all devices, restore all after test\n'\ ' -display m Change the display mode to m for the test (on/off/standby/suspend)\n'\ ' [advanced]\n'\ ' -gzip Gzip the trace and dmesg logs to save space\n'\ ' -cmd {s} Run the timeline over a custom command, e.g. "sync -d"\n'\ ' -proc Add usermode process info into the timeline (default: disabled)\n'\ ' -dev Add kernel function calls and threads to the timeline (default: disabled)\n'\ ' -x2 Run two suspend/resumes back to back (default: disabled)\n'\ ' -x2delay t Include t ms delay between multiple test runs (default: 0 ms)\n'\ ' -predelay t Include t ms delay before 1st suspend (default: 0 ms)\n'\ ' -postdelay t Include t ms delay after last resume (default: 0 ms)\n'\ ' -mindev ms Discard all device blocks shorter than ms milliseconds (e.g. 0.001 for us)\n'\ ' -multi n d Execute consecutive tests at seconds intervals. The outputs will\n'\ ' be created in a new subdirectory with a summary page.\n'\ ' [debug]\n'\ ' -f Use ftrace to create device callgraphs (default: disabled)\n'\ ' -ftop Use ftrace on the top level call: "%s" (default: disabled)\n'\ ' -maxdepth N limit the callgraph data to N call levels (default: 0=all)\n'\ ' -expandcg pre-expand the callgraph data in the html output (default: disabled)\n'\ ' -fadd file Add functions to be graphed in the timeline from a list in a text file\n'\ ' -filter "d1,d2,..." Filter out all but this comma-delimited list of device names\n'\ ' -mincg ms Discard all callgraphs shorter than ms milliseconds (e.g. 0.001 for us)\n'\ ' -cgphase P Only show callgraph data for phase P (e.g. suspend_late)\n'\ ' -cgtest N Only show callgraph data for test N (e.g. 0 or 1 in an x2 run)\n'\ ' -timeprec N Number of significant digits in timestamps (0:S, [3:ms], 6:us)\n'\ ' -cgfilter S Filter the callgraph output in the timeline\n'\ ' -cgskip file Callgraph functions to skip, off to disable (default: cgskip.txt)\n'\ ' -bufsize N Set trace buffer size to N kilo-bytes (default: all of free memory)\n'\ ' -devdump Print out all the raw device data for each phase\n'\ ' -cgdump Print out all the raw callgraph data\n'\ '\n'\ 'Other commands:\n'\ ' -modes List available suspend modes\n'\ ' -status Test to see if the system is enabled to run this tool\n'\ ' -fpdt Print out the contents of the ACPI Firmware Performance Data Table\n'\ ' -battery Print out battery info (if available)\n'\ ' -wifi Print out wifi connection info (if wireless-tools and device exists)\n'\ ' -x Test xset by toggling the given mode (on/off/standby/suspend)\n'\ ' -sysinfo Print out system info extracted from BIOS\n'\ ' -devinfo Print out the pm settings of all devices which support runtime suspend\n'\ ' -flist Print the list of functions currently being captured in ftrace\n'\ ' -flistall Print all functions capable of being captured in ftrace\n'\ ' -summary dir Create a summary of tests in this dir [-genhtml builds missing html]\n'\ ' [redo]\n'\ ' -ftrace ftracefile Create HTML output using ftrace input (used with -dmesg)\n'\ ' -dmesg dmesgfile Create HTML output using dmesg (used with -ftrace)\n'\ '' % (sysvals.title, sysvals.version, sysvals.suspendmode, sysvals.ftopfunc)) return True # ----------------- MAIN -------------------- # exec start (skipped if script is loaded as library) if __name__ == '__main__': genhtml = False cmd = '' simplecmds = ['-sysinfo', '-modes', '-fpdt', '-flist', '-flistall', '-devinfo', '-status', '-battery', '-xon', '-xoff', '-xstandby', '-xsuspend', '-xinit', '-xreset', '-xstat', '-wifi'] if '-f' in sys.argv: sysvals.cgskip = sysvals.configFile('cgskip.txt') # loop through the command line arguments args = iter(sys.argv[1:]) for arg in args: if(arg == '-m'): try: val = next(args) except: doError('No mode supplied', True) if val == 'command' and not sysvals.testcommand: doError('No command supplied for mode "command"', True) sysvals.suspendmode = val elif(arg in simplecmds): cmd = arg[1:] elif(arg == '-h'): printHelp() sys.exit(0) elif(arg == '-v'): pprint("Version %s" % sysvals.version) sys.exit(0) elif(arg == '-x2'): sysvals.execcount = 2 elif(arg == '-x2delay'): sysvals.x2delay = getArgInt('-x2delay', args, 0, 60000) elif(arg == '-predelay'): sysvals.predelay = getArgInt('-predelay', args, 0, 60000) elif(arg == '-postdelay'): sysvals.postdelay = getArgInt('-postdelay', args, 0, 60000) elif(arg == '-f'): sysvals.usecallgraph = True elif(arg == '-ftop'): sysvals.usecallgraph = True sysvals.ftop = True sysvals.usekprobes = False elif(arg == '-skiphtml'): sysvals.skiphtml = True elif(arg == '-cgdump'): sysvals.cgdump = True elif(arg == '-devdump'): sysvals.devdump = True elif(arg == '-genhtml'): genhtml = True elif(arg == '-addlogs'): sysvals.dmesglog = sysvals.ftracelog = True elif(arg == '-nologs'): sysvals.dmesglog = sysvals.ftracelog = False elif(arg == '-addlogdmesg'): sysvals.dmesglog = True elif(arg == '-addlogftrace'): sysvals.ftracelog = True elif(arg == '-noturbostat'): sysvals.tstat = False elif(arg == '-verbose'): sysvals.verbose = True elif(arg == '-proc'): sysvals.useprocmon = True elif(arg == '-dev'): sysvals.usedevsrc = True elif(arg == '-sync'): sysvals.sync = True elif(arg == '-gzip'): sysvals.gzip = True elif(arg == '-rs'): try: val = next(args) except: doError('-rs requires "enable" or "disable"', True) if val.lower() in switchvalues: if val.lower() in switchoff: sysvals.rs = -1 else: sysvals.rs = 1 else: doError('invalid option: %s, use "enable/disable" or "on/off"' % val, True) elif(arg == '-display'): try: val = next(args) except: doError('-display requires an mode value', True) disopt = ['on', 'off', 'standby', 'suspend'] if val.lower() not in disopt: doError('valid display mode values are %s' % disopt, True) sysvals.display = val.lower() elif(arg == '-maxdepth'): sysvals.max_graph_depth = getArgInt('-maxdepth', args, 0, 1000) elif(arg == '-rtcwake'): try: val = next(args) except: doError('No rtcwake time supplied', True) if val.lower() in switchoff: sysvals.rtcwake = False else: sysvals.rtcwake = True sysvals.rtcwaketime = getArgInt('-rtcwake', val, 0, 3600, False) elif(arg == '-timeprec'): sysvals.setPrecision(getArgInt('-timeprec', args, 0, 6)) elif(arg == '-mindev'): sysvals.mindevlen = getArgFloat('-mindev', args, 0.0, 10000.0) elif(arg == '-mincg'): sysvals.mincglen = getArgFloat('-mincg', args, 0.0, 10000.0) elif(arg == '-bufsize'): sysvals.bufsize = getArgInt('-bufsize', args, 1, 1024*1024*8) elif(arg == '-cgtest'): sysvals.cgtest = getArgInt('-cgtest', args, 0, 1) elif(arg == '-cgphase'): try: val = next(args) except: doError('No phase name supplied', True) d = Data(0) if val not in d.phasedef: doError('invalid phase --> (%s: %s), valid phases are %s'\ % (arg, val, d.phasedef.keys()), True) sysvals.cgphase = val elif(arg == '-cgfilter'): try: val = next(args) except: doError('No callgraph functions supplied', True) sysvals.setCallgraphFilter(val) elif(arg == '-skipkprobe'): try: val = next(args) except: doError('No kprobe functions supplied', True) sysvals.skipKprobes(val) elif(arg == '-cgskip'): try: val = next(args) except: doError('No file supplied', True) if val.lower() in switchoff: sysvals.cgskip = '' else: sysvals.cgskip = sysvals.configFile(val) if(not sysvals.cgskip): doError('%s does not exist' % sysvals.cgskip) elif(arg == '-callloop-maxgap'): sysvals.callloopmaxgap = getArgFloat('-callloop-maxgap', args, 0.0, 1.0) elif(arg == '-callloop-maxlen'): sysvals.callloopmaxlen = getArgFloat('-callloop-maxlen', args, 0.0, 1.0) elif(arg == '-cmd'): try: val = next(args) except: doError('No command string supplied', True) sysvals.testcommand = val sysvals.suspendmode = 'command' elif(arg == '-expandcg'): sysvals.cgexp = True elif(arg == '-srgap'): sysvals.srgap = 5 elif(arg == '-multi'): sysvals.multitest['run'] = True sysvals.multitest['count'] = getArgInt('-multi n d (exec count)', args, 2, 1000000) sysvals.multitest['delay'] = getArgInt('-multi n d (delay between tests)', args, 0, 3600) elif(arg == '-o'): try: val = next(args) except: doError('No subdirectory name supplied', True) sysvals.outdir = sysvals.setOutputFolder(val) elif(arg == '-config'): try: val = next(args) except: doError('No text file supplied', True) file = sysvals.configFile(val) if(not file): doError('%s does not exist' % val) configFromFile(file) elif(arg == '-fadd'): try: val = next(args) except: doError('No text file supplied', True) file = sysvals.configFile(val) if(not file): doError('%s does not exist' % val) sysvals.addFtraceFilterFunctions(file) elif(arg == '-dmesg'): try: val = next(args) except: doError('No dmesg file supplied', True) sysvals.notestrun = True sysvals.dmesgfile = val if(os.path.exists(sysvals.dmesgfile) == False): doError('%s does not exist' % sysvals.dmesgfile) elif(arg == '-ftrace'): try: val = next(args) except: doError('No ftrace file supplied', True) sysvals.notestrun = True sysvals.ftracefile = val if(os.path.exists(sysvals.ftracefile) == False): doError('%s does not exist' % sysvals.ftracefile) elif(arg == '-summary'): try: val = next(args) except: doError('No directory supplied', True) cmd = 'summary' sysvals.outdir = val sysvals.notestrun = True if(os.path.isdir(val) == False): doError('%s is not accesible' % val) elif(arg == '-filter'): try: val = next(args) except: doError('No devnames supplied', True) sysvals.setDeviceFilter(val) elif(arg == '-result'): try: val = next(args) except: doError('No result file supplied', True) sysvals.result = val sysvals.signalHandlerInit() else: doError('Invalid argument: '+arg, True) # compatibility errors if(sysvals.usecallgraph and sysvals.usedevsrc): doError('-dev is not compatible with -f') if(sysvals.usecallgraph and sysvals.useprocmon): doError('-proc is not compatible with -f') if sysvals.usecallgraph and sysvals.cgskip: sysvals.vprint('Using cgskip file: %s' % sysvals.cgskip) sysvals.setCallgraphBlacklist(sysvals.cgskip) # callgraph size cannot exceed device size if sysvals.mincglen < sysvals.mindevlen: sysvals.mincglen = sysvals.mindevlen # remove existing buffers before calculating memory if(sysvals.usecallgraph or sysvals.usedevsrc): sysvals.fsetVal('16', 'buffer_size_kb') sysvals.cpuInfo() # just run a utility command and exit if(cmd != ''): ret = 0 if(cmd == 'status'): if not statusCheck(True): ret = 1 elif(cmd == 'fpdt'): if not getFPDT(True): ret = 1 elif(cmd == 'battery'): out = getBattery() if out: pprint('AC Connect : %s\nBattery Charge: %d' % out) else: pprint('no battery found') ret = 1 elif(cmd == 'sysinfo'): sysvals.printSystemInfo(True) elif(cmd == 'devinfo'): deviceInfo() elif(cmd == 'modes'): pprint(getModes()) elif(cmd == 'flist'): sysvals.getFtraceFilterFunctions(True) elif(cmd == 'flistall'): sysvals.getFtraceFilterFunctions(False) elif(cmd == 'summary'): runSummary(sysvals.outdir, True, genhtml) elif(cmd in ['xon', 'xoff', 'xstandby', 'xsuspend', 'xinit', 'xreset']): sysvals.verbose = True ret = displayControl(cmd[1:]) elif(cmd == 'xstat'): pprint('Display Status: %s' % displayControl('stat').upper()) elif(cmd == 'wifi'): out = sysvals.checkWifi() if 'device' not in out: pprint('WIFI interface not found') else: for key in sorted(out): pprint('%6s: %s' % (key.upper(), out[key])) sys.exit(ret) # if instructed, re-analyze existing data files if(sysvals.notestrun): stamp = rerunTest(sysvals.outdir) sysvals.outputResult(stamp) sys.exit(0) # verify that we can run a test error = statusCheck() if(error): doError(error) # extract mem/disk extra modes and convert mode = sysvals.suspendmode if mode.startswith('mem'): memmode = mode.split('-', 1)[-1] if '-' in mode else 'deep' if memmode == 'shallow': mode = 'standby' elif memmode == 's2idle': mode = 'freeze' else: mode = 'mem' sysvals.memmode = memmode sysvals.suspendmode = mode if mode.startswith('disk-'): sysvals.diskmode = mode.split('-', 1)[-1] sysvals.suspendmode = 'disk' sysvals.systemInfo(dmidecode(sysvals.mempath)) setRuntimeSuspend(True) if sysvals.display: displayControl('init') ret = 0 if sysvals.multitest['run']: # run multiple tests in a separate subdirectory if not sysvals.outdir: s = 'suspend-x%d' % sysvals.multitest['count'] sysvals.outdir = datetime.now().strftime(s+'-%y%m%d-%H%M%S') if not os.path.isdir(sysvals.outdir): os.makedirs(sysvals.outdir) for i in range(sysvals.multitest['count']): if(i != 0): pprint('Waiting %d seconds...' % (sysvals.multitest['delay'])) time.sleep(sysvals.multitest['delay']) pprint('TEST (%d/%d) START' % (i+1, sysvals.multitest['count'])) fmt = 'suspend-%y%m%d-%H%M%S' sysvals.testdir = os.path.join(sysvals.outdir, datetime.now().strftime(fmt)) ret = runTest(i+1) pprint('TEST (%d/%d) COMPLETE' % (i+1, sysvals.multitest['count'])) sysvals.logmsg = '' if not sysvals.skiphtml: runSummary(sysvals.outdir, False, False) sysvals.sudoUserchown(sysvals.outdir) else: if sysvals.outdir: sysvals.testdir = sysvals.outdir # run the test in the current directory ret = runTest() if sysvals.display: displayControl('reset') setRuntimeSuspend(False) sys.exit(ret)
    ', '