Promotion of opensource-tools.lnx.1.0-00013.

CRs      Change ID                                   Subject
--------------------------------------------------------------------------------------------------------------
2013612 2049892   Id053c7b097f9898280fb120d0cf2457f24532d5f   dcc_parser: Fix offset calculation for second offset
2065082   Ib042ebc6895f0594f5784600174087a979e8709f   lrdp-v2:read DCC from KMISC section for minidump

Change-Id: I51749e9301fd3f47c9b7a1fc1358ad95b03fa21e
CRs-Fixed: 2049892, 2065082, 2013612

dcc_parser/dcc_parser.py

@@ -79,6 +79,7 @@ def read_config(config_pt):
         link_second_arg = 8
         # We return zero and fail
         on_zero_link_len = 0
+        track_len = 0
     else:
         address_descriptor = 0
         link_descriptor = 0x3 << 30
@@ -88,6 +89,8 @@ def read_config(config_pt):
         link_second_arg = 7
         #indicates end of list
         on_zero_link_len = -1
+        #word size
+        track_len = 4
 
     while True:
         word = config_pt.read(4)
@@ -107,9 +110,10 @@ def read_config(config_pt):
         elif descriptor == address_descriptor:
             base = ((val & 0x0FFFFFFF) << 4)
             offset = 0
+            length = 1
         elif descriptor == link_descriptor:
             for i in range(0, 2):
-                offset = offset + (val & 0xFF) * 4
+                offset = offset + (val & 0xFF) * 4 + (length - 1) * track_len
                 val = val >> 8
 
                 length = (val & 0x7f)

dcc_parser/sysregs_parser_minidump.py

