pynuttx 0.0.1__tar.gz

pynuttx-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: pynuttx
+Version: 0.0.1
+Summary: python scirpt for NuttX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Requires-Dist: angr>=0.0.0
+Requires-Dist: capstone>=0.0.0
+Requires-Dist: cloudpickle>=0.0.0
+Requires-Dist: construct>=0.0.0
+Requires-Dist: debugpy>=0.0.0
+Requires-Dist: lauterbach-trace32-rcl>=0.0.0
+Requires-Dist: lief>=0.0.0
+Requires-Dist: matplotlib>=0.0.0
+Requires-Dist: mcp>=0.0.0
+Requires-Dist: numpy>=0.0.0
+Requires-Dist: pandas>=0.0.0
+Requires-Dist: pillow>=0.0.0
+Requires-Dist: plotly>=0.0.0
+Requires-Dist: prettytable>=0.0.0
+Requires-Dist: pyelftools>=0.0.0
+Requires-Dist: pylink-square>=0.0.0
+Requires-Dist: viztracer>=0.0.0

pynuttx-0.0.1/gdbrpc/__init__.py

@@ -0,0 +1,43 @@
+############################################################################
+# tools/pynuttx/gdbrpc/__init__.py
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+############################################################################
+
+import importlib.util
+
+__all__ = [
+    "Client",
+    "ClientCLI",
+    "PostRequest",
+    "Request",
+    "Response",
+    "PacketStatus",
+    "Server",
+    "ShellExec",
+]
+
+# Client must be imported first because ClientCLI depends on it
+from .client import Client
+from .utils import PacketStatus, PostRequest, Request, Response, ShellExec
+
+if importlib.util.find_spec("gdb") is not None:
+    from .server import Server  # noqa: F401
+
+from .cli import ClientCLI

pynuttx-0.0.1/gdbrpc/__main__.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+############################################################################
+# tools/pynuttx/gdbrpc/__main__.py
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+############################################################################
+
+import argparse
+import os
+import sys
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+if __name__ == "__main__":
+    import gdbrpc
+
+    parser = argparse.ArgumentParser(description="GDB Socket Client")
+    parser.add_argument("--host", default="localhost", help="Server host")
+    parser.add_argument("--port", type=int, default=20819, help="Server port")
+
+    args = parser.parse_args()
+
+    client = gdbrpc.ClientCLI(args.host, args.port)
+    client.start()

pynuttx-0.0.1/gdbrpc/cli.py

@@ -0,0 +1,65 @@
+############################################################################
+# tools/pynuttx/gdbrpc/cli.py
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+############################################################################
+
+import logging
+
+from gdbrpc.client import Client
+from gdbrpc.utils import ShellExec
+
+
+class ClientCLI(Client):
+    def __init__(self, host, port):
+        super().__init__(host, port, logLevel=logging.WARNING)
+
+    def _show_command_help(self):
+        print("Welcome to the GDB Remote Protocol Client")
+        print("Type `exit` or `quit` to disconnect.")
+        print("Type `help` to show this help message.")
+        print("If you need `interrupt` command to stop the target, use Ctrl+C.")
+
+    def _loop(self):
+        print("gdb> ", end="", flush=True)
+        while True:
+            try:
+                command = input().strip()
+                if not command:
+                    continue
+                if command.lower() in ("exit", "quit"):
+                    self.disconnect()
+                    break
+                if command.lower() == "help":
+                    self._show_command_help()
+                    print("gdb> ", end="", flush=True)
+                    continue
+                print(self.call(ShellExec(command)))
+                print("gdb> ", end="", flush=True)
+            except KeyboardInterrupt:
+                print("")
+                self.call(ShellExec("interrupt"))
+                print("gdb> ", end="", flush=True)
+            except EOFError:
+                self.disconnect()
+
+    def start(self):
+        assert self.connect()
+        self._show_command_help()
+        self._loop()

pynuttx-0.0.1/gdbrpc/client.py

