You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nuttx.apache.org by xi...@apache.org on 2023/08/21 10:27:14 UTC

[nuttx] 03/05: minidumpserver.py:Print the line number of logfile when the format is wrong

This is an automated email from the ASF dual-hosted git repository.

xiaoxiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git

commit ffb391f6aa18ebe8188fb6eaea2fa9186bc45b0a
Author: anjiahao <an...@xiaomi.com>
AuthorDate: Wed Jul 5 15:38:40 2023 +0800

    minidumpserver.py:Print the line number of logfile when the format is wrong
    
    Signed-off-by: anjiahao <an...@xiaomi.com>
---
 tools/minidumpserver.py | 135 +++++++++++++++++++++++++-----------------------
 1 file changed, 71 insertions(+), 64 deletions(-)

diff --git a/tools/minidumpserver.py b/tools/minidumpserver.py
index b8f9442c8b..67638f9cbe 100755
--- a/tools/minidumpserver.py
+++ b/tools/minidumpserver.py
@@ -247,79 +247,86 @@ class dump_log_file:
         start = 0
         if self.fd is None:
             self.open()
-        while 1:
-            line = self.fd.readline()
-            if line == "":
-                break
 
-            tmp = re.search("up_dump_register:", line)
-            if tmp is not None:
-                # find arch
-                if arch is None:
-                    self.arch = tmp.group(1)
-                else:
-                    self.arch = arch
-
-                if self.arch not in reg_table:
-                    logger.error("%s not supported" % (self.arch))
-                # init register list
-                if len(self.registers) == 0:
-                    for x in range(max(reg_table[self.arch].values()) + 1):
-                        self.registers.append(b"x")
-
-                # find register value
-                line = line[tmp.span()[1] :]
-                line = line.replace("\n", " ")
-                while 1:
-                    tmp = re.search("([^ ]+):", line)
-                    if tmp is None:
-                        break
-                    register = tmp.group(1)
-                    line = line[tmp.span()[1] :]
-                    tmp = re.search("([0-9a-fA-F]+) ", line)
-                    if tmp is None:
-                        break
-                    if register in reg_table[self.arch].keys():
-                        self.registers[reg_table[self.arch][register]] = int(
-                            "0x" + tmp.group().replace(" ", ""), 16
-                        )
-                    line = line[tmp.span()[1] :]
-                continue
+        linenumber = 0
+        try:
+            while 1:
+                line = self.fd.readline()
+                if line == "":
+                    break
 
-            tmp = re.search("stack_dump:", line)
-            if tmp is not None:
-                # find stackdump
-                line = line[tmp.span()[1] :]
-                tmp = re.search("([0-9a-fA-F]+):", line)
+                linenumber += 1
+                tmp = re.search("up_dump_register:", line)
                 if tmp is not None:
-                    line_start = int("0x" + tmp.group()[:-1], 16)
-
-                    if start + len(data) != line_start:
-                        # stack is not contiguous
-                        if len(data) == 0:
-                            start = line_start
-                        else:
-                            memory = {
-                                "start": start,
-                                "end": start + len(data),
-                                "data": data,
-                            }
-                            self.memories.append(memory)
-                            data = b""
-                            start = line_start
-
+                    # find arch
+                    if arch is None:
+                        self.arch = tmp.group(1)
+                    else:
+                        self.arch = arch
+
+                    if self.arch not in reg_table:
+                        logger.error("%s not supported" % (self.arch))
+                    # init register list
+                    if len(self.registers) == 0:
+                        for x in range(max(reg_table[self.arch].values()) + 1):
+                            self.registers.append(b"x")
+
+                    # find register value
                     line = line[tmp.span()[1] :]
                     line = line.replace("\n", " ")
-
                     while 1:
-                        # record stack value
-                        tmp = re.search(" ([0-9a-fA-F]+)", line)
+                        tmp = re.search("([^ ]+):", line)
+                        if tmp is None:
+                            break
+                        register = tmp.group(1)
+                        line = line[tmp.span()[1] :]
+                        tmp = re.search("([0-9a-fA-F]+) ", line)
                         if tmp is None:
                             break
-                        data = data + struct.pack(
-                            "<I", int("0x" + tmp.group().replace(" ", ""), 16)
-                        )
+                        if register in reg_table[self.arch].keys():
+                            self.registers[reg_table[self.arch][register]] = int(
+                                "0x" + tmp.group().replace(" ", ""), 16
+                            )
+                        line = line[tmp.span()[1] :]
+                    continue
+
+                tmp = re.search("stack_dump:", line)
+                if tmp is not None:
+                    # find stackdump
+                    line = line[tmp.span()[1] :]
+                    tmp = re.search("([0-9a-fA-F]+):", line)
+                    if tmp is not None:
+                        line_start = int("0x" + tmp.group()[:-1], 16)
+
+                        if start + len(data) != line_start:
+                            # stack is not contiguous
+                            if len(data) == 0:
+                                start = line_start
+                            else:
+                                memory = {
+                                    "start": start,
+                                    "end": start + len(data),
+                                    "data": data,
+                                }
+                                self.memories.append(memory)
+                                data = b""
+                                start = line_start
+
                         line = line[tmp.span()[1] :]
+                        line = line.replace("\n", " ")
+
+                        while 1:
+                            # record stack value
+                            tmp = re.search(" ([0-9a-fA-F]+)", line)
+                            if tmp is None:
+                                break
+                            data = data + struct.pack(
+                                "<I", int("0x" + tmp.group().replace(" ", ""), 16)
+                            )
+                            line = line[tmp.span()[1] :]
+        except Exception as e:
+            logger.error("parse log file error: %s linenumber %d" % (e, linenumber))
+            os._exit(0)
 
         if len(data):
             memory = {"start": start, "end": start + len(data), "data": data}