+# Copyright (c) 2015-2017, The Linux Foundation. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 and
+# only version 2 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that 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.
+
+import datetime
+import logging
+import logging.handlers
+import os
+import struct
+import sys
+
+from optparse import OptionParser
+
+count = 0
+address = []
+data = []
+
+def log_init(name, path, filename):
+    # Set up logger
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+
+    # Add the log message handler to the logger
+    if filename is not None:
+        handler = logging.FileHandler(path + '/' + filename, mode='w')
+    else:
+        handler = logging.StreamHandler(sys.stdout)
+
+    logger.addHandler(handler)
+    return logger
+
+def read_data(data_pt):
+    nr = count
+    flag = 1
+    while nr > 0:
+        word = data_pt.read(4)
+        if len(word) != 4:
+            break
+
+        val = struct.unpack('<L', word)[0]
+        if flag % 2 != 0:
+            address.append(val)
+        else:
+            data.append(val)
+        flag = flag + 1
+        nr = nr - 1
+    return nr
+
+def read_config(config_pt):
+    while True:
+        word = config_pt.read(4)
+        if len(word) != 4:
+            break
+
+        val = struct.unpack('<L', word)[0]
+
+        if val == 0:
+            break
+        return val
+
+def dump_regs_json(options):
+    log.info("Dumping regs in JSON format in \'{0}\' file.".format(options.outfile))
+    parsed_data.info("{")
+    parsed_data.info("\t\"version\": 1,")
+    parsed_data.info("\t\"timestamp\": \"{0}\",".format(datetime.date.today().strftime('%m/%d/%y')))
+    parsed_data.info("\t\"generator\": \"Linux DCC Parser\",")
+    parsed_data.info("\t\"chip\": {")
+    parsed_data.info("\t\t\"name\": \"{0}\",".format(options.chipname))
+    parsed_data.info("\t\t\"version\": \"{0}\"".format(options.chipversion))
+    parsed_data.info("\t},")
+    parsed_data.info("\t\"registers\": [")
+    for addr, val in zip(address, data):
+        parsed_data.info("\t\t{{ \"address\": \"0x{0:08x}\", \"value\": \"0x{1:08x}\" }},".format(addr, val))
+    parsed_data.info("\t]")
+    parsed_data.info("}")
+    return
+
+def dump_regs_xml(options):
+    print "dumping xml file"
+    log.info("Dumping regs in XML format in \'{0}\' file.".format(options.outfile))
+    parsed_data.info("<?xml version=\"1.0\" encoding=\"utf-8\"?>")
+    parsed_data.info("<hwioDump version=\"1\"")
+    parsed_data.info("\t<timestamp>{0}</timestamp>".format(datetime.date.today().strftime('%m/%d/%y')))
+    parsed_data.info("\t<generator>Linux DCC Parser</generator>")
+    parsed_data.info("\t<chip name=\"{0}\" version=\"{1}\">".format(options.chipname, options.chipversion))
+    for addr, val in zip(address, data):
+        parsed_data.info("\t\t<register address=\"0x{0:08x}\" value=\"0x{1:08x}\" />".format(addr, val))
+    parsed_data.info("\t</chip>")
+    parsed_data.info("</hwioDump>")
+    return
+
+def dump_regs(options):
+    if options.json is True:
+        dump_regs_json(options)
+    else:
+        dump_regs_xml(options)
+
+if __name__ == '__main__':
+    usage = 'usage: %prog [options to print]. Run with --help for more details'
+    parser = OptionParser(usage)
+    parser.add_option('-s', '--sysreg-file', dest='sysregfile',
+                      help='sram image path')
+    parser.add_option('-j', '--json', action='store_true',
+                      help='output in JSON format')
+    parser.add_option('-o', '--out-dir', dest='outdir', help='output dir path')
+    parser.add_option('-f', '--output-file', dest='outfile',
+                      help='output filename')
+    parser.add_option('-l', '--log-file', dest='logfile', help='Log filename')
+    parser.add_option('', '--chip-name', dest='chipname', help='chip name')
+    parser.add_option('', '--chip-version', dest='chipversion',
+                      help='chip version')
+
+    (options, args) = parser.parse_args()
+
+    print "sysregs_parser_invoked"
+
+    args = ''
+    for arg in sys.argv:
+        args = args + arg + ' '
+
+    if options.outdir:
+        if not os.path.exists(options.outdir):
+            print ('!!! Out directory does not exist. Creating...')
+            try:
+                os.makedirs(options.outdir)
+            except:
+                print ("Failed to create %s. You probably don't have permissions there. Bailing." % options.outdir)
+                sys.exit(1)
+    else:
+        options.outdir = '.'
+
+    if options.json:
+        ext = '.json'
+    else:
+        ext = '.xml'
+
+    if options.outfile is None:
+        options.outfile = 'dcc_captured_data_minidump{0}'.format(ext)
+
+    log = log_init('LOG', options.outdir, options.logfile)
+
+    log.info("Data Capture and Compare(sysregs) parser.")
+
+    if options.sysregfile is None:
+        log.error("No SRAM image file given! Exiting...")
+        parser.print_usage()
+        sys.exit(1)
+
+    try:
+        sysreg_file = open(options.sysregfile, 'rb')
+    except:
+        log.error("could not open path {0}".format(options.sysregfile))
+        log.error("Do you have read permissions on the path?")
+        sys.exit(1)
+
+    count = 0
+    count = read_config(sysreg_file)
+    if count == 0:
+        log.error('No configuration found in sysdbg_regs!!')
+        sys.exit(1)
+
+    if read_data(sysreg_file):
+        log.error('Couldn\'t read complete data.')
+    else:
+        parsed_data = log_init('PARSED_DATA', options.outdir, options.outfile)
+        dump_regs(options)
+
+    sysreg_file.close()
+    sys.stderr.flush()

linux-ramdump-parser-v2/debug_image_v2.py

@@ -29,6 +29,7 @@ from watchdog_v2 import TZRegDump_v2
 from cachedumplib import lookup_cache_type
 from tlbdumplib import lookup_tlb_type
 from vsens import VsensData
+from sysregs import SysRegDump
 
 MEMDUMPV2_MAGIC = 0x42445953
 MAX_NUM_ENTRIES = 0x150
@@ -45,6 +46,7 @@ class client(object):
     MSM_DUMP_DATA_L3_CACHE = 0xD0
     MSM_DUMP_DATA_OCMEM = 0xE0
     MSM_DUMP_DATA_DBGUI_REG = 0xE5
+    MSM_DUMP_DATA_MISC = 0xE8
     MSM_DUMP_DATA_VSENSE = 0xE9
     MSM_DUMP_DATA_TMC_ETF = 0xF0
     MSM_DUMP_DATA_TMC_REG = 0x100
