| # Copyright 2026 The Fuchsia Authors. All rights reserved. | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| from typing import Literal | |
| from pydantic import Field | |
| from pydap.dap_types import DapBaseModel, StackFrame, Thread | |
| from pydap.models import ( | |
| Event, | |
| PauseArguments, | |
| Response, | |
| StackTraceResponse, | |
| StackTraceResponseBody, | |
| ThreadEvent, | |
| ThreadEventBody, | |
| ThreadsResponse, | |
| ThreadsResponseBody, | |
| ) | |
| UnwinderType = Literal["cfi", "fp", "scs", "plt", "armehabi", "sigreturn"] | |
| class ZxdbStackFrame(StackFrame): | |
| """Zxdb-specific stack frame model containing trust.""" | |
| trust: str | None = None | |
| class ZxdbStackTraceResponseBody(StackTraceResponseBody): | |
| """Body of response to `stackTrace` request containing zxdb stack frames.""" | |
| stack_frames: list[ZxdbStackFrame] | |
| class ZxdbStackTraceResponse(StackTraceResponse): | |
| """Response to `stackTrace` request with zxdb-specific frame info.""" | |
| body: ZxdbStackTraceResponseBody | |
| class ZxdbPauseArguments(PauseArguments): | |
| """Arguments for `pause` request with zxdb extensions. | |
| Attributes: | |
| process_id: Optional process ID to pause. | |
| """ | |
| # We have to explicitly override thread_id: int = Field(default=0) on | |
| # ZxdbPauseArguments because Pydantic v2 inherits field requiredness | |
| # from the parent class when not overridden. | |
| thread_id: int = Field(default=0) | |
| process_id: int | |
| class ZxdbProcessStoppedEventBody(DapBaseModel): | |
| """Body of the `processStopped` event. | |
| Attributes: | |
| process_id: Process ID (KOID). | |
| name: Process name. | |
| threads: List of thread IDs (KOIDs) stopped in the process. | |
| """ | |
| process_id: int | |
| name: str | None = None | |
| threads: list[int] = Field(default_factory=list) | |
| class ZxdbProcessStoppedEvent(Event): | |
| """Zxdb-specific processStopped event.""" | |
| type: Literal["event"] = "event" | |
| event: Literal["processStopped"] = "processStopped" | |
| body: ZxdbProcessStoppedEventBody | |
| class ZxdbThread(Thread): | |
| """Zxdb-specific thread model containing processId.""" | |
| process_id: int | None = None | |
| class ZxdbThreadsResponseBody(ThreadsResponseBody): | |
| """Body of response to `threads` request containing zxdb threads.""" | |
| threads: list[ZxdbThread] | |
| class ZxdbThreadsResponse(ThreadsResponse): | |
| """Response to `threads` request with zxdb specific thread info.""" | |
| body: ZxdbThreadsResponseBody | |
| class ZxdbThreadEventBody(ThreadEventBody): | |
| """Body of the thread event containing optional processId.""" | |
| process_id: int | None = None | |
| is_stopped: bool | None = None | |
| class ZxdbThreadEvent(ThreadEvent): | |
| """Zxdb-specific thread event with processId in body.""" | |
| body: ZxdbThreadEventBody | |
| class AsyncTaskNode(DapBaseModel): | |
| """Represents a node in the async task tree.""" | |
| id: str | None = None | |
| name: str | None = None | |
| file: str | None = None | |
| line: int | None = None | |
| children: list[AsyncTaskNode] = Field(default_factory=list) | |
| class AsyncBacktraceUpdateBody(DapBaseModel): | |
| """Body of zxdb.updateAsyncBacktrace event. | |
| Attributes: | |
| thread_id: Thread KOID (aliased as 'id' in DAP wire protocol). | |
| name: Name of the thread. | |
| process_id: Process KOID. | |
| tasks: Root list of async task nodes. | |
| """ | |
| thread_id: int = Field(alias="id") | |
| name: str | None = None | |
| process_id: int | |
| tasks: list[AsyncTaskNode] = Field(default_factory=list) | |
| class AsyncBacktraceUpdate(Event): | |
| """Custom event for asynchronous backtrace updates.""" | |
| type: Literal["event"] = "event" | |
| event: Literal["zxdb.updateAsyncBacktrace"] = "zxdb.updateAsyncBacktrace" | |
| body: AsyncBacktraceUpdateBody | |
| class ZxdbAsyncBacktraceArguments(DapBaseModel): | |
| """Arguments for `zxdb.AsyncBacktrace` request. | |
| Attributes: | |
| thread_id: Thread ID (KOID) to query async backtrace for. | |
| """ | |
| thread_id: int | |
| class ZxdbAsyncBacktraceResponseBody(DapBaseModel): | |
| """Body of response to `zxdb.AsyncBacktrace` request. | |
| Attributes: | |
| tasks: Root list of async task nodes. | |
| """ | |
| tasks: list[AsyncTaskNode] = Field(default_factory=list) | |
| class ZxdbAsyncBacktraceResponse(Response): | |
| """Response to `zxdb.AsyncBacktrace` request.""" | |
| body: ZxdbAsyncBacktraceResponseBody = Field( | |
| default_factory=ZxdbAsyncBacktraceResponseBody | |
| ) | |
| class ZxdbConsoleCommandArguments(DapBaseModel): | |
| """Arguments for `zxdb.ConsoleCommand` request. | |
| Attributes: | |
| command: Console command string to execute. | |
| frame_id: Optional frame ID to set as active context before executing. | |
| """ | |
| command: str | |
| frame_id: int | None = None | |
| class ZxdbConsoleCommandResponseBody(DapBaseModel): | |
| """Body of response to `zxdb.ConsoleCommand` request. | |
| Attributes: | |
| output: Output string generated by the console command. | |
| """ | |
| output: str = "" | |
| class ZxdbConsoleCommandResponse(Response): | |
| """Response to `zxdb.ConsoleCommand` request.""" | |
| body: ZxdbConsoleCommandResponseBody = Field( | |
| default_factory=ZxdbConsoleCommandResponseBody | |
| ) | |
| # LINT.IfChange | |
| class ZxdbTracepointWatchSpec(DapBaseModel): | |
| """Specification for a watchpoint on a memory expression.""" | |
| data_id: str | None = None | |
| address: int | None = None | |
| expression: str | None = None | |
| byte_size: int | None = None | |
| access_type: Literal["write", "readWrite"] | None = None | |
| class ZxdbTracepointSpec(DapBaseModel): | |
| """Specification for creating or updating a tracepoint.""" | |
| id: int | None = None | |
| function: str | None = None | |
| file: str | None = None | |
| line: int | None = None | |
| address: int | None = None | |
| watch: ZxdbTracepointWatchSpec | None = None | |
| condition: str | None = None | |
| frame: bool | None = None | |
| backtrace: bool | None = None | |
| raw_backtrace: bool | None = None | |
| expressions: list[str] | None = None | |
| max_matching_frames: int | None = None | |
| locals: bool | None = None | |
| registers: bool | None = None | |
| max_hits: int | None = None | |
| enabled: bool | None = None | |
| class ZxdbTracepointInfo(DapBaseModel): | |
| """Status information for an installed tracepoint.""" | |
| id: int | |
| verified: bool = False | |
| max_matching_frames: int | None = None | |
| hit_count: int = 0 | |
| max_hits: int = 0 | |
| enabled: bool = True | |
| auto_disabled: bool = False | |
| message: str | None = None | |
| class ZxdbSetTracepointsArguments(DapBaseModel): | |
| """Arguments for zxdb.SetTracepoints request.""" | |
| tracepoints: list[ZxdbTracepointSpec] = Field(default_factory=list) | |
| class ZxdbSetTracepointsResponseBody(DapBaseModel): | |
| """Body of response to zxdb.SetTracepoints request.""" | |
| tracepoints: list[ZxdbTracepointInfo] = Field(default_factory=list) | |
| class ZxdbSetTracepointsResponse(Response): | |
| """Response to zxdb.SetTracepoints request.""" | |
| body: ZxdbSetTracepointsResponseBody = Field( | |
| default_factory=ZxdbSetTracepointsResponseBody | |
| ) | |
| class ZxdbTracepointFrameSummary(DapBaseModel): | |
| """Summary of the frame where a tracepoint hit occurred.""" | |
| name: str = "" | |
| file: str | None = None | |
| line: int | None = None | |
| ip: int = 0 | |
| sp: int = 0 | |
| trust: str | None = None | |
| class ZxdbTracepointFrameRecord(DapBaseModel): | |
| """Single stack frame record in a captured tracepoint backtrace.""" | |
| frame_index: int = 0 | |
| name: str = "" | |
| file: str | None = None | |
| line: int | None = None | |
| ip: int = 0 | |
| sp: int = 0 | |
| trust: str | None = None | |
| elided: bool = False | |
| elide_description: str | None = None | |
| class ZxdbTracepointValue(DapBaseModel): | |
| """Captured local variable value and its type name.""" | |
| value: str | |
| type: str | None = None | |
| class ZxdbTracepointEvaluation(DapBaseModel): | |
| """Captured result, type, or error for an expression evaluation.""" | |
| result: str | None = None | |
| type: str | None = None | |
| error: str | None = None | |
| class ZxdbTracepointFrameCapture(DapBaseModel): | |
| """Full snapshot of state captured when a tracepoint triggered.""" | |
| matched: bool = True | |
| frame: ZxdbTracepointFrameSummary | None = None | |
| backtrace: list[ZxdbTracepointFrameRecord] | None = None | |
| locals: dict[str, ZxdbTracepointValue] | None = None | |
| registers: dict[str, str] | None = None | |
| evaluations: dict[str, ZxdbTracepointEvaluation] | None = None | |
| errors: list[str] = Field(default_factory=list) | |
| class ZxdbTracepointEventBody(DapBaseModel): | |
| """Body of the zxdb.Tracepoint event.""" | |
| tracepoint_id: int | |
| location: str | |
| hit_count: int | |
| max_hits: int | |
| auto_disabled: bool | |
| truncated: bool = False | |
| thread_koid: int | |
| dwell_ms: float | |
| capture: ZxdbTracepointFrameCapture | |
| class ZxdbTracepointEvent(Event): | |
| """DAP event emitted when a tracepoint triggers.""" | |
| type: Literal["event"] = "event" | |
| event: Literal["zxdb.Tracepoint"] = "zxdb.Tracepoint" | |
| body: ZxdbTracepointEventBody | |
| # LINT.ThenChange(//src/developer/debug/zxdb/debug_adapter/handlers/request_tracepoint.h) | |
| AsyncTaskNode.model_rebuild() |