@@ -0,0 +1,170 @@
+############################################################################
+# tools/pynuttx/gdbrpc/client.py
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+############################################################################
+
+import logging
+import os
+import queue
+import socket
+import sys
+import threading
+from datetime import datetime
+from typing import Dict, Optional, Tuple
+
+import cloudpickle as pickle
+from gdbrpc.utils import (
+    DEFAULT_TIMEOUT,
+    PacketStatus,
+    PostRequest,
+    Request,
+    Response,
+    socket_recv,
+    socket_send,
+)
+
+
+class Client:
+    def __init__(self, host="localhost", port=20819, logLevel=logging.INFO):
+        self._host = host
+        self._port = port
+        self._socket: socket.socket
+        self._connected = False
+        self._response = queue.Queue()
+        self._pending_requests: Dict[int, PostRequest] = {}
+
+        self._logger = logging.getLogger(__name__)
+        if not self._logger.hasHandlers():
+            self._logger.setLevel(logLevel)
+            timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+            pid = os.getpid()
+            handler = logging.FileHandler(f"gdbrpc_client-{timestamp}-pid{pid}.log")
+            formatter = logging.Formatter("%(asctime)s gdbrpc_client: %(message)s")
+            handler.setFormatter(formatter)
+            self._logger.addHandler(handler)
+
+    def connect(self):
+        try:
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self._socket.connect((self._host, self._port))
+            self._connected = True
+            logging.info(f"Connected to GDB server at {self._host}:{self._port}")
+
+            threading.Thread(
+                target=self._listen_responses, daemon=True, args=(self._socket,)
+            ).start()
+
+            return True
+        except Exception as e:
+            logging.error(f"Failed to connect {self._host}:{self._port}: {e}")
+            return False
+
+    def _listen_responses(self, socket: socket.socket):
+        try:
+            while self._connected:
+                data: Tuple[Response, PacketStatus] = pickle.loads(
+                    socket_recv(socket, self._logger)
+                )
+                response, status = data
+                self._logger.debug(
+                    f"Received response for request ID {response.tag}, current queue: {self._pending_requests}"
+                )
+
+                if status == PacketStatus.PYTHON_VERSION_MISMATCH:
+                    response.payload += f"\nclient python version: {sys.version}"
+                    self._response.put(response.payload)
+                elif (
+                    status == PacketStatus.HAS_CALLBACK
+                    and response.tag in self._pending_requests
+                ):
+                    self._logger.debug(f"Handling callback for request ID {status}")
+                    callback = self._pending_requests.get(response.tag)
+
+                    assert isinstance(callback, PostRequest)
+
+                    try:
+                        callback(response.payload)
+                    except Exception as e:
+                        self._logger.error(
+                            f"Error in callback {callback}, which raised an exception: {e}"
+                        )
+                    finally:
+                        callback.finish.set()
+                else:
+                    self._response.put(response)
+                    self._logger.debug(
+                        f"Response for request ID {response.tag} put into response queue"
+                    )
+                self._logger.info(
+                    f"Received data: {response.payload}. from {self._host}:{self._port}"
+                )
+        except ConnectionError:
+            self._logger.info("Connection closed by server")
+            self.disconnect()
+        except Exception as e:
+            self._logger.error(f"Error receiving data: {e}")
+            self.disconnect()
+
+    def disconnect(self):
+        self._connected = False
+        self._logger.info("Disconnecting...")
+        if self._socket:
+            try:
+                self._socket.close()
+                self._logger.info("Socket closed successfully.")
+            except Exception as e:
+                self._logger.error(f"Error closing socket: {e}")
+        self._logger.info("Disconnected")
+
+    def no_pending_requests(self) -> bool:
+        return len(self._pending_requests) == 0
+
+    def call(
+        self,
+        request: Request,
+        post_request: Optional[PostRequest] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ):
+        if not self._connected:
+            raise ConnectionError("Not connected to server")
+        if not isinstance(request, Request):
+            raise TypeError("request must be a Request instance")
+        if post_request is not None and not isinstance(post_request, PostRequest):
+            raise TypeError("post_request must be a PostRequest instance or None")
+
+        if post_request is not None:
+            self._logger.debug(f"Registering callback for request ID {request.tag}")
+            self._pending_requests[request.tag] = post_request
+            payload = (request, PacketStatus.HAS_CALLBACK)
+        else:
+            self._logger.debug(f"No callback for request ID {request.tag}")
+            payload = (request, PacketStatus.NO_CALLBACK)
+
+        self._logger.debug(f"Sending request: {request} to {self._host}:{self._port}")
+
+        socket_send(self._socket, pickle.dumps(payload), self._logger)
+
+        try:
+            rs = self._response.get(timeout=timeout)
+        except queue.Empty:
+            self._logger.error("Request timed out")
+            raise TimeoutError("Request timed out")
+
+        return rs.payload

pynuttx-0.0.1/gdbrpc/examples/getheaps.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python3
+############################################################################
+# tools/pynuttx/gdbrpc/examples/getheaps.py
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+############################################################################
+
+import os
+import queue
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+import gdbrpc  # noqa: E402
+
+
+class Func(gdbrpc.Request):
+    def __init__(self):
+        super().__init__()
+
+    def __call__(self, q: queue.Queue):
+        import nxgdb
+
+        heaps = nxgdb.mm.get_heaps()
+        for heap in heaps:
+            print(heap)
+        q.put(list(map(str, heaps)))
+
+
+if __name__ == "__main__":
+
+    client = gdbrpc.Client()
+
+    assert client.connect()
+
+    print(client.call(Func(), timeout=10))
+
+    client.disconnect()

pynuttx-0.0.1/gdbrpc/examples/memleak.py

@@ -0,0 +1,67 @@
+#!/usr/bin/python3
+############################################################################
+# tools/pynuttx/gdbrpc/examples/memleak.py
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+############################################################################
+
+import logging
+import os
+import queue
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+import gdbrpc  # noqa: E402
+
+
+class FetchResult(gdbrpc.PostRequest):
+    def __init__(self):
+        super().__init__()
+
+    def __call__(self, result):
+        print(result)
+
+
+class MemLeak(gdbrpc.Request):
+    def __init__(self):
+        super().__init__()
+
+    def __call__(self, q: queue.Queue):
+        import gdb
+
+        q.put(gdb.execute("memleak", to_string=True))
+
+
+if __name__ == "__main__":
+
+    client = gdbrpc.Client(logLevel=logging.DEBUG)
+
+    assert client.connect()
+
+    bt = FetchResult()
+    client.call(MemLeak(), bt)
+
+    print("Waiting for async call to complete...")
+
+    bt.finish.wait()
+
+    print("Async call completed.")
+
+    client.disconnect()