@@ -78,6 +80,7 @@ client_types = [
     ('MSM_DUMP_DATA_TMC_REG', 'parse_qdss_common'),
     ('MSM_DUMP_DATA_L2_TLB', 'parse_l2_tlb'),
     ('MSM_DUMP_DATA_LLC_CACHE', 'parse_system_cache_common'),
+    ('MSM_DUMP_DATA_MISC', 'parse_sysdbg_regs'),
 ]
 
 qdss_tag_to_field_name = {
@@ -101,7 +104,8 @@ minidump_dump_table_type = [
     ('MSM_DUMP_DATA_DCC_REG', 'KDCC_REG'),
     ('MSM_DUMP_DATA_DCC_SRAM', 'KDCC_SRAM'),
     ('MSM_DUMP_DATA_TMC_ETF', 'KTMC_ETF'),
-    ('MSM_DUMP_DATA_TMC_REG', 'KTMC_REG')
+    ('MSM_DUMP_DATA_TMC_REG', 'KTMC_REG'),
+    ('MSM_DUMP_DATA_MISC', 'KMISC')
 
 ]
 
@@ -205,6 +209,19 @@ class DebugImage_v2():
             ram_dump.dcc = True
         return
 
+    def parse_sysdbg_regs(self, version, start, end, client_id, ram_dump):
+        client_name = self.dump_data_id_lookup_table[client_id]
+
+        print_out_str(
+            'Parsing {0} context start {1:x} end {2:x}'.format(client_name, start, end))
+
+        sysregs = SysRegDump(start, end)
+        if sysregs.dump_sysreg_img(ram_dump) is False:
+            print_out_str('!!! Could not dump sysdbg_regs')
+        else:
+            ram_dump.sysreg = True
+        return
+
     def parse_vsens(self, version, start, end, client_id, ram_dump):
         client_name = self.dump_data_id_lookup_table[client_id]
 
@@ -470,6 +487,28 @@ class DebugImage_v2():
         print_out_str('--------')
         print_out_str(p.communicate()[0])
 
+    def parse_sysreg(self,ram_dump):
+        out_dir = ram_dump.outdir
+        sysreg_parser_path_minidump = os.path.join(os.path.dirname(__file__), '..', 'dcc_parser',
+                                                'sysregs_parser_minidump.py')
+        if sysreg_parser_path_minidump is None:
+            print_out_str("!!! Incorrect path for SYSREG specified.")
+            return
+        if not os.path.exists(sysreg_parser_path_minidump):
+            print_out_str("!!! sysreg_parser_path_minidump {0} does not exist! "
+                          "Check your settings!"
+                          .format(sysreg_parser_path_minidump))
+            return
+        if os.path.getsize(os.path.join(out_dir, 'sysdbg_regs.bin')) > 0:
+            sysdbg_file = os.path.join(out_dir, 'sysdbg_regs.bin')
+        else:
+            return
+        p = subprocess.Popen([sys.executable, sysreg_parser_path_minidump, '-s', sysdbg_file, '--out-dir', out_dir],
+                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        print_out_str('--------')
+        print_out_str(p.communicate()[0])
+
     def sorted_dump_data_clients(self, ram_dump, table, table_num_entries):
         """ Returns a sorted list of (client_name, func, client_address) where
 
@@ -768,6 +807,8 @@ class DebugImage_v2():
                                 client_end, client_id, ram_dump)
         if ram_dump.dcc:
             self.parse_dcc(ram_dump)
+        if ram_dump.sysreg:
+            self.parse_sysreg(ram_dump)
         self.qdss.dump_standard(ram_dump)
         if not ram_dump.skip_qdss_bin:
             self.qdss.save_etf_bin(ram_dump)

linux-ramdump-parser-v2/ramdump.py

@@ -528,6 +528,7 @@ class RamDump():
         self.qtf = options.qtf
         self.skip_qdss_bin = options.skip_qdss_bin
         self.dcc = False
+        self.sysreg = False
         self.t32_host_system = options.t32_host_system or None
         self.ipc_log_test = options.ipc_test
         self.ipc_log_skip = options.ipc_skip

linux-ramdump-parser-v2/sysregs.py

+# Copyright (c) 2015-2017, The Linux Foundation. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 and
+# only version 2 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that 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.
+
+import struct
+import os
+from print_out import print_out_str
+from ramparse import VERSION
+
+class SysRegDump():
+
+    def __init__(self, start, end):
+        self.start_addr = start
+        self.end_addr = end
+
+    def dump_sysreg_img(self,ram_dump):
+        if self.start_addr >= self.end_addr:
+            return False
+        rsz = self.end_addr - self.start_addr
+        sysregfile = ram_dump.open_file('sysdbg_regs.bin')
+        for i in range(0, rsz):
+            val = ram_dump.read_byte(self.start_addr + i, False)
+            sysregfile.write(struct.pack('<B', val))
+
+        sysregfile.close()