Use Logger, NIOAsyncChannel

Author: MaxDesiatov

Sources/GDBRemoteProtocol/GDBHostCommand.swift

@@ -2,11 +2,9 @@
 /// * https://sourceware.org/gdb/current/onlinedocs/gdb.html/General-Query-Packets.html
 /// * https://lldb.llvm.org/resources/lldbgdbremote.html
 package struct GDBHostCommand: Equatable {
-    package enum Kind: Equatable {
+    package enum Kind: String, Equatable {
         // Currently listed in the order that LLDB sends them in.
-        case generalRegisters
         case startNoAckMode
-        case firstThreadInfo
         case supportedFeatures
         case isThreadSuffixSupported
         case listThreadsInStopReply
@@ -16,6 +14,10 @@ package struct GDBHostCommand: Equatable {
         case enableErrorStrings
         case processInfo
         case currentThreadID
+        case firstThreadInfo
+        case subsequentThreadInfo
+
+        case generalRegisters
 
         package init?(rawValue: String) {
             switch rawValue {
@@ -41,6 +43,10 @@ package struct GDBHostCommand: Equatable {
                 self = .processInfo
             case "qC":
                 self = .currentThreadID
+            case "qfThreadInfo":
+                self = .firstThreadInfo
+            case "qsThreadInfo":
+                self = .subsequentThreadInfo
             default:
                 return nil
             }

Sources/GDBRemoteProtocol/GDBHostCommandDecoder.swift

@@ -1,3 +1,4 @@
+import Logging
 import NIOCore
 
 extension ByteBuffer {
@@ -20,27 +21,39 @@ package struct GDBHostCommandDecoder: ByteToMessageDecoder {
 
     package typealias InboundOut = GDBPacket<GDBHostCommand>
 
+    private var accumulatedDelimiter: UInt8?
+
     private var accummulatedKind = [UInt8]()
     private var accummulatedArguments = [UInt8]()
 
-    package init() {}
+    private let logger: Logger
+
+    package init(logger: Logger) { self.logger = logger }
 
     private var accummulatedSum = 0
     package var accummulatedChecksum: UInt8 {
         UInt8(self.accummulatedSum % 256)
     }
 
     mutating package func decode(buffer: inout ByteBuffer) throws -> GDBPacket<GDBHostCommand>? {
+        guard let firstStartDelimiter = self.accumulatedDelimiter ?? buffer.readInteger(as: UInt8.self) else {
+            // Not enough data to parse.
+            return nil
+        }
+        guard let secondStartDelimiter = buffer.readInteger(as: UInt8.self) else {
+            // Preserve what we already read.
+            self.accumulatedDelimiter = firstStartDelimiter
+
+            // Not enough data to parse.
+            return nil
+        }
+
         // Command start delimiters.
-        let firstStartDelimiter = buffer.readInteger(as: UInt8.self)
-        let secondStartDelimiter = buffer.readInteger(as: UInt8.self)
         guard
             firstStartDelimiter == UInt8(ascii: "+")
                 && secondStartDelimiter == UInt8(ascii: "$")
         else {
-            if let firstStartDelimiter, let secondStartDelimiter {
-                print("unexpected delimiter: \(Character(UnicodeScalar(firstStartDelimiter)))\(Character(UnicodeScalar(secondStartDelimiter)))")
-            }
+            logger.error("unexpected delimiter: \(Character(UnicodeScalar(firstStartDelimiter)))\(Character(UnicodeScalar(secondStartDelimiter)))")
             throw Error.expectedCommandStart
         }
 
@@ -70,6 +83,7 @@ package struct GDBHostCommandDecoder: ByteToMessageDecoder {
         }
 
         defer {
+            self.accumulatedDelimiter = nil
             self.accummulatedKind = []
             self.accummulatedArguments = []
             self.accummulatedSum = 0
@@ -108,7 +122,7 @@ package struct GDBHostCommandDecoder: ByteToMessageDecoder {
         context: ChannelHandlerContext,
         buffer: inout ByteBuffer
     ) throws -> DecodingState {
-        print(buffer.peekString(length: buffer.readableBytes)!)
+        logger.trace(.init(stringLiteral: buffer.peekString(length: buffer.readableBytes)!))
 
         guard let command = try self.decode(buffer: &buffer) else {
             return .needMoreData

Sources/GDBRemoteProtocol/GDBPacket.swift

@@ -1,4 +1,4 @@
-package struct GDBPacket<Payload> {
+package struct GDBPacket<Payload: Sendable>: Sendable {
     package let payload: Payload
 
     package let checksum: UInt8

Sources/GDBRemoteProtocol/GDBTargetResponse.swift

@@ -11,7 +11,7 @@ package enum VContActions: String {
 package struct GDBTargetResponse {
     package enum Kind {
         case ok
-        case hostInfo(KeyValuePairs<String, String>)
+        case keyValuePairs(KeyValuePairs<String, String>)
         case vContSupportedActions([VContActions])
         case raw(String)
         case empty

Sources/WasmKitGDBHandler/WasmKitDebugger.swift

@@ -0,0 +1,68 @@
+import GDBRemoteProtocol
+import Logging
+import SystemPackage
+import WasmKit
+
+package actor WasmKitDebugger {
+    /// Whether `QStartNoAckMode` command was previously sent.
+    private var isNoAckModeActive = false
+
+    private let module: Module
+    private let logger: Logger
+
+    package init(logger: Logger, moduleFilePath: FilePath) throws {
+        self.logger = logger
+        self.module = try parseWasm(filePath: moduleFilePath)
+    }
+
+    package func handle(command: GDBHostCommand) -> GDBTargetResponse {
+        let responseKind: GDBTargetResponse.Kind
+        logger.trace("handling GDB host command", metadata: ["GDBHostCommand": .string(command.kind.rawValue)])
+
+        responseKind = switch command.kind {
+        case .startNoAckMode, .isThreadSuffixSupported, .listThreadsInStopReply:
+            .ok
+
+        case .hostInfo:
+            .keyValuePairs([
+                "arch": "wasm32",
+                "ptrsize": "4",
+                "endian": "little",
+                "ostype": "wasip1",
+                "vendor": "WasmKit",
+            ])
+
+        case .supportedFeatures:
+            // FIXME: should return a different set of supported features instead of echoing.
+            .raw(command.arguments)
+
+        case .vContSupportedActions:
+            .vContSupportedActions([.continue, .step, .stop])
+
+        case .isVAttachOrWaitSupported, .enableErrorStrings:
+            .empty
+        case .processInfo:
+            .raw("pid:1;parent-pid:1;arch:wasm32;endian:little;ptrsize:4;")
+
+        case .currentThreadID:
+            .raw("QC1")
+
+        case .firstThreadInfo:
+            .raw("m1")
+
+        case .subsequentThreadInfo:
+            .raw("l")
+
+        case .generalRegisters:
+            fatalError()
+        }
+
+        defer {
+            if command.kind == .startNoAckMode {
+                self.isNoAckModeActive = true
+            }
+        }
+        return .init(kind: responseKind, isNoAckModeActive: self.isNoAckModeActive)
+    }
+
+}

Sources/WasmKitGDBHandler/WasmKitGDBHandler.swift

@@ -14,16 +14,46 @@
 
 import ArgumentParser
 import GDBRemoteProtocol
+import Logging
 import NIOCore
 import NIOPosix
+import SystemPackage
 import WasmKitGDBHandler
 
+#if hasFeature(RetroactiveAttribute)
+    extension Logger.Level: @retroactive ExpressibleByArgument {}
+    extension FilePath: @retroactive ExpressibleByArgument {
+        public init?(argument: String) {
+            self.init(argument)
+        }
+    }
+#else
+    extension Logger.Level: ExpressibleByArgument {}
+    extension FilePath: ExpressibleByArgument {
+        public init?(argument: String) {
+            self.init(argument)
+        }
+    }
+#endif
+
 @main
-struct Entrypoint: ParsableCommand {
+struct Entrypoint: AsyncParsableCommand {
     @Option(help: "TCP port that a debugger can connect to")
     var port = 8080
 
-    func run() throws {
+    @Option(name: .shortAndLong)
+    var logLevel = Logger.Level.info
+
+    @Argument
+    var wasmModulePath: FilePath
+
+    func run() async throws {
+        let logger = {
+            var result = Logger(label: "org.swiftwasm.WasmKit")
+            result.logLevel = self.logLevel
+            return result
+        }()
+
         let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
         let bootstrap = ServerBootstrap(group: group)
             // Specify backlog and enable SO_REUSEADDR for the server itself
@@ -38,9 +68,8 @@ struct Entrypoint: ParsableCommand {
                     // make sure to instantiate your `ChannelHandlers` inside of
                     // the closure as it will be invoked once per connection.
                     try channel.pipeline.syncOperations.addHandlers([
-                        ByteToMessageHandler(GDBHostCommandDecoder()),
+                        ByteToMessageHandler(GDBHostCommandDecoder(logger: logger)),
                         MessageToByteHandler(GDBTargetResponseEncoder()),
-                        WasmKitGDBHandler(),
                     ])
                 }
             }
@@ -49,11 +78,38 @@ struct Entrypoint: ParsableCommand {
             .childChannelOption(.socketOption(.so_reuseaddr), value: 1)
             .childChannelOption(.maxMessagesPerRead, value: 16)
             .childChannelOption(.recvAllocator, value: AdaptiveRecvByteBufferAllocator())
-        let channel = try bootstrap.bind(host: "127.0.0.1", port: port).wait()
+
+        let serverChannel = try await bootstrap.bind(host: "127.0.0.1", port: port) { childChannel in
+            childChannel.eventLoop.makeCompletedFuture {
+                try NIOAsyncChannel<GDBPacket<GDBHostCommand>, GDBTargetResponse>(
+                    wrappingChannelSynchronously: childChannel
+                )
+            }
+        }
         /* the server will now be accepting connections */
-        print("listening on port \(port)")
+        logger.info("listening on port \(port)")
+
+        let debugger = try WasmKitDebugger(logger: logger, moduleFilePath: self.wasmModulePath)
+
+        try await withThrowingDiscardingTaskGroup { group in
+            try await serverChannel.executeThenClose { serverChannelInbound in
+                for try await connectionChannel in serverChannelInbound {
+                    group.addTask {
+                        do {
+                            try await connectionChannel.executeThenClose { connectionChannelInbound, connectionChannelOutbound in
+                                for try await inboundData in connectionChannelInbound {
+                                    // Let's echo back all inbound data
+                                    try await connectionChannelOutbound.write(debugger.handle(command: inboundData.payload))
+                                }
+                            }
+                        } catch {
+                            logger.error("Error in GDB remote protocol connection channel", metadata: ["error": "\(error)"])
+                        }
+                    }
+                }
+            }
+        }
 
-        try channel.closeFuture.wait()  // wait forever as we never close the Channel
-        try group.syncShutdownGracefully()
+        try await group.shutdownGracefully()
     }
 }