Use a single Mutex per type

Author: dkovba

Sources/Services/ContainerNetworkService/ReservedVmnetNetwork.swift

@@ -29,11 +29,13 @@ import vmnet
 /// Creates a vmnet network with reservation APIs.
 @available(macOS 26, *)
 public final class ReservedVmnetNetwork: Network {
-    private let _state: Mutex<NetworkState>
-    private let log: Logger
+    private struct State {
+        var networkState: NetworkState
+        var network: vmnet_network_ref?
+    }
 
-    private let network = Mutex<vmnet_network_ref?>(nil)
-    private let networkLock = NSLock()
+    private let stateMutex: Mutex<State>
+    private let log: Logger
 
     /// Configure a bridge network that allows external system access using
     /// network address translation.
@@ -47,25 +49,25 @@ public final class ReservedVmnetNetwork: Network {
 
         log.info("creating vmnet network")
         self.log = log
-        _state = Mutex(.created(configuration))
+        let initialState = State(networkState: .created(configuration))
+        stateMutex = Mutex(initialState)
         log.info("created vmnet network")
     }
 
     public var state: NetworkState {
-        get async { _state.withLock { $0 } }
+        stateMutex.withLock { $0.networkState }
     }
 
     public nonisolated func withAdditionalData(_ handler: (XPCMessage?) throws -> Void) throws {
-        try networkLock.withLock {
-            let network = self.network.withLock { $0 }
-            try handler(network.map { try Self.serialize_network_ref(ref: $0) })
+        try stateMutex.withLock { state in
+            try handler(state.network.map { try Self.serialize_network_ref(ref: $0) })
         }
     }
 
     public func start() async throws {
-        let state = _state.withLock { $0 }
-        guard case .created(let configuration) = state else {
-            throw ContainerizationError(.invalidArgument, message: "cannot start network that is in \(state.state) state")
+        let networkState = stateMutex.withLock { $0.networkState }
+        guard case .created(let configuration) = networkState else {
+            throw ContainerizationError(.invalidArgument, message: "cannot start network that is in \(networkState.state) state")
         }
 
         try startNetwork(configuration: configuration, log: log)
@@ -124,11 +126,6 @@ public final class ReservedVmnetNetwork: Network {
             throw ContainerizationError(.unsupported, message: "failed to create vmnet network with status \(status)")
         }
 
-        let newNetwork = { network }  // A workaround for "'inout sending' parameter '$0' cannot be task-isolated at end of function".
-        self.network.withLock {
-            $0 = newNetwork()
-        }
-
         // retrieve the subnet since the caller may not have provided one
         var subnetAddr = in_addr()
         var maskAddr = in_addr()
@@ -139,8 +136,14 @@ public final class ReservedVmnetNetwork: Network {
         let upper = IPv4Address(fromValue: lower.value + ~maskValue)
         let runningSubnet = try CIDRAddress(lower: lower, upper: upper)
         let runningGateway = IPv4Address(fromValue: runningSubnet.lower.value + 1)
-        let newState = NetworkState.running(configuration, NetworkStatus(address: runningSubnet.description, gateway: runningGateway.description))
-        self._state.withLock { $0 = newState }
+        let networkState = NetworkState.running(configuration, NetworkStatus(address: runningSubnet.description, gateway: runningGateway.description))
+
+        let newNetwork = { network }  // A workaround for "'inout sending' parameter '$0' cannot be task-isolated at end of function".
+        stateMutex.withLock { state in
+            state.network = newNetwork()
+            state.networkState = networkState
+        }
+
         log.info(
             "started vmnet network",
             metadata: [

Sources/SocketForwarder/UDPForwarder.swift

@@ -42,8 +42,8 @@ private final class UDPProxyBackend: ChannelInboundHandler, Sendable {
         self.serverAddress = serverAddress
         self.frontendChannel = frontendChannel
         self.log = log
-        let state = State(queuedPayloads: Deque(), channel: nil)
-        self.state = Mutex(state)
+        let initialState = State(queuedPayloads: Deque(), channel: nil)
+        self.state = Mutex(initialState)
     }
 
     func channelRead(context: ChannelHandlerContext, data: NIOAny) {