netstack3_core/device/
socket.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! Implementations of traits defined in foreign modules for the types defined
6//! in the device socket module.
7
8use lock_order::lock::{DelegatedOrderedLockAccess, LockLevelFor};
9use lock_order::relation::LockBefore;
10use netstack3_device::socket::{
11    AllSockets, AnyDeviceSockets, DeviceSocketAccessor, DeviceSocketContext, DeviceSocketId,
12    DeviceSockets, HeldSockets, SocketStateAccessor, Target,
13};
14use netstack3_device::{DeviceId, WeakDeviceId, for_any_device_id};
15
16use crate::context::WrapLockLevel;
17use crate::context::prelude::*;
18use crate::device::integration;
19use crate::{BindingsContext, BindingsTypes, CoreCtx, StackState};
20
21impl<BC: BindingsContext, L: LockBefore<crate::lock_ordering::AllDeviceSockets>>
22    DeviceSocketContext<BC> for CoreCtx<'_, BC, L>
23{
24    type SocketTablesCoreCtx<'a> =
25        CoreCtx<'a, BC, WrapLockLevel<crate::lock_ordering::AnyDeviceSockets>>;
26
27    fn with_all_device_sockets<
28        F: FnOnce(&AllSockets<Self::WeakDeviceId, BC>, &mut Self::SocketTablesCoreCtx<'_>) -> R,
29        R,
30    >(
31        &mut self,
32        cb: F,
33    ) -> R {
34        let (sockets, mut locked) = self.read_lock_and::<crate::lock_ordering::AllDeviceSockets>();
35        let mut locked = locked.cast_locked::<crate::lock_ordering::AnyDeviceSockets>();
36        cb(&*sockets, &mut locked)
37    }
38
39    fn with_all_device_sockets_mut<F: FnOnce(&mut AllSockets<Self::WeakDeviceId, BC>) -> R, R>(
40        &mut self,
41        cb: F,
42    ) -> R {
43        let mut locked = self.write_lock::<crate::lock_ordering::AllDeviceSockets>();
44        cb(&mut locked)
45    }
46
47    fn with_any_device_sockets<
48        F: FnOnce(&AnyDeviceSockets<Self::WeakDeviceId, BC>, &mut Self::SocketTablesCoreCtx<'_>) -> R,
49        R,
50    >(
51        &mut self,
52        cb: F,
53    ) -> R {
54        let (sockets, mut locked) = self.read_lock_and::<crate::lock_ordering::AnyDeviceSockets>();
55        cb(&*sockets, &mut locked)
56    }
57
58    fn with_any_device_sockets_mut<
59        F: FnOnce(
60            &mut AnyDeviceSockets<Self::WeakDeviceId, BC>,
61            &mut Self::SocketTablesCoreCtx<'_>,
62        ) -> R,
63        R,
64    >(
65        &mut self,
66        cb: F,
67    ) -> R {
68        let (mut sockets, mut locked) =
69            self.write_lock_and::<crate::lock_ordering::AnyDeviceSockets>();
70        cb(&mut *sockets, &mut locked)
71    }
72}
73
74impl<BC: BindingsContext, L: LockBefore<crate::lock_ordering::DeviceSocketState>>
75    SocketStateAccessor<BC> for CoreCtx<'_, BC, L>
76{
77    fn with_socket_state<F: FnOnce(&Target<Self::WeakDeviceId>) -> R, R>(
78        &mut self,
79        id: &DeviceSocketId<Self::WeakDeviceId, BC>,
80        cb: F,
81    ) -> R {
82        let mut locked = self.adopt(id);
83        let guard = locked.lock_with::<crate::lock_ordering::DeviceSocketState, _>(|c| c.right());
84        cb(&*guard)
85    }
86
87    fn with_socket_state_mut<F: FnOnce(&mut Target<Self::WeakDeviceId>) -> R, R>(
88        &mut self,
89        id: &DeviceSocketId<Self::WeakDeviceId, BC>,
90        cb: F,
91    ) -> R {
92        let mut locked = self.adopt(id);
93        let mut guard =
94            locked.lock_with::<crate::lock_ordering::DeviceSocketState, _>(|c| c.right());
95        cb(&mut *guard)
96    }
97}
98
99impl<BC: BindingsContext, L: LockBefore<crate::lock_ordering::DeviceSockets>>
100    DeviceSocketAccessor<BC> for CoreCtx<'_, BC, L>
101{
102    type DeviceSocketCoreCtx<'a> =
103        CoreCtx<'a, BC, WrapLockLevel<crate::lock_ordering::DeviceSockets>>;
104
105    fn with_device_sockets<
106        F: FnOnce(&DeviceSockets<Self::WeakDeviceId, BC>, &mut Self::DeviceSocketCoreCtx<'_>) -> R,
107        R,
108    >(
109        &mut self,
110        device: &Self::DeviceId,
111        cb: F,
112    ) -> R {
113        for_any_device_id!(
114            DeviceId,
115            device,
116            device => {
117                let mut core_ctx_and_resource =
118                    integration::device_state_and_core_ctx(self, device);
119                let (device_sockets, mut locked) = core_ctx_and_resource
120                    .read_lock_with_and::<crate::lock_ordering::DeviceSockets, _>(
121                    |c| c.right(),
122                );
123                cb(&*device_sockets, &mut locked.cast_core_ctx())
124            }
125        )
126    }
127
128    fn with_device_sockets_mut<
129        F: FnOnce(&mut DeviceSockets<Self::WeakDeviceId, BC>, &mut Self::DeviceSocketCoreCtx<'_>) -> R,
130        R,
131    >(
132        &mut self,
133        device: &Self::DeviceId,
134        cb: F,
135    ) -> R {
136        for_any_device_id!(
137            DeviceId,
138            device,
139            device => {
140                let mut core_ctx_and_resource =
141                    integration::device_state_and_core_ctx(self, device);
142                let (mut device_sockets, mut locked) = core_ctx_and_resource
143                    .write_lock_with_and::<crate::lock_ordering::DeviceSockets, _>(
144                    |c| c.right(),
145                );
146                cb(&mut *device_sockets, &mut locked.cast_core_ctx())
147            }
148        )
149    }
150}
151
152impl<BT: BindingsTypes> DelegatedOrderedLockAccess<AnyDeviceSockets<WeakDeviceId<BT>, BT>>
153    for StackState<BT>
154{
155    type Inner = HeldSockets<BT>;
156    fn delegate_ordered_lock_access(&self) -> &Self::Inner {
157        &self.device.shared_sockets
158    }
159}
160
161impl<BT: BindingsTypes> DelegatedOrderedLockAccess<AllSockets<WeakDeviceId<BT>, BT>>
162    for StackState<BT>
163{
164    type Inner = HeldSockets<BT>;
165    fn delegate_ordered_lock_access(&self) -> &Self::Inner {
166        &self.device.shared_sockets
167    }
168}
169
170impl<BT: BindingsTypes> LockLevelFor<StackState<BT>> for crate::lock_ordering::AnyDeviceSockets {
171    type Data = AnyDeviceSockets<WeakDeviceId<BT>, BT>;
172}
173
174impl<BT: BindingsTypes> LockLevelFor<StackState<BT>> for crate::lock_ordering::AllDeviceSockets {
175    type Data = AllSockets<WeakDeviceId<BT>, BT>;
176}
177
178impl<BT: BindingsTypes> LockLevelFor<DeviceSocketId<WeakDeviceId<BT>, BT>>
179    for crate::lock_ordering::DeviceSocketState
180{
181    type Data = Target<WeakDeviceId<BT>>;
182}
netstack3_core/device/socket.rs

netstack3_core/device/
socket.rs
