| blob | 918eae58b0b45f62b3dc0ebce501f39c01918d6f |
1 #!/usr/bin/env python3
2 # SPDX-License-Identifier: GPL-2.0-only
3 #
4 # Tool for analyzing suspend/resume timing
5 # Copyright (c) 2013, Intel Corporation.
6 #
7 # This program is free software; you can redistribute it and/or modify it
8 # under the terms and conditions of the GNU General Public License,
9 # version 2, as published by the Free Software Foundation.
10 #
11 # This program is distributed in the hope it will be useful, but WITHOUT
12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 # more details.
15 #
16 # Authors:
17 # Todd Brandt <todd.e.brandt@linux.intel.com>
18 #
19 # Links:
20 # Home Page
21 # https://www.intel.com/content/www/us/en/developer/topic-technology/open/pm-graph/overview.html
22 # Source repo
23 # git@github.com:intel/pm-graph
24 #
25 # Description:
26 # This tool is designed to assist kernel and OS developers in optimizing
27 # their linux stack's suspend/resume time. Using a kernel image built
28 # with a few extra options enabled, the tool will execute a suspend and
29 # will capture dmesg and ftrace data until resume is complete. This data
30 # is transformed into a device timeline and a callgraph to give a quick
31 # and detailed view of which devices and callbacks are taking the most
32 # time in suspend/resume. The output is a single html file which can be
33 # viewed in firefox or chrome.
34 #
35 # The following kernel build options are required:
36 # CONFIG_DEVMEM=y
37 # CONFIG_PM_DEBUG=y
38 # CONFIG_PM_SLEEP_DEBUG=y
39 # CONFIG_FTRACE=y
40 # CONFIG_FUNCTION_TRACER=y
41 # CONFIG_FUNCTION_GRAPH_TRACER=y
42 # CONFIG_KPROBES=y
43 # CONFIG_KPROBES_ON_FTRACE=y
44 #
45 # For kernel versions older than 3.15:
46 # The following additional kernel parameters are required:
47 # (e.g. in file /etc/default/grub)
48 # GRUB_CMDLINE_LINUX_DEFAULT="... initcall_debug log_buf_len=16M ..."
49 #
51 # ----------------- LIBRARIES --------------------
53 import sys
54 import time
55 import os
56 import string
57 import re
58 import platform
59 import signal
60 import codecs
62 import struct
63 import configparser
64 import gzip
67 import base64
68 import traceback
82 # ----------------- CLASSES --------------------
84 # Class: SystemValues
85 # Description:
86 # A global, single-instance container used to
87 # store system values and test parameters
131 traceevents = [
136 'device_pm_callback_start'
137 ]
159 devicefilter = []
160 cgfilter = []
180 platinfo = []
185 tracefuncs = {
228 },
233 },
234 }
235 dev_tracefuncs = {
236 # general wait/delay/sleep
244 },
248 # ACPI
252 }},
253 # mei_me
255 # filesystem
257 # 80211
280 # ATA
282 # i915
297 }
298 infocmds = [
314 [2, 'cpuidle', 'sh', '-c', 'grep -v invalid /sys/devices/system/cpu/cpu*/cpuidle/state*/s2idle/*'],
317 ]
318 cgblacklist = []
356 return
372 continue
376 return True
382 return False
385 return True
391 return False
394 return False
401 return False
403 return False
404 return True
413 return out
418 return cmdfull
419 return out
422 return
456 self.sysstamp = '# sysinfo | man:%s | plat:%s | cpu:%s | bios:%s | biosdate:%s | numcpu:%d | memsz:%d | memfr:%d' % \
464 return
515 out = []
519 return out
538 # if hardware time fails, use the software time
545 # get the latest time stamp from the dmesg log
556 break
560 # store all new dmesg lines since initdmesg was called
569 continue
587 continue
593 return
607 continue
618 k = kdata
637 # first remvoe any spaces inside quotes, and the quotes
644 data += c
647 # now process the args
659 return out
682 return val
685 return
688 # first test each kprobe
689 rejects = []
690 # sort kprobes: trace, ub-dev, custom, dev
691 kpl = [[], [], [], []]
711 # remove all failed ones from the list
714 # set the kprobes all at once
729 return False
734 return False
738 return False
739 return True
742 return False
749 return False
750 return True
753 return False
758 return res
764 pass
765 return res
782 return True
787 f = i
789 return True
790 return False
793 return
797 # turn trace off
800 # set the trace clock to global
803 # set trace buffer to an appropriate value
814 # if the size failed to set, lower it and keep trying
818 break
820 # initialize the callgraph trace
822 # set trace type
825 # temporary hack to fix https://bugzilla.kernel.org/show_bug.cgi?id=212761
829 # set trace format options
852 # initialize the kprobe trace
863 # turn trace events on
867 # clear the trace buffer
870 # files needed for any trace data
873 # legacy check for old systems
878 # files needed for callgraph trace data
881 files += [
884 'set_graph_function'
885 ]
888 return False
889 return True
891 # files needed for kprobes to work
896 return False
897 return True
918 return fp
925 return
936 return
981 return
989 out = data
990 return out
993 return out
995 # add platform info on to a completed ftrace file
997 return False
1000 # add test command string line if need be
1004 # get a list of target devices from the ftrace file
1010 continue
1011 # parse only valid lines, if this is not one move on
1014 continue
1017 continue
1023 # now get the syspath for each target device
1030 # now fill in the properties for our target devices
1034 continue
1044 continue
1049 continue
1057 break
1059 break
1065 # add a devinfo line to the bottom of ftrace
1071 # add a line for each of these commands with their outputs
1075 return True
1084 break
1087 return prefix
1095 continue
1104 return out
1120 out = []
1130 continue
1137 continue
1157 return out
1183 return False
1188 return True
1189 return False
1192 return False
1195 return False
1201 return True
1202 return False
1210 rawout += line
1212 continue
1226 out = []
1231 continue
1241 return out
1246 return dev
1260 continue
1282 break
1284 return
1296 entry = {
1301 }
1313 return
1319 return
1361 return ret
1370 break
1372 return ret
1375 # runtime suspend disable or enable
1388 # runtime suspend re-enable or re-disable
1410 suspendmodename = {
1415 }
1417 # Class: DevProps
1418 # Description:
1419 # Simple class which holds property values collected
1420 # for all the devices used in the timeline.
1434 return dev
1449 # Class: DeviceNode
1450 # Description:
1451 # A container used to create a device hierachy, with a single root node
1452 # and a tree of child nodes. Used by Data.deviceTopology()
1459 # Class: Data
1460 # Description:
1461 # The primary container for suspend/resume test data. There is one for
1462 # each test run. The data is organized into a cronological hierarchy:
1463 # Data.dmesg {
1464 # phases {
1465 # 10 sequential, non-overlapping phases of S/R
1466 # contents: times for phase start/end, order/color data for html
1467 # devlist {
1468 # device callback or action list for this phase
1469 # device {
1470 # a single device callback or generic action
1471 # contents: start/stop times, pid/cpu/driver info
1472 # parents/children, html id for timeline/callgraph
1473 # optionally includes an ftrace callgraph
1474 # optionally includes dev/ps data
1475 # }
1476 # }
1477 # }
1478 # }
1479 #
1481 phasedef = {
1492 }
1493 errlist = {
1513 }
1547 # called when phases are all finished being added
1560 return p
1573 continue
1579 break
1580 return out
1591 continue
1594 continue
1597 continue
1601 continue
1606 break
1615 return tp
1637 return False
1638 return True
1642 continue
1645 return phase
1653 # pid must match
1655 continue
1659 # device target event is entirely inside the source boundary
1661 continue
1663 # thread target event will expand the source boundary
1668 tgtdev = dev
1669 break
1670 return tgtdev
1672 # try to place the call in a device
1675 # calls with device pids that occur outside device bounds are dropped
1676 # TODO: include these somehow
1678 return False
1679 # try to place the call in a thread
1682 # create new thread blocks, expand as new calls are found
1690 return False
1692 return self.addDeviceFunctionCall(displayname, kprobename, proc, pid, start, end, cdata, rdata)
1693 # this should not happen
1697 return False
1698 # place the call data inside the src element of the tgtdev
1716 return False
1718 return False
1722 return True
1724 # get a list of devices that extend beyond the end of this test run
1725 devlist = []
1732 return devlist
1734 # merge any devices that overlap devlist
1740 continue
1744 continue
1747 continue
1751 # the caller test has priority of this thread, give it to him
1763 break
1765 # merge any threads between tests that touch
1771 continue
1775 # merge any src call loops to reduce timeline size
1780 continue
1785 p = e
1786 continue
1787 # e is another iteration of p, move it into p
1796 return t0
1799 return t
1806 return t
1851 # trim out any standby or freeze clock time
1858 continue
1871 lp = phase
1874 return
1886 # phase start over current phase
1894 # create unique name for every new phase
1902 # phase end without a start
1905 sysvals.vprint('WARNING: %s ended instead of %s, ftrace corruption?' % (phase, self.currphase))
1908 return phase
1912 return phase
1917 # if any calls never returned, clip them at system resume end
1925 break
1930 rmlist = []
1942 # if any calls never returned, clip them at system resume end
1946 rmgroups = []
1947 newgroup = []
1951 continue
1961 # which phase is this device callback or action in
1966 myphases = []
1970 # see if the action overlaps this phase
1974 # set the target phase to the one that overlaps most
1977 continue
1978 targetphase = phase
1979 overlap = o
1980 # if no target phase was found, pin it to the edge
1997 return False
1999 # new device callback for a specific phase
2008 origname = name
2018 return name
2024 mydev = devname
2027 return False
2029 devlist = []
2034 return devlist
2040 return size
2070 devlist = []
2076 return devlist
2080 # avoid recursions
2082 continue
2086 return node
2109 return html
2111 # list of devices graphed
2112 real = []
2118 # list of top-most root devices
2119 rootlist = []
2126 continue
2129 return rootlist
2135 # only select devices that will actually show up in html
2138 devlist = []
2154 return d
2156 # get the start and end times for this process
2161 tlast = t
2162 continue
2165 start = tlast
2169 tlast = t
2171 return
2172 # add a new action for this process and get the object
2179 # get an array of process names and times
2188 # process the events for suspend and resume
2198 # give suspend_prepare an end if needed
2201 # assume resume machine ends at next phase start
2206 # if kernel resume end not found, assume its the end marker
2209 # if kernel suspend start not found, assume its the end marker
2212 # set resume complete to end at end marker
2247 # Class: DevFunction
2248 # Description:
2249 # A container for kprobe function data we want in the dev timeline
2281 return text
2283 # is the tgt call just a repeat of this call (e.g. are we in a loop)
2285 # only combine calls if -all- attributes are identical
2292 return True
2293 return False
2295 # Class: FTraceLine
2296 # Description:
2297 # A container for a single line of ftrace data. There are six basic types:
2298 # callgraph line:
2299 # call: " dpm_run_callback() {"
2300 # return: " }"
2301 # leaf: " dpm_run_callback();"
2302 # trace event:
2303 # tracing_mark_write: SUSPEND START or RESUME COMPLETE
2304 # suspend_resume: phase or custom exec block data
2305 # device_pm_callback: device callback info
2318 return
2319 # is this a trace event
2322 # nop format trace event
2323 msg = m
2325 # function_graph format trace event
2340 return
2346 return
2348 return
2349 # convert the duration to seconds
2352 # the indentation determines the depth
2355 return
2358 # function return
2362 # includes comment with function name
2366 # function call
2369 # function call with children
2374 # function call with no children (leaf)
2380 # something else (possibly a trace marker)
2402 # Is this the starting line of a suspend?
2404 return False
2407 return True
2408 return False
2412 return True
2413 return False
2415 # Is this the ending line of a resume?
2417 return False
2420 return True
2421 return False
2425 return True
2426 return False
2428 # Class: FTraceCallGraph
2429 # Description:
2430 # A container for the ftrace callgraph of a single recursive function.
2431 # This can be a dpm_run_callback, dpm_prepare, or dpm_complete callgraph
2432 # Each instance is tied to a single device in a single phase, and is
2433 # comprised of an ordered list of FTraceLine objects
2449 # if this is already invalid, just leave
2454 # invalidate on bad depth
2458 # ignore data til we return to the current depth
2466 # if this is a return at self.depth, no more work is needed
2472 # compare current depth with this lines pre-call depth
2483 # handle low misalignments by inserting returns
2486 info = []
2489 # add return calls to get the depth down
2493 # special case, turn last call into a leaf
2512 # handle high misalignments by inserting calls
2517 # add calls to get the depth up
2520 # special case, turn this return into a leaf
2545 # process the call and set the new depth
2549 # ignore blacklisted/overdepth funcs
2556 # remove blacklisted/overdepth/empty funcs that slipped through
2571 # check for a mismatch that returned all the way to callgraph end
2589 return res
2612 continue
2616 continue
2619 break
2624 return minicg
2626 # bring the depth back to 0 with additional returns
2636 return True
2637 return False
2645 # ftrace bug: reported duration is not reliable
2646 # check each leaf and clip it at max possible length
2658 return False
2659 # calculate call length from call/return lines
2667 last = l
2669 # trace caught the whole call tree
2670 return True
2674 return False
2675 # trace ended before call tree finished
2679 # add the callgraph data to the device hierarchy
2680 borderphase = {
2683 }
2695 found = devname
2696 return found
2707 found = devname
2708 break
2709 break
2710 return found
2714 return
2718 return
2723 phase = p
2724 break
2726 return
2754 return True
2755 return False
2757 # Class: Timeline
2758 # Description:
2759 # A container for a device timeline which calculates
2760 # all the html properties to display it correctly
2762 html_tblock = '<div id="block{0}" class="tblock" style="left:{1}%;width:{2}%;"><div class="tback" style="height:{3}px"></div>\n'
2763 html_device = '<div id="{0}" title="{1}" class="thread{7}" style="left:{2}%;top:{3}px;height:{4}px;width:{5}%;{8}">{6}</div>\n'
2764 html_phase = '<div class="phase" style="left:{0}%;width:{1}%;top:{2}px;height:{3}px;background:{4}">{5}</div>\n'
2765 html_phaselet = '<div id="{0}" class="phaselet" style="left:{1}%;width:{2}%;background:{3}"></div>\n'
2766 html_legend = '<div id="p{3}" class="square" style="left:{0}%;background:{1}"> {2}</div>\n'
2778 return
2796 # Function: getDeviceRows
2797 # Description:
2798 # determine how may rows the device funcs will take
2799 # Arguments:
2800 # rawlist: the list of devices/actions for a single phase
2801 # Output:
2802 # The total number of rows needed to display this phase of the timeline
2804 # clear all rows and set them to undefined
2813 # try to pack each row with as many ranges as possible
2819 continue
2829 break
2835 return row
2836 # Function: getPhaseRows
2837 # Description:
2838 # Organize the timeline entries into the smallest
2839 # number of rows possible, with no entry overlapping
2840 # Arguments:
2841 # devlist: the list of devices/actions in a group of contiguous phases
2842 # Output:
2843 # The total number of rows needed to display this phase of the timeline
2845 # clear all rows and set them to undefined
2849 myphases = []
2850 # initialize all device rows to -1 and calculate devrows
2858 # sort by start 1st, then length 2nd
2861 # sort by length 1st, then name 2nd
2865 # sort the devlist by length so that large items graph on top
2867 orderedlist = []
2874 # try to pack each row with as many devices as possible
2891 break
2906 # section headers should use a different row height
2916 return row
2923 break
2925 return top
2927 # Calculate the heights and offsets for the header and rows
2929 standardphases = []
2936 maxrows = total
2941 # if there is 1 line per row, draw them the standard way
2946 # Create bounding box, add buttons
2947 html_zoombox = '<center><button id="zoomin">ZOOM IN +</button><button id="zoomout">ZOOM OUT -</button><button id="zoomdef">ZOOM 1:1</button></center>\n'
2948 html_timeline = '<div id="dmesgzoombox" class="zoombox">\n<div id="{0}" class="timeline" style="height:{1}px">\n'
2949 html_devlist1 = '<button id="devlist1" class="devlist" style="float:left;">Device Detail{0}</button>'
2950 html_devlist2 = '<button id="devlist2" class="devlist" style="float:right;">Device Detail2</button>\n'
2959 # Function: createTimeScale
2960 # Description:
2961 # Create the timescale for a timeline block
2962 # Arguments:
2963 # m0: start time (mode begin)
2964 # mMax: end time (mode end)
2965 # tTotal: total timeline time
2966 # mode: suspend or resume
2967 # Output:
2968 # The html code needed to display the time scale
2971 rline = '<div class="t" style="left:0;border-left:1px solid black;border-right:0;">{0}</div>\n'
2973 # set scale for timeline
2988 val = mode
2996 output += htmlline
2999 # Class: TestProps
3000 # Description:
3001 # A list of values describing the properties of these test runs
3005 r' (?P<host>.*) (?P<mode>.*) (?P<kernel>.*)$'
3018 ftrace_line_fmt_fg = \
3021 r'[ +!#\*@$]*(?P<dur>[0-9\.]*) .*\| (?P<msg>.*)'
3022 ftrace_line_fmt_nop = \
3025 r'(?P<msg>.*)'
3053 return True
3056 return True
3059 return True
3062 return True
3065 return True
3068 return True
3071 return True
3074 return True
3078 return True
3082 return True
3083 return False
3085 # global test data
3100 continue
3119 break
3124 # firmware data
3131 # turbostat data
3136 # wifi data
3143 # sleep mode enter errors
3154 continue
3162 return props
3166 return
3174 return
3178 return
3181 return
3184 return
3189 # Class: TestRun
3190 # Description:
3191 # A container for a suspend/resume test run. This is necessary as
3192 # there could be more than one, and they need to be separate.
3250 # ----------------- FUNCTIONS --------------------
3252 # Function: doesTraceLogHaveTraceEvents
3253 # Description:
3254 # Quickly determine if the ftrace log has all of the trace events,
3255 # markers, and/or kprobes required for primary parsing.
3263 # check for kprobes
3268 # check for all necessary trace events
3273 techeck = check
3274 # check for all necessary trace markers
3279 tmcheck = check
3284 # Function: appendIncompleteTraceLog
3285 # Description:
3286 # Adds callgraph data which lacks trace event data. This is only
3287 # for timelines generated from 3.15 or older
3288 # Arguments:
3289 # testruns: the array of Data objects obtained from parseKernelLog
3291 # create TestRun vessels for ftrace parsing
3294 testrun = []
3298 # extract the callgraph and traceevent data
3305 # remove any latent carriage returns
3308 continue
3309 # parse only valid lines, if this is not one move on
3312 continue
3313 # gather the basic message data from the line
3325 continue
3326 # the line should be a call, return, or event
3328 continue
3329 # look for the suspend start marker
3334 continue
3336 continue
3337 # find the end of resume
3342 break
3343 continue
3344 # trace event processing
3346 continue
3347 # call/return processing
3349 # create a callgraph object for the data
3353 # when the call is finished, see which device matches it
3363 # add the callgraph data to the device hierarchy
3367 continue
3372 continue
3385 break
3387 # Function: loadTraceLog
3388 # Description:
3389 # load the ftrace file into memory and fix up any ordering issues
3390 # Output:
3391 # TestProps instance and an array of lines in proper order
3396 # remove any latent carriage returns
3399 continue
3400 # ignore all other commented lines
3402 continue
3403 # ftrace line: parse only valid lines
3406 continue
3410 # group the data by timestamp
3416 # we only care about trace event ordering
3424 # move certain lines to the start or end of a timestamp block
3442 # Function: parseTraceLog
3443 # Description:
3444 # Analyze an ftrace log output file generated from this app during
3445 # the execution phase. Used when the ftrace log is the primary data source
3446 # and includes the suspend_resume and device_pm_callback trace events
3447 # The ftrace filename is taken from sysvals
3448 # Output:
3449 # An array of Data objects
3465 # extract the callgraph and traceevent data
3472 # gather the basic message data from the line
3477 continue
3478 # the line should be a call, return, or event
3480 continue
3481 # find the start of suspend
3491 continue
3493 continue
3494 # process cpu exec line
3515 continue
3523 continue
3524 # find the end of resume
3530 # no trace markers? then quit and be sure to finish recording
3531 # the event we used to trigger resume end
3533 # if an entry exists, assume this is its end
3536 continue
3537 # trace event processing
3540 # suspend_resume trace events have two types, begin and end
3546 continue
3552 # ignore these events
3554 continue
3555 # -- phase changes --
3556 # start of kernel suspend
3560 continue
3561 # suspend_prepare start
3567 continue
3569 continue
3570 # suspend start
3573 continue
3574 # suspend_late start
3577 continue
3578 # suspend_noirq start
3581 continue
3582 # suspend_machine/resume_machine
3588 # trim out s2idle loops, track time trying to freeze
3598 continue
3606 continue
3614 continue
3615 # resume_noirq start
3618 continue
3619 # resume_early start
3622 continue
3623 # resume start
3626 continue
3627 # resume complete start
3630 continue
3631 # skip trace events inside devices calls
3633 continue
3634 # global events (outside device calls) are graphed
3637 # special handling for s2idle_enter
3649 continue
3651 # create a new list entry
3656 # if an entry exists, assume this is its end
3658 # device callback start
3661 continue
3665 continue
3673 # device callback finish
3676 continue
3679 continue
3685 # kprobe event processing
3690 # displayname is generated from kprobe data
3695 continue
3705 })
3706 # start of kernel resume
3712 continue
3715 continue
3718 continue
3721 # end of kernel resume
3727 # callgraph processing
3729 # create a callgraph object for the data
3734 # when the call is finished, see which device matches it
3760 # dev source and procmon events can be unreadable with mixed phase height
3764 # expand phase boundaries so there are no gaps
3770 lp = p
3775 # find the total time range for this test (begin, end)
3779 # add the process usage data to the timeline
3782 # add the traceevent data to the device hierarchy
3784 # add actual trace funcs
3788 continue
3789 title = name
3793 # add the kprobe based virtual tracefuncs as actual devices
3797 continue
3803 continue
3806 # add config base kprobes and dev kprobes
3811 continue
3815 continue
3819 # add the callgraph data to the device hierarchy
3825 continue
3830 continue
3831 # match cg data to devices
3841 # create blocks for orphan cg data
3846 sysvals.vprint('Callgraph found for task %d: %.3fms, %s' % (cg.pid, (cg.end - cg.start)*1000, name))
3851 # fill in any missing phases
3852 error = []
3877 lp = p
3897 # x2: merge any overlapping devices between test runs
3907 # Function: loadKernelLog
3908 # Description:
3909 # load the dmesg file into memory and fix up any ordering issues
3910 # Output:
3911 # An array of empty Data objects with only their dmesgtext attributes set
3918 # there can be multiple test runs in a single file
3921 testruns = []
3930 continue
3933 continue
3942 continue
3964 # fix lines with same timestamp/function with the call and return swapped
3975 last = line
3976 return testruns
3978 # Function: parseKernelLog
3979 # Description:
3980 # Analyse a dmesg log output file generated from this app during
3981 # the execution phase. Create a set of device structures in memory
3982 # for subsequent formatting in the html output file
3983 # This call is only for legacy support on kernels where the ftrace
3984 # data lacks the suspend_resume or device_pm_callbacks trace events.
3985 # Arguments:
3986 # data: an empty Data object (with dmesgtext) obtained from loadKernelLog
3987 # Output:
3988 # The filled Data object
3996 # dmesg phase match table
3997 dm = {
4021 }
4023 # action table (expected events that occur and show up in dmesg)
4024 at = {
4040 }
4047 # parse each dmesg line into the time and message
4054 continue
4056 # initialize data start to first line time
4059 t0 = ktime
4061 continue
4063 # check for a phase change line
4070 break
4072 # hack for determining resume_machine end for freeze
4143 break
4145 # -- device callbacks --
4147 # device init call
4152 # device init return
4161 # if trace events are not available, these are better than nothing
4163 # look for known actions
4171 # now look for CPU on/off events
4173 # start of first cpu suspend
4174 cpu_start = ktime
4176 # start of first cpu resume
4177 cpu_start = ktime
4180 # end of a cpu suspend, start of the next
4188 cpu_start = ktime
4190 # end of a cpu resume, start of the next
4196 cpu_start = ktime
4197 prevktime = ktime
4200 # fill in any missing phases
4215 lp = p
4220 lp = p
4226 # fill in any actions we've found
4234 return True
4237 html_func_top = '<article id="{0}" class="atop" style="background:{1}">\n<input type="checkbox" class="pf" id="f{2}" checked/><label for="f{2}">{3} {4}</label>\n'
4238 html_func_start = '<article>\n<input type="checkbox" class="pf" id="f{0}" checked/><label for="f{0}">{1} {2}</label>\n'
4242 cgid = devid
4247 return num
4261 continue
4269 return num
4273 # write out the ftrace data converted to html
4277 continue
4281 continue
4313 .stamp {width: 100%;text-align:center;background:#888;line-height:30px;color:white;font: 25px Arial;}\n\
4325 return out
4327 # Function: createHTMLSummarySimple
4328 # Description:
4329 # Create summary html file for a series of tests
4330 # Arguments:
4331 # testruns: array of Data objects from parseTraceLog
4333 # write the html header first (html head, css code, up to body start)
4336 # extract the test data into list
4390 lastmode = mode
4401 # group test header
4402 desc = []
4406 html += '<div class="stamp">%s (%d tests: %s)</div>\n' % (title, len(testruns), ', '.join(desc))
4418 # table header
4430 # export list into html
4444 # header line for each suspend mode
4455 )
4460 # row classes - alternate row color
4465 # figure out if the line has sus or res highlighted
4498 # flush the data to file
4506 # create global device list from all tests
4528 # generate the html
4537 # table header
4549 continue
4550 # row classes - alternate row color
4563 # flush the data to file
4567 return devall
4574 # generate the html
4589 links = []
4594 # row classes - alternate row color
4607 # flush the data to file
4611 return issues
4624 # Function: createHTML
4625 # Description:
4626 # Create the output html file from the resident test data
4627 # Arguments:
4628 # testruns: array of Data objects from parseKernelLog or parseTraceLog
4629 # Output:
4630 # True if the html file was created, false if it failed
4634 return
4645 # html function templates
4646 html_error = '<div id="{1}" title="kernel error/warning" class="err" style="right:{0}%">{2}→</div>\n'
4647 html_traceevent = '<div title="{0}" class="traceevent{6}" style="left:{1}%;top:{2}px;height:{3}px;width:{4}%;line-height:{3}px;{7}">{5}</div>\n'
4648 html_cpuexec = '<div class="jiffie" style="left:{0}%;top:{1}px;height:{2}px;width:{3}%;background:{4};"></div>\n'
4655 '<td class="gray" title="time spent in low-power mode with clock running">'+sysvals.suspendmode+' time: <b>{1} ms</b></td>'\
4663 html_kdesc = '<td class="{3}" title="time spent in kernel execution">{0}Kernel {2}: {1} ms</td>'
4665 html_wifdesc = '<td class="yellow" title="time for wifi to reconnect after resume complete ({2})">{0}Wifi Resume: {1}</td>'
4667 # html format variables
4672 # device timeline
4675 # write the test title and general info header
4678 # Generate the header for this timeline
4693 continue
4694 # typical full suspend/resume header
4724 continue
4725 # extra detail when the times come from multiple sources
4745 # time scale for potentially multiple datasets
4750 # determine the maximum number of rows we need to draw
4751 fulllist = []
4752 threadlist = []
4758 devlist = []
4790 # draw the full timeline
4793 # draw each test run and block chronologically
4800 # now draw the actual timeline blocks
4802 # draw suspend and resume blocks separately
4811 # in an x2 run, remove any gap between blocks
4816 # if a timeline block is 0 length, skip altogether
4818 continue
4822 # draw the phase color background
4831 # draw red lines for any kernel errors found
4837 # draw the devices for this phase
4870 title += b
4885 continue
4886 # draw any trace events for this device
4889 continue
4900 # draw the time scale, try to make the number of labels readable
4904 # timeline is finished
4907 # draw a legend which describes the phases by color
4925 # write the device timeline
4929 # draw the colored boxes for the device detail section
4949 # write the ftrace data (callgraph)
4957 # add the test log as a hidden div
4960 # add the dmesg log as a hidden div
4969 # add the ftrace log as a hidden div
4978 # write the footer and close
4982 return True
4992 # various format changes by flags
5011 # write the html header first (html head, css code, up to body start)
5017 .stamp {width:100%;text-align:center;background:gray;line-height:30px;color:white;font:25px Arial;}\n\
5035 .time2 {font:15px Arial;border-bottom:1px solid;border-left:1px solid;border-right:1px solid;}\n\
5043 .pf:'+cgchk+' + label {background:url(\'data:image/svg+xml;utf,<?xml version="1.0" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" height="18" width="18" version="1.1"><circle cx="9" cy="9" r="8" stroke="black" stroke-width="1" fill="white"/><rect x="4" y="8" width="10" height="2" style="fill:black;stroke-width:0"/><rect x="8" y="4" width="2" height="10" style="fill:black;stroke-width:0"/></svg>\') no-repeat left center;}\n\
5044 .pf:'+cgnchk+' ~ label {background:url(\'data:image/svg+xml;utf,<?xml version="1.0" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" height="18" width="18" version="1.1"><circle cx="9" cy="9" r="8" stroke="black" stroke-width="1" fill="white"/><rect x="4" y="8" width="10" height="2" style="fill:black;stroke-width:0"/></svg>\') no-repeat left center;}\n\
5046 .zoombox {position:relative;width:100%;overflow-x:scroll;-webkit-user-select:none;-moz-user-select:none;user-select:none;}\n\
5047 .timeline {position:relative;font-size:14px;cursor:pointer;width:100%; overflow:hidden;background:linear-gradient(#cccccc, white);}\n\
5048 .thread {position:absolute;height:0%;overflow:hidden;z-index:7;line-height:30px;font-size:14px;border:1px solid;text-align:center;white-space:nowrap;}\n\
5051 .thread.sec,.thread.sec:hover {background:black;border:0;color:white;line-height:15px;font-size:10px;}\n\
5056 .traceevent {position:absolute;font-size:10px;z-index:7;overflow:hidden;color:black;text-align:center;white-space:nowrap;border-radius:5px;border:1px solid black;background:linear-gradient(to bottom right,#CCC,#969696);}\n\
5059 .phaselet {float:left;overflow:hidden;border:0px;text-align:center;min-height:100px;font-size:24px;}\n\
5060 .t {position:absolute;line-height:'+('%d'%scaleTH)+'px;pointer-events:none;top:0;height:100%;border-right:1px solid black;z-index:6;}\n\
5061 .err {position:absolute;top:0%;height:100%;border-right:3px solid red;color:red;font:bold 14px Times;line-height:18px;}\n\
5063 .legend .square {position:absolute;cursor:pointer;top:10px; width:0px;height:20px;border:1px solid;padding-left:20px;}\n\
5065 .btnfmt {position:relative;float:right;height:25px;width:auto;margin-top:3px;margin-bottom:0;font-size:10px;text-align:center;}\n\
5071 .version {position:relative;float:left;color:white;font-size:10px;line-height:30px;margin-left:10px;}\n\
5080 # Function: addScriptCode
5081 # Description:
5082 # Adds the javascript code to the output html
5083 # Arguments:
5084 # hf: the open html file pointer
5085 # testruns: array of Data objects from parseKernelLog or parseTraceLog
5090 # create an array in javascript memory with the device details
5096 # add the code which will manipulate the data in the browser
5099 var dragval = [0, 0];
5100 function redrawTimescale(t0, tMax, tS) {
5101 var rline = '<div class="t" style="left:0;border-left:1px solid black;border-right:0;">';
5102 var tTotal = tMax - t0;
5103 var list = document.getElementsByClassName("tblock");
5104 for (var i = 0; i < list.length; i++) {
5105 var timescale = list[i].getElementsByClassName("timescale")[0];
5106 var m0 = t0 + (tTotal*parseFloat(list[i].style.left)/100);
5107 var mTotal = tTotal*parseFloat(list[i].style.width)/100;
5108 var mMax = m0 + mTotal;
5109 var html = "";
5110 var divTotal = Math.floor(mTotal/tS) + 1;
5111 if(divTotal > 1000) continue;
5112 var divEdge = (mTotal - tS*(divTotal-1))*100/mTotal;
5113 var pos = 0.0, val = 0.0;
5114 for (var j = 0; j < divTotal; j++) {
5115 var htmlline = "";
5116 var mode = list[i].id[5];
5117 if(mode == "s") {
5118 pos = 100 - (((j)*tS*100)/mTotal) - divEdge;
5119 val = (j-divTotal+1)*tS;
5120 if(j == divTotal - 1)
5121 htmlline = '<div class="t" style="right:'+pos+'%"><cS>S→</cS></div>';
5122 else
5123 htmlline = '<div class="t" style="right:'+pos+'%">'+val+'ms</div>';
5124 } else {
5125 pos = 100 - (((j)*tS*100)/mTotal);
5126 val = (j)*tS;
5127 htmlline = '<div class="t" style="right:'+pos+'%">'+val+'ms</div>';
5128 if(j == 0)
5129 if(mode == "r")
5130 htmlline = rline+"<cS>←R</cS></div>";
5131 else
5132 htmlline = rline+"<cS>0ms</div>";
5133 }
5134 html += htmlline;
5135 }
5136 timescale.innerHTML = html;
5137 }
5138 }
5139 function zoomTimeline() {
5140 var dmesg = document.getElementById("dmesg");
5141 var zoombox = document.getElementById("dmesgzoombox");
5142 var left = zoombox.scrollLeft;
5143 var val = parseFloat(dmesg.style.width);
5144 var newval = 100;
5145 var sh = window.outerWidth / 2;
5146 if(this.id == "zoomin") {
5147 newval = val * 1.2;
5148 if(newval > 910034) newval = 910034;
5149 dmesg.style.width = newval+"%";
5150 zoombox.scrollLeft = ((left + sh) * newval / val) - sh;
5151 } else if (this.id == "zoomout") {
5152 newval = val / 1.2;
5153 if(newval < 100) newval = 100;
5154 dmesg.style.width = newval+"%";
5155 zoombox.scrollLeft = ((left + sh) * newval / val) - sh;
5156 } else {
5157 zoombox.scrollLeft = 0;
5158 dmesg.style.width = "100%";
5159 }
5160 var tS = [10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1];
5161 var t0 = bounds[0];
5162 var tMax = bounds[1];
5163 var tTotal = tMax - t0;
5164 var wTotal = tTotal * 100.0 / newval;
5165 var idx = 7*window.innerWidth/1100;
5166 for(var i = 0; (i < tS.length)&&((wTotal / tS[i]) < idx); i++);
5167 if(i >= tS.length) i = tS.length - 1;
5168 if(tS[i] == resolution) return;
5169 resolution = tS[i];
5170 redrawTimescale(t0, tMax, tS[i]);
5171 }
5172 function deviceName(title) {
5173 var name = title.slice(0, title.indexOf(" ("));
5174 return name;
5175 }
5176 function deviceHover() {
5177 var name = deviceName(this.title);
5178 var dmesg = document.getElementById("dmesg");
5179 var dev = dmesg.getElementsByClassName("thread");
5180 var cpu = -1;
5181 if(name.match("CPU_ON\[[0-9]*\]"))
5182 cpu = parseInt(name.slice(7));
5183 else if(name.match("CPU_OFF\[[0-9]*\]"))
5184 cpu = parseInt(name.slice(8));
5185 for (var i = 0; i < dev.length; i++) {
5186 dname = deviceName(dev[i].title);
5187 var cname = dev[i].className.slice(dev[i].className.indexOf("thread"));
5188 if((cpu >= 0 && dname.match("CPU_O[NF]*\\[*"+cpu+"\\]")) ||
5189 (name == dname))
5190 {
5191 dev[i].className = "hover "+cname;
5192 } else {
5193 dev[i].className = cname;
5194 }
5195 }
5196 }
5197 function deviceUnhover() {
5198 var dmesg = document.getElementById("dmesg");
5199 var dev = dmesg.getElementsByClassName("thread");
5200 for (var i = 0; i < dev.length; i++) {
5201 dev[i].className = dev[i].className.slice(dev[i].className.indexOf("thread"));
5202 }
5203 }
5204 function deviceTitle(title, total, cpu) {
5205 var prefix = "Total";
5206 if(total.length > 3) {
5207 prefix = "Average";
5208 total[1] = (total[1]+total[3])/2;
5209 total[2] = (total[2]+total[4])/2;
5210 }
5211 var devtitle = document.getElementById("devicedetailtitle");
5212 var name = deviceName(title);
5213 if(cpu >= 0) name = "CPU"+cpu;
5214 var driver = "";
5215 var tS = "<t2>(</t2>";
5216 var tR = "<t2>)</t2>";
5217 if(total[1] > 0)
5218 tS = "<t2>("+prefix+" Suspend:</t2><t0> "+total[1].toFixed(3)+" ms</t0> ";
5219 if(total[2] > 0)
5220 tR = " <t2>"+prefix+" Resume:</t2><t0> "+total[2].toFixed(3)+" ms<t2>)</t2></t0>";
5221 var s = title.indexOf("{");
5222 var e = title.indexOf("}");
5223 if((s >= 0) && (e >= 0))
5224 driver = title.slice(s+1, e) + " <t1>@</t1> ";
5225 if(total[1] > 0 && total[2] > 0)
5226 devtitle.innerHTML = "<t0>"+driver+name+"</t0> "+tS+tR;
5227 else
5228 devtitle.innerHTML = "<t0>"+title+"</t0>";
5229 return name;
5230 }
5231 function deviceDetail() {
5232 var devinfo = document.getElementById("devicedetail");
5233 devinfo.style.display = "block";
5234 var name = deviceName(this.title);
5235 var cpu = -1;
5236 if(name.match("CPU_ON\[[0-9]*\]"))
5237 cpu = parseInt(name.slice(7));
5238 else if(name.match("CPU_OFF\[[0-9]*\]"))
5239 cpu = parseInt(name.slice(8));
5240 var dmesg = document.getElementById("dmesg");
5241 var dev = dmesg.getElementsByClassName("thread");
5242 var idlist = [];
5243 var pdata = [[]];
5244 if(document.getElementById("devicedetail1"))
5245 pdata = [[], []];
5246 var pd = pdata[0];
5247 var total = [0.0, 0.0, 0.0];
5248 for (var i = 0; i < dev.length; i++) {
5249 dname = deviceName(dev[i].title);
5250 if((cpu >= 0 && dname.match("CPU_O[NF]*\\[*"+cpu+"\\]")) ||
5251 (name == dname))
5252 {
5253 idlist[idlist.length] = dev[i].id;
5254 var tidx = 1;
5255 if(dev[i].id[0] == "a") {
5256 pd = pdata[0];
5257 } else {
5258 if(pdata.length == 1) pdata[1] = [];
5259 if(total.length == 3) total[3]=total[4]=0.0;
5260 pd = pdata[1];
5261 tidx = 3;
5262 }
5263 var info = dev[i].title.split(" ");
5264 var pname = info[info.length-1];
5265 var length = parseFloat(info[info.length-3].slice(1));
5266 if (pname in pd)
5267 pd[pname] += length;
5268 else
5269 pd[pname] = length;
5270 total[0] += length;
5271 if(pname.indexOf("suspend") >= 0)
5272 total[tidx] += length;
5273 else
5274 total[tidx+1] += length;
5275 }
5276 }
5277 var devname = deviceTitle(this.title, total, cpu);
5278 var left = 0.0;
5279 for (var t = 0; t < pdata.length; t++) {
5280 pd = pdata[t];
5281 devinfo = document.getElementById("devicedetail"+t);
5282 var phases = devinfo.getElementsByClassName("phaselet");
5283 for (var i = 0; i < phases.length; i++) {
5284 if(phases[i].id in pd) {
5285 var w = 100.0*pd[phases[i].id]/total[0];
5286 var fs = 32;
5287 if(w < 8) fs = 4*w | 0;
5288 var fs2 = fs*3/4;
5289 phases[i].style.width = w+"%";
5290 phases[i].style.left = left+"%";
5291 phases[i].title = phases[i].id+" "+pd[phases[i].id]+" ms";
5292 left += w;
5294 var pname = "<t3 style=\"font-size:"+fs2+"px\">"+phases[i].id.replace(new RegExp("_", "g"), " ")+"</t3>";
5295 phases[i].innerHTML = time+pname;
5296 } else {
5299 }
5300 }
5301 }
5302 if(typeof devstats !== 'undefined')
5303 callDetail(this.id, this.title);
5305 if(!cglist) return;
5307 if(cg.length < 10) return;
5308 for (var i = 0; i < cg.length; i++) {
5310 if(idlist.indexOf(cgid) >= 0) {
5312 } else {
5314 }
5315 }
5316 }
5317 function callDetail(devid, devtitle) {
5318 if(!(devid in devstats) || devstats[devid].length < 1)
5319 return;
5320 var list = devstats[devid];
5322 var name = tmp[0], phase = tmp[tmp.length-1];
5323 var dd = document.getElementById(phase);
5324 var total = parseFloat(tmp[1].slice(1));
5325 var mlist = [];
5326 var maxlen = 0;
5327 var info = []
5328 for(var i in list) {
5331 continue;
5332 }
5334 var t = parseFloat(tmp[0]), f = tmp[1], c = parseInt(tmp[2]);
5335 var p = (t*100.0/total).toFixed(2);
5337 if(f.length > maxlen)
5338 maxlen = f.length;
5339 }
5340 var pad = 5;
5341 if(mlist.length == 0) pad = 30;
5343 if(info.length > 2)
5345 if(info.length > 3)
5347 if(info.length > 4)
5350 if(mlist.length > 0) {
5352 for(var i in mlist)
5355 for(var i in mlist)
5358 for(var i in mlist)
5361 for(var i in mlist)
5364 }
5365 dd.innerHTML = html;
5366 var height = (maxlen*5)+100;
5369 }
5370 function callSelect() {
5372 if(!cglist) return;
5374 for (var i = 0; i < cg.length; i++) {
5375 if(this.id == cg[i].id) {
5377 } else {
5379 }
5380 }
5381 }
5382 function devListWindow(e) {
5383 var win = window.open();
5388 var dt = devtable[0];
5390 dt = devtable[1];
5391 win.document.write(html+dt);
5392 }
5393 function errWindow() {
5395 var idx1 = parseInt(range[0]);
5396 var idx2 = parseInt(range[1]);
5397 var win = window.open();
5402 for(var i = 0; i < text.length; i++) {
5403 if(i == idx1) {
5405 } else if(i > idx1 && i <= idx2) {
5407 } else {
5409 }
5410 }
5414 }
5422 }
5427 }
5431 }
5434 }
5446 }
5471 }
5476 });
5478 hf.write(script_code);
5480 # Function: executeSuspend
5481 # Description:
5482 # Execute system suspend through the sysfs interface, then copy the output
5483 # dmesg and ftrace files to the test output directory.
5484 def executeSuspend(quiet=False):
5485 sv, tp, pm = sysvals, sysvals.tpath, ProcessMonitor()
5486 if sv.wifi:
5487 wifi = sv.checkWifi()
5489 testdata = []
5490 # run these commands to prepare the system for suspend
5491 if sv.display:
5492 if not quiet:
5494 ret = sv.displayControl(sv.display)
5496 time.sleep(1)
5497 if sv.sync:
5498 if not quiet:
5499 pprint('SYNCING FILESYSTEMS')
5500 sv.dlog('syncing filesystems')
5501 call('sync', shell=True)
5502 sv.dlog('read dmesg')
5503 sv.initdmesg()
5504 sv.dlog('cmdinfo before')
5505 sv.cmdinfo(True)
5506 sv.start(pm)
5507 # execute however many s/r runs requested
5508 for count in range(1,sv.execcount+1):
5509 # x2delay in between test runs
5510 if(count > 1 and sv.x2delay > 0):
5512 time.sleep(sv.x2delay/1000.0)
5513 sv.fsetVal('WAIT END', 'trace_marker')
5514 # start message
5515 if sv.testcommand != '':
5516 pprint('COMMAND START')
5517 else:
5518 if(sv.rtcwake):
5519 pprint('SUSPEND START')
5520 else:
5521 pprint('SUSPEND START (press a key to resume)')
5522 # set rtcwake
5523 if(sv.rtcwake):
5524 if not quiet:
5526 sv.dlog('enable RTC wake alarm')
5527 sv.rtcWakeAlarmOn()
5528 # start of suspend trace marker
5529 sv.fsetVal(datetime.now().strftime(sv.tmstart), 'trace_marker')
5530 # predelay delay
5531 if(count == 1 and sv.predelay > 0):
5533 time.sleep(sv.predelay/1000.0)
5534 sv.fsetVal('WAIT END', 'trace_marker')
5535 # initiate suspend or command
5536 sv.dlog('system executing a suspend')
5537 tdata = {'error': ''}
5538 if sv.testcommand != '':
5539 res = call(sv.testcommand+' 2>&1', shell=True);
5540 if res != 0:
5542 else:
5543 s0ixready = sv.s0ixSupport()
5544 mode = sv.suspendmode
5545 if sv.memmode and os.path.exists(sv.mempowerfile):
5546 mode = 'mem'
5547 sv.testVal(sv.mempowerfile, 'radio', sv.memmode)
5548 if sv.diskmode and os.path.exists(sv.diskpowerfile):
5549 mode = 'disk'
5550 sv.testVal(sv.diskpowerfile, 'radio', sv.diskmode)
5551 if sv.acpidebug:
5552 sv.testVal(sv.acpipath, 'acpi', '0xe')
5553 if ((mode == 'freeze') or (sv.memmode == 's2idle')) \
5554 and sv.haveTurbostat():
5555 # execution will pause here
5556 retval, turbo = sv.turbostat(s0ixready)
5557 if retval != 0:
5559 if turbo:
5560 tdata['turbo'] = turbo
5561 else:
5562 pf = open(sv.powerfile, 'w')
5563 pf.write(mode)
5564 # execution will pause here
5565 try:
5566 pf.flush()
5567 pf.close()
5568 except Exception as e:
5569 tdata['error'] = str(e)
5570 sv.fsetVal('CMD COMPLETE', 'trace_marker')
5571 sv.dlog('system returned')
5572 # reset everything
5573 sv.testVal('restoreall')
5574 if(sv.rtcwake):
5575 sv.dlog('disable RTC wake alarm')
5576 sv.rtcWakeAlarmOff()
5577 # postdelay delay
5578 if(count == sv.execcount and sv.postdelay > 0):
5580 time.sleep(sv.postdelay/1000.0)
5581 sv.fsetVal('WAIT END', 'trace_marker')
5582 # return from suspend
5583 pprint('RESUME COMPLETE')
5584 if(count < sv.execcount):
5585 sv.fsetVal(datetime.now().strftime(sv.tmend), 'trace_marker')
5586 elif(not sv.wifitrace):
5587 sv.fsetVal(datetime.now().strftime(sv.tmend), 'trace_marker')
5588 sv.stop(pm)
5589 if sv.wifi and wifi:
5590 tdata['wifi'] = sv.pollWifi(wifi)
5592 if(count == sv.execcount and sv.wifitrace):
5593 sv.fsetVal(datetime.now().strftime(sv.tmend), 'trace_marker')
5594 sv.stop(pm)
5595 if sv.netfix:
5596 tdata['netfix'] = sv.netfixon()
5598 if(sv.suspendmode == 'mem' or sv.suspendmode == 'command'):
5599 sv.dlog('read the ACPI FPDT')
5600 tdata['fw'] = getFPDT(False)
5601 testdata.append(tdata)
5602 sv.dlog('cmdinfo after')
5603 cmdafter = sv.cmdinfo(False)
5604 # grab a copy of the dmesg output
5605 if not quiet:
5606 pprint('CAPTURING DMESG')
5607 sv.getdmesg(testdata)
5608 # grab a copy of the ftrace output
5609 if sv.useftrace:
5610 if not quiet:
5611 pprint('CAPTURING TRACE')
5612 op = sv.writeDatafileHeader(sv.ftracefile, testdata)
5613 fp = open(tp+'trace', 'rb')
5614 op.write(ascii(fp.read()))
5615 op.close()
5616 sv.fsetVal('', 'trace')
5617 sv.platforminfo(cmdafter)
5619 def readFile(file):
5620 if os.path.islink(file):
5621 return os.readlink(file).split('/')[-1]
5622 else:
5623 return sysvals.getVal(file).strip()
5625 # Function: ms2nice
5626 # Description:
5627 # Print out a very concise time string in minutes and seconds
5628 # Output:
5629 # The time string, e.g. "1901m16s"
5630 def ms2nice(val):
5631 val = int(val)
5632 h = val // 3600000
5633 m = (val // 60000) % 60
5634 s = (val // 1000) % 60
5635 if h > 0:
5637 if m > 0:
5641 def yesno(val):
5642 list = {'enabled':'A', 'disabled':'S', 'auto':'E', 'on':'D',
5643 'active':'A', 'suspended':'S', 'suspending':'S'}
5644 if val not in list:
5645 return ' '
5646 return list[val]
5648 # Function: deviceInfo
5649 # Description:
5650 # Detect all the USB hosts and devices currently connected and add
5651 # a list of USB device names to sysvals for better timeline readability
5652 def deviceInfo(output=''):
5653 if not output:
5655 '---------------------------------------------------------------------------------------------\n'\
5660 '---------------------------------------------------------------------------------------------\n'\
5662 '---------------------------------------------------------------------------------------------')
5664 res = []
5665 tgtval = 'runtime_status'
5666 lines = dict()
5667 for dirname, dirnames, filenames in os.walk('/sys/devices'):
5668 if(not re.match(r'.*/power', dirname) or
5669 'control' not in filenames or
5670 tgtval not in filenames):
5671 continue
5672 name = ''
5673 dirname = dirname[:-6]
5674 device = dirname.split('/')[-1]
5675 power = dict()
5677 # only list devices which support runtime suspend
5678 if power[tgtval] not in ['active', 'suspended', 'suspending']:
5679 continue
5680 for i in ['product', 'driver', 'subsystem']:
5682 if os.path.exists(file):
5683 name = readFile(file)
5684 break
5685 for i in ['async', 'control', 'runtime_status', 'runtime_usage',
5686 'runtime_active_kids', 'runtime_active_time',
5687 'runtime_suspended_time']:
5688 if i in filenames:
5690 if output:
5691 if power['control'] == output:
5693 continue
5695 (device[:26], name[:26],
5696 yesno(power['async']), \
5697 yesno(power['control']), \
5698 yesno(power['runtime_status']), \
5699 power['runtime_usage'], \
5700 power['runtime_active_kids'], \
5701 ms2nice(power['runtime_active_time']), \
5702 ms2nice(power['runtime_suspended_time']))
5703 for i in sorted(lines):
5704 print(lines[i])
5705 return res
5707 # Function: getModes
5708 # Description:
5709 # Determine the supported power modes on this system
5710 # Output:
5711 # A string list of the available modes
5712 def getModes():
5713 modes = []
5714 if(os.path.exists(sysvals.powerfile)):
5715 fp = open(sysvals.powerfile, 'r')
5716 modes = fp.read().split()
5717 fp.close()
5718 if(os.path.exists(sysvals.mempowerfile)):
5719 deep = False
5720 fp = open(sysvals.mempowerfile, 'r')
5721 for m in fp.read().split():
5722 memmode = m.strip('[]')
5723 if memmode == 'deep':
5724 deep = True
5725 else:
5727 fp.close()
5728 if 'mem' in modes and not deep:
5729 modes.remove('mem')
5730 if('disk' in modes and os.path.exists(sysvals.diskpowerfile)):
5731 fp = open(sysvals.diskpowerfile, 'r')
5732 for m in fp.read().split():
5734 fp.close()
5735 return modes
5737 def dmidecode_backup(out, fatal=False):
5738 cpath, spath, info = '/proc/cpuinfo', '/sys/class/dmi/id', {
5739 'bios-vendor': 'bios_vendor',
5740 'bios-version': 'bios_version',
5741 'bios-release-date': 'bios_date',
5742 'system-manufacturer': 'sys_vendor',
5743 'system-product-name': 'product_name',
5744 'system-version': 'product_version',
5745 'system-serial-number': 'product_serial',
5746 'baseboard-manufacturer': 'board_vendor',
5747 'baseboard-product-name': 'board_name',
5748 'baseboard-version': 'board_version',
5749 'baseboard-serial-number': 'board_serial',
5750 'chassis-manufacturer': 'chassis_vendor',
5751 'chassis-version': 'chassis_version',
5752 'chassis-serial-number': 'chassis_serial',
5753 }
5754 for key in info:
5755 if key not in out:
5756 val = sysvals.getVal(os.path.join(spath, info[key])).strip()
5757 if val and val.lower() != 'to be filled by o.e.m.':
5758 out[key] = val
5759 if 'processor-version' not in out and os.path.exists(cpath):
5760 with open(cpath, 'r') as fp:
5761 for line in fp:
5762 m = re.match(r'^model\s*name\s*\:\s*(?P<c>.*)', line)
5763 if m:
5764 out['processor-version'] = m.group('c').strip()
5765 break
5766 if fatal and len(out) < 1:
5768 (sysvals.mempath, spath))
5769 return out
5771 # Function: dmidecode
5772 # Description:
5773 # Read the bios tables and pull out system info
5774 # Arguments:
5775 # mempath: /dev/mem or custom mem path
5776 # fatal: True to exit on error, False to return empty dict
5777 # Output:
5778 # A dict object with all available key/values
5779 def dmidecode(mempath, fatal=False):
5780 out = dict()
5781 if(not (os.path.exists(mempath) and os.access(mempath, os.R_OK))):
5782 return dmidecode_backup(out, fatal)
5784 # the list of values to retrieve, with hardcoded (type, idx)
5785 info = {
5786 'bios-vendor': (0, 4),
5787 'bios-version': (0, 5),
5788 'bios-release-date': (0, 8),
5789 'system-manufacturer': (1, 4),
5790 'system-product-name': (1, 5),
5791 'system-version': (1, 6),
5792 'system-serial-number': (1, 7),
5793 'baseboard-manufacturer': (2, 4),
5794 'baseboard-product-name': (2, 5),
5795 'baseboard-version': (2, 6),
5796 'baseboard-serial-number': (2, 7),
5797 'chassis-manufacturer': (3, 4),
5798 'chassis-version': (3, 6),
5799 'chassis-serial-number': (3, 7),
5800 'processor-manufacturer': (4, 7),
5801 'processor-version': (4, 16),
5802 }
5804 # by default use legacy scan, but try to use EFI first
5805 memaddr, memsize = 0xf0000, 0x10000
5806 for ep in ['/sys/firmware/efi/systab', '/proc/efi/systab']:
5807 if not os.path.exists(ep) or not os.access(ep, os.R_OK):
5808 continue
5809 fp = open(ep, 'r')
5810 buf = fp.read()
5811 fp.close()
5812 i = buf.find('SMBIOS=')
5813 if i >= 0:
5814 try:
5815 memaddr = int(buf[i+7:], 16)
5816 memsize = 0x20
5817 except:
5818 continue
5820 # read in the memory for scanning
5821 try:
5822 fp = open(mempath, 'rb')
5823 fp.seek(memaddr)
5824 buf = fp.read(memsize)
5825 except:
5826 return dmidecode_backup(out, fatal)
5827 fp.close()
5829 # search for either an SM table or DMI table
5830 i = base = length = num = 0
5831 while(i < memsize):
5832 if buf[i:i+4] == b'_SM_' and i < memsize - 16:
5833 length = struct.unpack('H', buf[i+22:i+24])[0]
5834 base, num = struct.unpack('IH', buf[i+24:i+30])
5835 break
5836 elif buf[i:i+5] == b'_DMI_':
5837 length = struct.unpack('H', buf[i+6:i+8])[0]
5838 base, num = struct.unpack('IH', buf[i+8:i+14])
5839 break
5840 i += 16
5841 if base == 0 and length == 0 and num == 0:
5842 return dmidecode_backup(out, fatal)
5844 # read in the SM or DMI table
5845 try:
5846 fp = open(mempath, 'rb')
5847 fp.seek(base)
5848 buf = fp.read(length)
5849 except:
5850 return dmidecode_backup(out, fatal)
5851 fp.close()
5853 # scan the table for the values we want
5854 count = i = 0
5855 while(count < num and i <= len(buf) - 4):
5856 type, size, handle = struct.unpack('BBH', buf[i:i+4])
5857 n = i + size
5858 while n < len(buf) - 1:
5859 if 0 == struct.unpack('H', buf[n:n+2])[0]:
5860 break
5861 n += 1
5862 data = buf[i+size:n+2].split(b'\0')
5863 for name in info:
5864 itype, idxadr = info[name]
5865 if itype == type:
5866 idx = struct.unpack('B', buf[i+idxadr:i+idxadr+1])[0]
5867 if idx > 0 and idx < len(data) - 1:
5868 s = data[idx-1].decode('utf-8')
5869 if s.strip() and s.strip().lower() != 'to be filled by o.e.m.':
5870 out[name] = s
5871 i = n + 2
5872 count += 1
5873 return out
5875 # Function: getFPDT
5876 # Description:
5877 # Read the acpi bios tables and pull out FPDT, the firmware data
5878 # Arguments:
5879 # output: True to output the info to stdout, False otherwise
5880 def getFPDT(output):
5881 rectype = {}
5882 rectype[0] = 'Firmware Basic Boot Performance Record'
5883 rectype[1] = 'S3 Performance Table Record'
5884 prectype = {}
5885 prectype[0] = 'Basic S3 Resume Performance Record'
5886 prectype[1] = 'Basic S3 Suspend Performance Record'
5888 sysvals.rootCheck(True)
5889 if(not os.path.exists(sysvals.fpdtpath)):
5890 if(output):
5892 return False
5893 if(not os.access(sysvals.fpdtpath, os.R_OK)):
5894 if(output):
5896 return False
5897 if(not os.path.exists(sysvals.mempath)):
5898 if(output):
5900 return False
5901 if(not os.access(sysvals.mempath, os.R_OK)):
5902 if(output):
5904 return False
5906 fp = open(sysvals.fpdtpath, 'rb')
5907 buf = fp.read()
5908 fp.close()
5910 if(len(buf) < 36):
5911 if(output):
5912 doError('Invalid FPDT table data, should '+\
5913 'be at least 36 bytes')
5914 return False
5916 table = struct.unpack('4sIBB6s8sI4sI', buf[0:36])
5917 if(output):
5929 '' % (ascii(table[0]), ascii(table[0]), table[1], table[2],
5930 table[3], ascii(table[4]), ascii(table[5]), table[6],
5931 ascii(table[7]), table[8]))
5933 if(table[0] != b'FPDT'):
5934 if(output):
5935 doError('Invalid FPDT table')
5936 return False
5937 if(len(buf) <= 36):
5938 return False
5939 i = 0
5940 fwData = [0, 0]
5941 records = buf[36:]
5942 try:
5943 fp = open(sysvals.mempath, 'rb')
5944 except:
5945 pprint('WARNING: /dev/mem is not readable, ignoring the FPDT data')
5946 return False
5947 while(i < len(records)):
5948 header = struct.unpack('HBB', records[i:i+4])
5949 if(header[0] not in rectype):
5950 i += header[1]
5951 continue
5952 if(header[1] != 16):
5953 i += header[1]
5954 continue
5955 addr = struct.unpack('Q', records[i+8:i+16])[0]
5956 try:
5957 fp.seek(addr)
5958 first = fp.read(8)
5959 except:
5960 if(output):
5962 return [0, 0]
5963 rechead = struct.unpack('4sI', first)
5964 recdata = fp.read(rechead[1]-8)
5965 if(rechead[0] == b'FBPT'):
5966 record = struct.unpack('HBBIQQQQQ', recdata[:48])
5967 if(output):
5974 '' % (rectype[header[0]], ascii(rechead[0]), record[4], record[5],
5975 record[6], record[7], record[8]))
5976 elif(rechead[0] == b'S3PT'):
5977 if(output):
5979 j = 0
5980 while(j < len(recdata)):
5981 prechead = struct.unpack('HBB', recdata[j:j+4])
5982 if(prechead[0] not in prectype):
5983 continue
5984 if(prechead[0] == 0):
5985 record = struct.unpack('IIQQ', recdata[j:j+prechead[1]])
5986 fwData[1] = record[2]
5987 if(output):
5992 '' % (prectype[prechead[0]], record[1],
5993 record[2], record[3]))
5994 elif(prechead[0] == 1):
5995 record = struct.unpack('QQ', recdata[j+4:j+prechead[1]])
5996 fwData[0] = record[1] - record[0]
5997 if(output):
6002 '' % (prectype[prechead[0]], record[0],
6003 record[1], fwData[0]))
6005 j += prechead[1]
6006 if(output):
6007 pprint('')
6008 i += header[1]
6009 fp.close()
6010 return fwData
6012 # Function: statusCheck
6013 # Description:
6014 # Verify that the requested command and options will work, and
6015 # print the results to the terminal
6016 # Output:
6017 # True if the test will work, False if not
6018 def statusCheck(probecheck=False):
6019 status = ''
6023 # check we have root access
6024 res = sysvals.colorText('NO (No features of this tool will work!)')
6025 if(sysvals.rootCheck(False)):
6026 res = 'YES'
6028 if(res != 'YES'):
6029 pprint(' Try running this script with sudo')
6030 return 'missing root access'
6032 # check sysfs is mounted
6033 res = sysvals.colorText('NO (No features of this tool will work!)')
6034 if(os.path.exists(sysvals.powerfile)):
6035 res = 'YES'
6037 if(res != 'YES'):
6038 return 'sysfs is missing'
6040 # check target mode is a valid mode
6041 if sysvals.suspendmode != 'command':
6042 res = sysvals.colorText('NO')
6043 modes = getModes()
6044 if(sysvals.suspendmode in modes):
6045 res = 'YES'
6046 else:
6049 if(res == 'NO'):
6051 pprint(' please choose one with -m')
6053 # check if ftrace is available
6054 if sysvals.useftrace:
6055 res = sysvals.colorText('NO')
6056 sysvals.useftrace = sysvals.verifyFtrace()
6058 if sysvals.useftrace:
6059 res = 'YES'
6060 elif sysvals.usecallgraph:
6061 status = efmt.format('-f')
6062 elif sysvals.usedevsrc:
6063 status = efmt.format('-dev')
6064 elif sysvals.useprocmon:
6065 status = efmt.format('-proc')
6068 # check if kprobes are available
6069 if sysvals.usekprobes:
6070 res = sysvals.colorText('NO')
6071 sysvals.usekprobes = sysvals.verifyKprobes()
6072 if(sysvals.usekprobes):
6073 res = 'YES'
6074 else:
6075 sysvals.usedevsrc = False
6078 # what data source are we using
6079 res = 'DMESG (very limited, ftrace is preferred)'
6080 if sysvals.useftrace:
6081 sysvals.usetraceevents = True
6082 for e in sysvals.traceevents:
6083 if not os.path.exists(sysvals.epath+e):
6084 sysvals.usetraceevents = False
6085 if(sysvals.usetraceevents):
6086 res = 'FTRACE (all trace events found)'
6089 # check if rtcwake
6090 res = sysvals.colorText('NO')
6091 if(sysvals.rtcpath != ''):
6092 res = 'YES'
6093 elif(sysvals.rtcwake):
6094 status = 'rtcwake is not properly supported'
6097 # check info commands
6098 pprint(' optional commands this tool may use for info:')
6099 no = sysvals.colorText('MISSING')
6100 yes = sysvals.colorText('FOUND', 32)
6101 for c in ['turbostat', 'mcelog', 'lspci', 'lsusb', 'netfix']:
6102 if c == 'turbostat':
6103 res = yes if sysvals.haveTurbostat() else no
6104 else:
6105 res = yes if sysvals.getExec(c) else no
6108 if not probecheck:
6109 return status
6111 # verify kprobes
6112 if sysvals.usekprobes:
6113 for name in sysvals.tracefuncs:
6114 sysvals.defaultKprobe(name, sysvals.tracefuncs[name])
6115 if sysvals.usedevsrc:
6116 for name in sysvals.dev_tracefuncs:
6117 sysvals.defaultKprobe(name, sysvals.dev_tracefuncs[name])
6118 sysvals.addKprobes(True)
6120 return status
6122 # Function: doError
6123 # Description:
6124 # generic error function for catastrphic failures
6125 # Arguments:
6126 # msg: the error message to print
6127 # help: True if printHelp should be called after, False otherwise
6128 def doError(msg, help=False):
6129 if(help == True):
6130 printHelp()
6132 sysvals.outputResult({'error':msg})
6133 sys.exit(1)
6135 # Function: getArgInt
6136 # Description:
6137 # pull out an integer argument from the command line with checks
6138 def getArgInt(name, args, min, max, main=True):
6139 if main:
6140 try:
6141 arg = next(args)
6142 except:
6143 doError(name+': no argument supplied', True)
6144 else:
6145 arg = args
6146 try:
6147 val = int(arg)
6148 except:
6149 doError(name+': non-integer value given', True)
6150 if(val < min or val > max):
6152 return val
6154 # Function: getArgFloat
6155 # Description:
6156 # pull out a float argument from the command line with checks
6157 def getArgFloat(name, args, min, max, main=True):
6158 if main:
6159 try:
6160 arg = next(args)
6161 except:
6162 doError(name+': no argument supplied', True)
6163 else:
6164 arg = args
6165 try:
6166 val = float(arg)
6167 except:
6168 doError(name+': non-numerical value given', True)
6169 if(val < min or val > max):
6171 return val
6173 def processData(live=False, quiet=False):
6174 if not quiet:
6177 (sysvals.usetraceevents, sysvals.usetracemarkers, sysvals.usekprobes))
6178 error = ''
6179 if(sysvals.usetraceevents):
6180 testruns, error = parseTraceLog(live)
6181 if sysvals.dmesgfile:
6182 for data in testruns:
6183 data.extractErrorInfo()
6184 else:
6185 testruns = loadKernelLog()
6186 for data in testruns:
6187 parseKernelLog(data)
6188 if(sysvals.ftracefile and (sysvals.usecallgraph or sysvals.usetraceevents)):
6189 appendIncompleteTraceLog(testruns)
6190 if not sysvals.stamp:
6191 pprint('ERROR: data does not include the expected stamp')
6192 return (testruns, {'error': 'timeline generation failed'})
6193 shown = ['os', 'bios', 'biosdate', 'cpu', 'host', 'kernel', 'man', 'memfr',
6194 'memsz', 'mode', 'numcpu', 'plat', 'time', 'wifi']
6195 sysvals.vprint('System Info:')
6196 for key in sorted(sysvals.stamp):
6197 if key in shown:
6200 for data in testruns:
6201 if data.turbostat:
6203 for val in data.turbostat.split('|'):
6204 idx += len(val) + 1
6205 if idx >= 80:
6206 idx = 0
6208 s += val + ' '
6209 sysvals.vprint(s)
6210 data.printDetails()
6211 if len(sysvals.platinfo) > 0:
6213 for info in sysvals.platinfo:
6215 sysvals.vprint(info[2])
6216 sysvals.vprint('')
6217 if sysvals.cgdump:
6218 for data in testruns:
6219 data.debugPrint()
6220 sys.exit(0)
6221 if len(testruns) < 1:
6222 pprint('ERROR: Not enough test data to build a timeline')
6223 return (testruns, {'error': 'timeline generation failed'})
6225 createHTML(testruns, error)
6226 if not quiet:
6228 data = testruns[0]
6229 stamp = data.stamp
6230 stamp['suspend'], stamp['resume'] = data.getTimeValues()
6231 if data.fwValid:
6232 stamp['fwsuspend'], stamp['fwresume'] = data.fwSuspend, data.fwResume
6233 if error:
6234 stamp['error'] = error
6235 return (testruns, stamp)
6237 # Function: rerunTest
6238 # Description:
6239 # generate an output from an existing set of ftrace/dmesg logs
6240 def rerunTest(htmlfile=''):
6241 if sysvals.ftracefile:
6242 doesTraceLogHaveTraceEvents()
6243 if not sysvals.dmesgfile and not sysvals.usetraceevents:
6244 doError('recreating this html output requires a dmesg file')
6245 if htmlfile:
6246 sysvals.htmlfile = htmlfile
6247 else:
6248 sysvals.setOutputFile()
6249 if os.path.exists(sysvals.htmlfile):
6250 if not os.path.isfile(sysvals.htmlfile):
6252 elif not os.access(sysvals.htmlfile, os.W_OK):
6254 testruns, stamp = processData()
6255 sysvals.resetlog()
6256 return stamp
6258 # Function: runTest
6259 # Description:
6260 # execute a suspend/resume, gather the logs, and generate the output
6261 def runTest(n=0, quiet=False):
6262 # prepare for the test
6263 sysvals.initTestOutput('suspend')
6264 op = sysvals.writeDatafileHeader(sysvals.dmesgfile, [])
6266 op.close()
6267 if n <= 1:
6268 if sysvals.rs != 0:
6270 sysvals.setRuntimeSuspend(True)
6271 if sysvals.display:
6272 ret = sysvals.displayControl('init')
6274 sysvals.testVal(sysvals.pmdpath, 'basic', '1')
6275 sysvals.testVal(sysvals.s0ixpath, 'basic', 'Y')
6276 sysvals.dlog('initialize ftrace')
6277 sysvals.initFtrace(quiet)
6279 # execute the test
6280 executeSuspend(quiet)
6281 sysvals.cleanupFtrace()
6282 if sysvals.skiphtml:
6283 sysvals.outputResult({}, n)
6284 sysvals.sudoUserchown(sysvals.testdir)
6285 return
6286 testruns, stamp = processData(True, quiet)
6287 for data in testruns:
6288 del data
6289 sysvals.sudoUserchown(sysvals.testdir)
6290 sysvals.outputResult(stamp, n)
6291 if 'error' in stamp:
6292 return 2
6293 return 0
6295 def find_in_html(html, start, end, firstonly=True):
6296 cnt, out, list = len(html), [], []
6297 if firstonly:
6298 m = re.search(start, html)
6299 if m:
6300 list.append(m)
6301 else:
6302 list = re.finditer(start, html)
6303 for match in list:
6304 s = match.end()
6305 e = cnt if (len(out) < 1 or s + 10000 > cnt) else s + 10000
6306 m = re.search(end, html[s:e])
6307 if not m:
6308 break
6309 e = s + m.start()
6310 str = html[s:e]
6311 if end == 'ms':
6312 num = re.search(r'[-+]?\d*\.\d+|\d+', str)
6313 str = num.group() if num else 'NaN'
6314 if firstonly:
6315 return str
6316 out.append(str)
6317 if firstonly:
6318 return ''
6319 return out
6321 def data_from_html(file, outpath, issues, fulldetail=False):
6322 try:
6323 html = open(file, 'r').read()
6324 except:
6325 html = ascii(open(file, 'rb').read())
6326 sysvals.htmlfile = os.path.relpath(file, outpath)
6327 # extract general info
6328 suspend = find_in_html(html, 'Kernel Suspend', 'ms')
6329 resume = find_in_html(html, 'Kernel Resume', 'ms')
6330 sysinfo = find_in_html(html, '<div class="stamp sysinfo">', '</div>')
6331 line = find_in_html(html, '<div class="stamp">', '</div>')
6332 stmp = line.split()
6333 if not suspend or not resume or len(stmp) != 8:
6334 return False
6335 try:
6337 except:
6338 return False
6339 sysvals.hostname = stmp[0]
6341 error = find_in_html(html, '<table class="testfail"><tr><td>', '</td>')
6342 if error:
6343 m = re.match(r'[a-z0-9]* failed in (?P<p>\S*).*', error)
6344 if m:
6346 else:
6347 result = 'fail'
6348 else:
6349 result = 'pass'
6350 # extract error info
6351 tp, ilist = False, []
6352 extra = dict()
6353 log = find_in_html(html, '<div id="dmesglog" style="display:none;">',
6354 '</div>').strip()
6355 if log:
6356 d = Data(0)
6357 d.end = 999999999
6359 tp = d.extractErrorInfo()
6360 if len(issues) < 100:
6361 for msg in tp.msglist:
6362 sysvals.errorSummary(issues, msg)
6363 if stmp[2] == 'freeze':
6364 extra = d.turbostatInfo()
6365 elist = dict()
6366 for dir in d.errorinfo:
6367 for err in d.errorinfo[dir]:
6368 if err[0] not in elist:
6369 elist[err[0]] = 0
6370 elist[err[0]] += 1
6371 for i in elist:
6374 if line:
6375 extra['wifi'] = line
6377 if line:
6378 extra['netfix'] = line
6380 if line:
6381 m = re.match(r'.* -m (?P<m>\S*).*', line)
6382 if m:
6383 extra['fullmode'] = m.group('m')
6384 low = find_in_html(html, 'freeze time: <b>', ' ms</b>')
6385 for lowstr in ['waking', '+']:
6386 if not low:
6387 break
6388 if lowstr not in low:
6389 continue
6390 if lowstr == '+':
6392 else:
6393 m = re.match(r'.*waking *(?P<n>[0-9]*) *times.*', low)
6395 match = [i for i in issues if i['match'] == issue]
6396 if len(match) > 0:
6397 match[0]['count'] += 1
6398 if sysvals.hostname not in match[0]['urls']:
6399 match[0]['urls'][sysvals.hostname] = [sysvals.htmlfile]
6400 elif sysvals.htmlfile not in match[0]['urls'][sysvals.hostname]:
6401 match[0]['urls'][sysvals.hostname].append(sysvals.htmlfile)
6402 else:
6403 issues.append({
6404 'match': issue, 'count': 1, 'line': issue,
6405 'urls': {sysvals.hostname: [sysvals.htmlfile]},
6406 })
6407 ilist.append(issue)
6408 # extract device info
6409 devices = dict()
6412 if not m or 'thread kth' in line or 'thread sec' in line:
6413 continue
6414 m = re.match(r'(?P<n>.*) \((?P<t>[0-9,\.]*) ms\) (?P<p>.*)', m.group('title'))
6415 if not m:
6416 continue
6417 name, time, phase = m.group('n'), m.group('t'), m.group('p')
6418 if name == 'async_synchronize_full':
6419 continue
6420 if ' async' in name or ' sync' in name:
6421 name = ' '.join(name.split(' ')[:-1])
6422 if phase.startswith('suspend'):
6423 d = 'suspend'
6424 elif phase.startswith('resume'):
6425 d = 'resume'
6426 else:
6427 continue
6428 if d not in devices:
6429 devices[d] = dict()
6430 if name not in devices[d]:
6431 devices[d][name] = 0.0
6432 devices[d][name] += float(time)
6433 # create worst device info
6434 worst = dict()
6435 for d in ['suspend', 'resume']:
6436 worst[d] = {'name':'', 'time': 0.0}
6437 dev = devices[d] if d in devices else 0
6438 if dev and len(dev.keys()) > 0:
6439 n = sorted(dev, key=lambda k:(dev[k], k), reverse=True)[0]
6440 worst[d]['name'], worst[d]['time'] = n, dev[n]
6441 data = {
6442 'mode': stmp[2],
6443 'host': stmp[0],
6444 'kernel': stmp[1],
6445 'sysinfo': sysinfo,
6446 'time': tstr,
6447 'result': result,
6448 'issues': ' '.join(ilist),
6449 'suspend': suspend,
6450 'resume': resume,
6451 'devlist': devices,
6452 'sus_worst': worst['suspend']['name'],
6453 'sus_worsttime': worst['suspend']['time'],
6454 'res_worst': worst['resume']['name'],
6455 'res_worsttime': worst['resume']['time'],
6456 'url': sysvals.htmlfile,
6457 }
6458 for key in extra:
6459 data[key] = extra[key]
6460 if fulldetail:
6461 data['funclist'] = find_in_html(html, '<div title="', '" class="traceevent"', False)
6462 if tp:
6463 for arg in ['-multi ', '-info ']:
6464 if arg in tp.cmdline:
6465 data['target'] = tp.cmdline[tp.cmdline.find(arg):].split()[1]
6466 break
6467 return data
6469 def genHtml(subdir, force=False):
6470 for dirname, dirnames, filenames in os.walk(subdir):
6471 sysvals.dmesgfile = sysvals.ftracefile = sysvals.htmlfile = ''
6472 for filename in filenames:
6473 file = os.path.join(dirname, filename)
6474 if sysvals.usable(file):
6475 if(re.match(r'.*_dmesg.txt', filename)):
6476 sysvals.dmesgfile = file
6477 elif(re.match(r'.*_ftrace.txt', filename)):
6478 sysvals.ftracefile = file
6479 sysvals.setOutputFile()
6480 if (sysvals.dmesgfile or sysvals.ftracefile) and sysvals.htmlfile and \
6481 (force or not sysvals.usable(sysvals.htmlfile, True)):
6483 if sysvals.dmesgfile:
6485 rerunTest()
6487 # Function: runSummary
6488 # Description:
6489 # create a summary of tests in a sub-directory
6490 def runSummary(subdir, local=True, genhtml=False):
6491 inpath = os.path.abspath(subdir)
6492 outpath = os.path.abspath('.') if local else inpath
6494 if genhtml:
6495 genHtml(subdir)
6496 target, issues, testruns = '', [], []
6497 desc = {'host':[],'mode':[],'kernel':[]}
6498 for dirname, dirnames, filenames in os.walk(subdir):
6499 for filename in filenames:
6500 if(not re.match(r'.*.html', filename)):
6501 continue
6502 data = data_from_html(os.path.join(dirname, filename), outpath, issues)
6503 if(not data):
6504 continue
6505 if 'target' in data:
6506 target = data['target']
6507 testruns.append(data)
6508 for key in desc:
6509 if data[key] not in desc[key]:
6510 desc[key].append(data[key])
6511 pprint('Summary files:')
6512 if len(desc['host']) == len(desc['mode']) == len(desc['kernel']) == 1:
6514 if target:
6516 else:
6517 title = inpath
6518 createHTMLSummarySimple(testruns, os.path.join(outpath, 'summary.html'), title)
6519 pprint(' summary.html - tabular list of test data found')
6520 createHTMLDeviceSummary(testruns, os.path.join(outpath, 'summary-devices.html'), title)
6521 pprint(' summary-devices.html - kernel device list sorted by total execution time')
6522 createHTMLIssuesSummary(testruns, issues, os.path.join(outpath, 'summary-issues.html'), title)
6523 pprint(' summary-issues.html - kernel issues found sorted by frequency')
6525 # Function: checkArgBool
6526 # Description:
6527 # check if a boolean string value is true or false
6528 def checkArgBool(name, value):
6529 if value in switchvalues:
6530 if value in switchoff:
6531 return False
6532 return True
6534 return False
6536 # Function: configFromFile
6537 # Description:
6538 # Configure the script via the info in a config file
6539 def configFromFile(file):
6540 Config = configparser.ConfigParser()
6542 Config.read(file)
6543 sections = Config.sections()
6544 overridekprobes = False
6545 overridedevkprobes = False
6546 if 'Settings' in sections:
6547 for opt in Config.options('Settings'):
6548 value = Config.get('Settings', opt).lower()
6549 option = opt.lower()
6550 if(option == 'verbose'):
6551 sysvals.verbose = checkArgBool(option, value)
6552 elif(option == 'addlogs'):
6553 sysvals.dmesglog = sysvals.ftracelog = checkArgBool(option, value)
6554 elif(option == 'dev'):
6555 sysvals.usedevsrc = checkArgBool(option, value)
6556 elif(option == 'proc'):
6557 sysvals.useprocmon = checkArgBool(option, value)
6558 elif(option == 'x2'):
6559 if checkArgBool(option, value):
6560 sysvals.execcount = 2
6561 elif(option == 'callgraph'):
6562 sysvals.usecallgraph = checkArgBool(option, value)
6563 elif(option == 'override-timeline-functions'):
6564 overridekprobes = checkArgBool(option, value)
6565 elif(option == 'override-dev-timeline-functions'):
6566 overridedevkprobes = checkArgBool(option, value)
6567 elif(option == 'skiphtml'):
6568 sysvals.skiphtml = checkArgBool(option, value)
6569 elif(option == 'sync'):
6570 sysvals.sync = checkArgBool(option, value)
6571 elif(option == 'rs' or option == 'runtimesuspend'):
6572 if value in switchvalues:
6573 if value in switchoff:
6574 sysvals.rs = -1
6575 else:
6576 sysvals.rs = 1
6577 else:
6579 elif(option == 'display'):
6580 disopt = ['on', 'off', 'standby', 'suspend']
6581 if value not in disopt:
6583 sysvals.display = value
6584 elif(option == 'gzip'):
6585 sysvals.gzip = checkArgBool(option, value)
6586 elif(option == 'cgfilter'):
6587 sysvals.setCallgraphFilter(value)
6588 elif(option == 'cgskip'):
6589 if value in switchoff:
6590 sysvals.cgskip = ''
6591 else:
6592 sysvals.cgskip = sysvals.configFile(val)
6593 if(not sysvals.cgskip):
6595 elif(option == 'cgtest'):
6596 sysvals.cgtest = getArgInt('cgtest', value, 0, 1, False)
6597 elif(option == 'cgphase'):
6598 d = Data(0)
6599 if value not in d.phasedef:
6601 % (option, value, d.phasedef.keys()), True)
6602 sysvals.cgphase = value
6603 elif(option == 'fadd'):
6604 file = sysvals.configFile(value)
6605 if(not file):
6607 sysvals.addFtraceFilterFunctions(file)
6608 elif(option == 'result'):
6609 sysvals.result = value
6610 elif(option == 'multi'):
6611 nums = value.split()
6612 if len(nums) != 2:
6613 doError('multi requires 2 integers (exec_count and delay)', True)
6614 sysvals.multiinit(nums[0], nums[1])
6615 elif(option == 'devicefilter'):
6616 sysvals.setDeviceFilter(value)
6617 elif(option == 'expandcg'):
6618 sysvals.cgexp = checkArgBool(option, value)
6619 elif(option == 'srgap'):
6620 if checkArgBool(option, value):
6621 sysvals.srgap = 5
6622 elif(option == 'mode'):
6623 sysvals.suspendmode = value
6624 elif(option == 'command' or option == 'cmd'):
6625 sysvals.testcommand = value
6626 elif(option == 'x2delay'):
6627 sysvals.x2delay = getArgInt('x2delay', value, 0, 60000, False)
6628 elif(option == 'predelay'):
6629 sysvals.predelay = getArgInt('predelay', value, 0, 60000, False)
6630 elif(option == 'postdelay'):
6631 sysvals.postdelay = getArgInt('postdelay', value, 0, 60000, False)
6632 elif(option == 'maxdepth'):
6633 sysvals.max_graph_depth = getArgInt('maxdepth', value, 0, 1000, False)
6634 elif(option == 'rtcwake'):
6635 if value in switchoff:
6636 sysvals.rtcwake = False
6637 else:
6638 sysvals.rtcwake = True
6639 sysvals.rtcwaketime = getArgInt('rtcwake', value, 0, 3600, False)
6640 elif(option == 'timeprec'):
6641 sysvals.setPrecision(getArgInt('timeprec', value, 0, 6, False))
6642 elif(option == 'mindev'):
6643 sysvals.mindevlen = getArgFloat('mindev', value, 0.0, 10000.0, False)
6644 elif(option == 'callloop-maxgap'):
6645 sysvals.callloopmaxgap = getArgFloat('callloop-maxgap', value, 0.0, 1.0, False)
6646 elif(option == 'callloop-maxlen'):
6647 sysvals.callloopmaxgap = getArgFloat('callloop-maxlen', value, 0.0, 1.0, False)
6648 elif(option == 'mincg'):
6649 sysvals.mincglen = getArgFloat('mincg', value, 0.0, 10000.0, False)
6650 elif(option == 'bufsize'):
6651 sysvals.bufsize = getArgInt('bufsize', value, 1, 1024*1024*8, False)
6652 elif(option == 'output-dir'):
6653 sysvals.outdir = sysvals.setOutputFolder(value)
6655 if sysvals.suspendmode == 'command' and not sysvals.testcommand:
6656 doError('No command supplied for mode "command"')
6658 # compatibility errors
6659 if sysvals.usedevsrc and sysvals.usecallgraph:
6660 doError('-dev is not compatible with -f')
6661 if sysvals.usecallgraph and sysvals.useprocmon:
6662 doError('-proc is not compatible with -f')
6664 if overridekprobes:
6665 sysvals.tracefuncs = dict()
6666 if overridedevkprobes:
6667 sysvals.dev_tracefuncs = dict()
6669 kprobes = dict()
6670 kprobesec = 'dev_timeline_functions_'+platform.machine()
6671 if kprobesec in sections:
6672 for name in Config.options(kprobesec):
6673 text = Config.get(kprobesec, name)
6674 kprobes[name] = (text, True)
6675 kprobesec = 'timeline_functions_'+platform.machine()
6676 if kprobesec in sections:
6677 for name in Config.options(kprobesec):
6678 if name in kprobes:
6680 text = Config.get(kprobesec, name)
6681 kprobes[name] = (text, False)
6683 for name in kprobes:
6684 function = name
6685 format = name
6686 color = ''
6687 args = dict()
6688 text, dev = kprobes[name]
6689 data = text.split()
6690 i = 0
6691 for val in data:
6692 # bracketted strings are special formatting, read them separately
6693 if val[0] == '[' and val[-1] == ']':
6694 for prop in val[1:-1].split(','):
6695 p = prop.split('=')
6696 if p[0] == 'color':
6697 try:
6698 color = int(p[1], 16)
6699 color = '#'+p[1]
6700 except:
6701 color = p[1]
6702 continue
6703 # first real arg should be the format string
6704 if i == 0:
6705 format = val
6706 # all other args are actual function args
6707 else:
6708 d = val.split('=')
6709 args[d[0]] = d[1]
6710 i += 1
6711 if not function or not format:
6713 for arg in re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', format):
6714 if arg not in args:
6716 if (dev and name in sysvals.dev_tracefuncs) or (not dev and name in sysvals.tracefuncs):
6719 kp = {
6720 'name': name,
6721 'func': function,
6722 'format': format,
6723 sysvals.archargs: args
6724 }
6725 if color:
6726 kp['color'] = color
6727 if dev:
6728 sysvals.dev_tracefuncs[name] = kp
6729 else:
6730 sysvals.tracefuncs[name] = kp
6732 # Function: printHelp
6733 # Description:
6734 # print out the help text
6735 def printHelp():
6768 ' -skiphtml Run the test and capture the trace logs, but skip the timeline (default: disabled)\n'\
6824 '' % (sysvals.title, sysvals.version, sysvals.suspendmode, sysvals.ftopfunc))
6825 return True
6827 # ----------------- MAIN --------------------
6828 # exec start (skipped if script is loaded as library)
6829 if __name__ == '__main__':
6830 genhtml = False
6831 cmd = ''
6832 simplecmds = ['-sysinfo', '-modes', '-fpdt', '-flist', '-flistall',
6833 '-devinfo', '-status', '-xon', '-xoff', '-xstandby', '-xsuspend',
6834 '-xinit', '-xreset', '-xstat', '-wificheck', '-cmdinfo']
6835 if '-f' in sys.argv:
6836 sysvals.cgskip = sysvals.configFile('cgskip.txt')
6837 # loop through the command line arguments
6838 args = iter(sys.argv[1:])
6839 for arg in args:
6840 if(arg == '-m'):
6841 try:
6842 val = next(args)
6843 except:
6844 doError('No mode supplied', True)
6845 if val == 'command' and not sysvals.testcommand:
6846 doError('No command supplied for mode "command"', True)
6847 sysvals.suspendmode = val
6848 elif(arg in simplecmds):
6849 cmd = arg[1:]
6850 elif(arg == '-h'):
6851 printHelp()
6852 sys.exit(0)
6853 elif(arg == '-v'):
6855 sys.exit(0)
6856 elif(arg == '-debugtiming'):
6857 debugtiming = True
6858 elif(arg == '-x2'):
6859 sysvals.execcount = 2
6860 elif(arg == '-x2delay'):
6861 sysvals.x2delay = getArgInt('-x2delay', args, 0, 60000)
6862 elif(arg == '-predelay'):
6863 sysvals.predelay = getArgInt('-predelay', args, 0, 60000)
6864 elif(arg == '-postdelay'):
6865 sysvals.postdelay = getArgInt('-postdelay', args, 0, 60000)
6866 elif(arg == '-f'):
6867 sysvals.usecallgraph = True
6868 elif(arg == '-ftop'):
6869 sysvals.usecallgraph = True
6870 sysvals.ftop = True
6871 sysvals.usekprobes = False
6872 elif(arg == '-skiphtml'):
6873 sysvals.skiphtml = True
6874 elif(arg == '-cgdump'):
6875 sysvals.cgdump = True
6876 elif(arg == '-devdump'):
6877 sysvals.devdump = True
6878 elif(arg == '-genhtml'):
6879 genhtml = True
6880 elif(arg == '-addlogs'):
6881 sysvals.dmesglog = sysvals.ftracelog = True
6882 elif(arg == '-nologs'):
6883 sysvals.dmesglog = sysvals.ftracelog = False
6884 elif(arg == '-addlogdmesg'):
6885 sysvals.dmesglog = True
6886 elif(arg == '-addlogftrace'):
6887 sysvals.ftracelog = True
6888 elif(arg == '-noturbostat'):
6889 sysvals.tstat = False
6890 elif(arg == '-verbose'):
6891 sysvals.verbose = True
6892 elif(arg == '-proc'):
6893 sysvals.useprocmon = True
6894 elif(arg == '-dev'):
6895 sysvals.usedevsrc = True
6896 elif(arg == '-sync'):
6897 sysvals.sync = True
6898 elif(arg == '-wifi'):
6899 sysvals.wifi = True
6900 elif(arg == '-wifitrace'):
6901 sysvals.wifitrace = True
6902 elif(arg == '-netfix'):
6903 sysvals.netfix = True
6904 elif(arg == '-gzip'):
6905 sysvals.gzip = True
6906 elif(arg == '-info'):
6907 try:
6908 val = next(args)
6909 except:
6910 doError('-info requires one string argument', True)
6911 elif(arg == '-desc'):
6912 try:
6913 val = next(args)
6914 except:
6915 doError('-desc requires one string argument', True)
6916 elif(arg == '-rs'):
6917 try:
6918 val = next(args)
6919 except:
6920 doError('-rs requires "enable" or "disable"', True)
6921 if val.lower() in switchvalues:
6922 if val.lower() in switchoff:
6923 sysvals.rs = -1
6924 else:
6925 sysvals.rs = 1
6926 else:
6928 elif(arg == '-display'):
6929 try:
6930 val = next(args)
6931 except:
6932 doError('-display requires an mode value', True)
6933 disopt = ['on', 'off', 'standby', 'suspend']
6934 if val.lower() not in disopt:
6936 sysvals.display = val.lower()
6937 elif(arg == '-maxdepth'):
6938 sysvals.max_graph_depth = getArgInt('-maxdepth', args, 0, 1000)
6939 elif(arg == '-rtcwake'):
6940 try:
6941 val = next(args)
6942 except:
6943 doError('No rtcwake time supplied', True)
6944 if val.lower() in switchoff:
6945 sysvals.rtcwake = False
6946 else:
6947 sysvals.rtcwake = True
6948 sysvals.rtcwaketime = getArgInt('-rtcwake', val, 0, 3600, False)
6949 elif(arg == '-timeprec'):
6950 sysvals.setPrecision(getArgInt('-timeprec', args, 0, 6))
6951 elif(arg == '-mindev'):
6952 sysvals.mindevlen = getArgFloat('-mindev', args, 0.0, 10000.0)
6953 elif(arg == '-mincg'):
6954 sysvals.mincglen = getArgFloat('-mincg', args, 0.0, 10000.0)
6955 elif(arg == '-bufsize'):
6956 sysvals.bufsize = getArgInt('-bufsize', args, 1, 1024*1024*8)
6957 elif(arg == '-cgtest'):
6958 sysvals.cgtest = getArgInt('-cgtest', args, 0, 1)
6959 elif(arg == '-cgphase'):
6960 try:
6961 val = next(args)
6962 except:
6963 doError('No phase name supplied', True)
6964 d = Data(0)
6965 if val not in d.phasedef:
6967 % (arg, val, d.phasedef.keys()), True)
6968 sysvals.cgphase = val
6969 elif(arg == '-cgfilter'):
6970 try:
6971 val = next(args)
6972 except:
6973 doError('No callgraph functions supplied', True)
6974 sysvals.setCallgraphFilter(val)
6975 elif(arg == '-skipkprobe'):
6976 try:
6977 val = next(args)
6978 except:
6979 doError('No kprobe functions supplied', True)
6980 sysvals.skipKprobes(val)
6981 elif(arg == '-cgskip'):
6982 try:
6983 val = next(args)
6984 except:
6985 doError('No file supplied', True)
6986 if val.lower() in switchoff:
6987 sysvals.cgskip = ''
6988 else:
6989 sysvals.cgskip = sysvals.configFile(val)
6990 if(not sysvals.cgskip):
6992 elif(arg == '-callloop-maxgap'):
6993 sysvals.callloopmaxgap = getArgFloat('-callloop-maxgap', args, 0.0, 1.0)
6994 elif(arg == '-callloop-maxlen'):
6995 sysvals.callloopmaxlen = getArgFloat('-callloop-maxlen', args, 0.0, 1.0)
6996 elif(arg == '-cmd'):
6997 try:
6998 val = next(args)
6999 except:
7000 doError('No command string supplied', True)
7001 sysvals.testcommand = val
7002 sysvals.suspendmode = 'command'
7003 elif(arg == '-expandcg'):
7004 sysvals.cgexp = True
7005 elif(arg == '-srgap'):
7006 sysvals.srgap = 5
7007 elif(arg == '-maxfail'):
7008 sysvals.maxfail = getArgInt('-maxfail', args, 0, 1000000)
7009 elif(arg == '-multi'):
7010 try:
7011 c, d = next(args), next(args)
7012 except:
7013 doError('-multi requires two values', True)
7014 sysvals.multiinit(c, d)
7015 elif(arg == '-o'):
7016 try:
7017 val = next(args)
7018 except:
7019 doError('No subdirectory name supplied', True)
7020 sysvals.outdir = sysvals.setOutputFolder(val)
7021 elif(arg == '-config'):
7022 try:
7023 val = next(args)
7024 except:
7025 doError('No text file supplied', True)
7026 file = sysvals.configFile(val)
7027 if(not file):
7029 configFromFile(file)
7030 elif(arg == '-fadd'):
7031 try:
7032 val = next(args)
7033 except:
7034 doError('No text file supplied', True)
7035 file = sysvals.configFile(val)
7036 if(not file):
7038 sysvals.addFtraceFilterFunctions(file)
7039 elif(arg == '-dmesg'):
7040 try:
7041 val = next(args)
7042 except:
7043 doError('No dmesg file supplied', True)
7044 sysvals.notestrun = True
7045 sysvals.dmesgfile = val
7046 if(os.path.exists(sysvals.dmesgfile) == False):
7048 elif(arg == '-ftrace'):
7049 try:
7050 val = next(args)
7051 except:
7052 doError('No ftrace file supplied', True)
7053 sysvals.notestrun = True
7054 sysvals.ftracefile = val
7055 if(os.path.exists(sysvals.ftracefile) == False):
7057 elif(arg == '-summary'):
7058 try:
7059 val = next(args)
7060 except:
7061 doError('No directory supplied', True)
7062 cmd = 'summary'
7063 sysvals.outdir = val
7064 sysvals.notestrun = True
7065 if(os.path.isdir(val) == False):
7067 elif(arg == '-filter'):
7068 try:
7069 val = next(args)
7070 except:
7071 doError('No devnames supplied', True)
7072 sysvals.setDeviceFilter(val)
7073 elif(arg == '-result'):
7074 try:
7075 val = next(args)
7076 except:
7077 doError('No result file supplied', True)
7078 sysvals.result = val
7079 else:
7080 doError('Invalid argument: '+arg, True)
7082 # compatibility errors
7083 if(sysvals.usecallgraph and sysvals.usedevsrc):
7084 doError('-dev is not compatible with -f')
7085 if(sysvals.usecallgraph and sysvals.useprocmon):
7086 doError('-proc is not compatible with -f')
7088 sysvals.signalHandlerInit()
7089 if sysvals.usecallgraph and sysvals.cgskip:
7091 sysvals.setCallgraphBlacklist(sysvals.cgskip)
7093 # callgraph size cannot exceed device size
7094 if sysvals.mincglen < sysvals.mindevlen:
7095 sysvals.mincglen = sysvals.mindevlen
7097 # remove existing buffers before calculating memory
7098 if(sysvals.usecallgraph or sysvals.usedevsrc):
7099 sysvals.fsetVal('16', 'buffer_size_kb')
7100 sysvals.cpuInfo()
7102 # just run a utility command and exit
7103 if(cmd != ''):
7104 ret = 0
7105 if(cmd == 'status'):
7106 if not statusCheck(True):
7107 ret = 1
7108 elif(cmd == 'fpdt'):
7109 if not getFPDT(True):
7110 ret = 1
7111 elif(cmd == 'sysinfo'):
7112 sysvals.printSystemInfo(True)
7113 elif(cmd == 'devinfo'):
7114 deviceInfo()
7115 elif(cmd == 'modes'):
7116 pprint(getModes())
7117 elif(cmd == 'flist'):
7118 sysvals.getFtraceFilterFunctions(True)
7119 elif(cmd == 'flistall'):
7120 sysvals.getFtraceFilterFunctions(False)
7121 elif(cmd == 'summary'):
7122 runSummary(sysvals.outdir, True, genhtml)
7123 elif(cmd in ['xon', 'xoff', 'xstandby', 'xsuspend', 'xinit', 'xreset']):
7124 sysvals.verbose = True
7125 ret = sysvals.displayControl(cmd[1:])
7126 elif(cmd == 'xstat'):
7128 elif(cmd == 'wificheck'):
7129 dev = sysvals.checkWifi()
7130 if dev:
7132 else:
7133 print('No wifi connection found')
7134 elif(cmd == 'cmdinfo'):
7135 for out in sysvals.cmdinfo(False, True):
7137 sys.exit(ret)
7139 # if instructed, re-analyze existing data files
7140 if(sysvals.notestrun):
7141 stamp = rerunTest(sysvals.outdir)
7142 sysvals.outputResult(stamp)
7143 sys.exit(0)
7145 # verify that we can run a test
7146 error = statusCheck()
7147 if(error):
7148 doError(error)
7150 # extract mem/disk extra modes and convert
7151 mode = sysvals.suspendmode
7152 if mode.startswith('mem'):
7153 memmode = mode.split('-', 1)[-1] if '-' in mode else 'deep'
7154 if memmode == 'shallow':
7155 mode = 'standby'
7156 elif memmode == 's2idle':
7157 mode = 'freeze'
7158 else:
7159 mode = 'mem'
7160 sysvals.memmode = memmode
7161 sysvals.suspendmode = mode
7162 if mode.startswith('disk-'):
7163 sysvals.diskmode = mode.split('-', 1)[-1]
7164 sysvals.suspendmode = 'disk'
7165 sysvals.systemInfo(dmidecode(sysvals.mempath))
7167 failcnt, ret = 0, 0
7168 if sysvals.multitest['run']:
7169 # run multiple tests in a separate subdirectory
7170 if not sysvals.outdir:
7171 if 'time' in sysvals.multitest:
7173 else:
7176 if not os.path.isdir(sysvals.outdir):
7177 os.makedirs(sysvals.outdir)
7178 sysvals.sudoUserchown(sysvals.outdir)
7179 finish = datetime.now()
7180 if 'time' in sysvals.multitest:
7181 finish += timedelta(minutes=sysvals.multitest['time'])
7182 for i in range(sysvals.multitest['count']):
7183 sysvals.multistat(True, i, finish)
7184 if i != 0 and sysvals.multitest['delay'] > 0:
7186 time.sleep(sysvals.multitest['delay'])
7188 sysvals.testdir = os.path.join(sysvals.outdir, datetime.now().strftime(fmt))
7189 ret = runTest(i+1, not sysvals.verbose)
7190 failcnt = 0 if not ret else failcnt + 1
7191 if sysvals.maxfail > 0 and failcnt >= sysvals.maxfail:
7193 break
7194 sysvals.resetlog()
7195 sysvals.multistat(False, i, finish)
7196 if 'time' in sysvals.multitest and datetime.now() >= finish:
7197 break
7198 if not sysvals.skiphtml:
7199 runSummary(sysvals.outdir, False, False)
7200 sysvals.sudoUserchown(sysvals.outdir)
7201 else:
7202 if sysvals.outdir:
7203 sysvals.testdir = sysvals.outdir
7204 # run the test in the current directory
7205 ret = runTest()
7207 # reset to default values after testing
7208 if sysvals.display:
7209 sysvals.displayControl('reset')
7210 if sysvals.rs != 0:
7211 sysvals.setRuntimeSuspend(False)
7212 sys.exit(ret)