dhcp_client_core/
inspect.rs

1// Copyright 2025 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
5use std::sync::atomic::{AtomicUsize, Ordering};
6use std::time::Duration;
7
8use diagnostics_traits::{InspectableValue, Inspector};
9
10use crate::parse::{IncomingResponseToRequestErrorCounters, SelectingIncomingMessageErrorCounters};
11
12/// An incrementing counter.
13#[derive(Default, Debug)]
14pub(crate) struct Counter(AtomicUsize);
15
16impl Counter {
17    pub(crate) fn increment(&self) {
18        let _: usize = self.0.fetch_add(1, Ordering::Relaxed);
19    }
20
21    pub(crate) fn load(&self) -> usize {
22        self.0.load(Ordering::Relaxed)
23    }
24}
25
26impl InspectableValue for Counter {
27    fn record<I: diagnostics_traits::Inspector>(&self, name: &str, inspector: &mut I) {
28        inspector.record_uint(name, u64::try_from(self.load()).unwrap_or(u64::MAX));
29    }
30}
31
32pub(crate) fn record_optional_duration_secs(
33    inspector: &mut impl Inspector,
34    name: &str,
35    value: Option<Duration>,
36) {
37    match value {
38        Some(value) => inspector.record_uint(name, value.as_secs()),
39        None => inspector.record_display(name, "Unset"),
40    }
41}
42
43/// Counters relating to sending and receiving messages.
44#[derive(Debug, Default)]
45pub(crate) struct MessagingRelatedCounters {
46    /// A counter for each time the client sent a message.
47    pub(crate) send_message: Counter,
48    /// A counter for each time the client received a message.
49    pub(crate) recv_message: Counter,
50    /// A counter for each time the client observed a fatal socket error while
51    /// trying to receive a message.
52    pub(crate) recv_message_fatal_socket_error: Counter,
53    /// A counter for each time the client observed a non-fatal socket error
54    /// while trying to receive a message.
55    pub(crate) recv_message_non_fatal_socket_error: Counter,
56    /// A counter for each time the client has timed out waiting to receive
57    /// (causing it to retransmit or state-transition).
58    pub(crate) recv_time_out: Counter,
59    /// A counter for each time the client received a message with the wrong
60    /// transaction ID.
61    pub(crate) recv_wrong_xid: Counter,
62    /// A counter for each time the client received a message specifying an
63    /// incorrect chaddr (client hardware address).
64    pub(crate) recv_wrong_chaddr: Counter,
65    /// A counter for each time the client received a UDPv4 packet on the
66    /// dhcp-client port that did not parse as a DHCP message.
67    pub(crate) recv_failed_dhcp_parse: Counter,
68}
69
70impl MessagingRelatedCounters {
71    fn record(&self, inspector: &mut impl Inspector) {
72        let Self {
73            send_message,
74            recv_message,
75            recv_message_fatal_socket_error,
76            recv_message_non_fatal_socket_error,
77            recv_time_out,
78            recv_wrong_xid,
79            recv_wrong_chaddr,
80            recv_failed_dhcp_parse,
81        } = self;
82        inspector.record_inspectable_value("SendMessage", send_message);
83        inspector.record_inspectable_value("RecvMessage", recv_message);
84        inspector.record_inspectable_value(
85            "RecvMessageFatalSocketError",
86            recv_message_fatal_socket_error,
87        );
88        inspector.record_inspectable_value(
89            "RecvMessageNonFatalSocketError",
90            recv_message_non_fatal_socket_error,
91        );
92        inspector.record_inspectable_value("RecvTimeOut", recv_time_out);
93        inspector.record_inspectable_value("RecvWrongXid", recv_wrong_xid);
94        inspector.record_inspectable_value("RecvWrongChaddr", recv_wrong_chaddr);
95        inspector.record_inspectable_value("RecvFailedDhcpParse", recv_failed_dhcp_parse);
96    }
97}
98
99/// Counters for the Init state.
100#[derive(Debug, Default)]
101pub(crate) struct InitCounters {
102    /// The number of times the state was entered.
103    pub(crate) entered: Counter,
104}
105
106impl InitCounters {
107    fn record(&self, inspector: &mut impl Inspector) {
108        let Self { entered } = self;
109        inspector.record_inspectable_value("Entered", entered);
110    }
111}
112
113/// Counters for the Selecting state.
114#[derive(Debug, Default)]
115pub(crate) struct SelectingCounters {
116    /// The number of times the state was entered.
117    pub(crate) entered: Counter,
118    /// Counters relating to sending and receiving messages.
119    pub(crate) messaging: MessagingRelatedCounters,
120    /// Counters for each error that could cause the client to reject a message
121    /// while receiving in the Selecting state.
122    pub(crate) recv_error: SelectingIncomingMessageErrorCounters,
123}
124
125impl SelectingCounters {
126    fn record(&self, inspector: &mut impl Inspector) {
127        let Self { entered, messaging, recv_error } = self;
128        inspector.record_inspectable_value("Entered", entered);
129        messaging.record(inspector);
130        recv_error.record(inspector);
131    }
132}
133
134/// Counters for the Requesting state.
135#[derive(Debug, Default)]
136pub(crate) struct RequestingCounters {
137    /// The number of times the state was entered.
138    pub(crate) entered: Counter,
139    /// Counters relating to sending and receiving messages.
140    pub(crate) messaging: MessagingRelatedCounters,
141    /// Counters for each error that could cause a client to reject a message
142    /// while receiving in the Requesting state.
143    pub(crate) recv_error: IncomingResponseToRequestErrorCounters,
144    /// Counter for each time the client received a NAK message while in the
145    /// Requesting state.
146    pub(crate) recv_nak: Counter,
147}
148
149impl RequestingCounters {
150    fn record(&self, inspector: &mut impl Inspector) {
151        let Self { entered, messaging, recv_error, recv_nak } = self;
152        inspector.record_inspectable_value("Entered", entered);
153        messaging.record(inspector);
154        recv_error.record(inspector);
155        inspector.record_inspectable_value("RecvNak", recv_nak);
156    }
157}
158
159/// Counters for the Bound state.
160#[derive(Debug, Default)]
161pub(crate) struct BoundCounters {
162    /// The number of times the state was entered.
163    pub(crate) entered: Counter,
164}
165
166impl BoundCounters {
167    fn record(&self, inspector: &mut impl Inspector) {
168        let Self { entered } = self;
169        inspector.record_inspectable_value("Entered", entered);
170    }
171}
172
173/// Counters for the Renewing state.
174#[derive(Debug, Default)]
175pub(crate) struct RenewingCounters {
176    /// The number of times the state was entered.
177    pub(crate) entered: Counter,
178    /// Counters relating to sending and receiving messages.
179    pub(crate) messaging: MessagingRelatedCounters,
180    /// Counters for each error that could cause a client to reject a message
181    /// while receiving in the Requesting state.
182    pub(crate) recv_error: IncomingResponseToRequestErrorCounters,
183    /// Counter for each time the client received a NAK message while in the
184    /// Renewing state.
185    pub(crate) recv_nak: Counter,
186}
187
188impl RenewingCounters {
189    fn record(&self, inspector: &mut impl Inspector) {
190        let Self { entered, messaging, recv_error, recv_nak } = self;
191        inspector.record_inspectable_value("Entered", entered);
192        messaging.record(inspector);
193        recv_error.record(inspector);
194        inspector.record_inspectable_value("RecvNak", recv_nak);
195    }
196}
197
198/// Counters for the Rebinding state.
199#[derive(Debug, Default)]
200pub(crate) struct RebindingCounters {
201    /// The number of times the state was entered.
202    pub(crate) entered: Counter,
203    /// Counters relating to sending and receiving messages.
204    pub(crate) messaging: MessagingRelatedCounters,
205    /// Counters for each error that could cause a client to reject a message
206    /// while receiving in the Rebinding state.
207    pub(crate) recv_error: IncomingResponseToRequestErrorCounters,
208    /// Counter for each time the client received a NAK message while in the
209    /// Rebinding state.
210    pub(crate) recv_nak: Counter,
211}
212
213impl RebindingCounters {
214    fn record(&self, inspector: &mut impl Inspector) {
215        let Self { entered, messaging, recv_error, recv_nak } = self;
216        inspector.record_inspectable_value("Entered", entered);
217        messaging.record(inspector);
218        recv_error.record(inspector);
219        inspector.record_inspectable_value("RecvNak", recv_nak);
220    }
221}
222
223/// Counters for the WaitingToRestart state.
224#[derive(Debug, Default)]
225pub(crate) struct WaitingToRestartCounters {
226    /// The number of times the state was entered.
227    pub(crate) entered: Counter,
228}
229
230impl WaitingToRestartCounters {
231    fn record(&self, inspector: &mut impl Inspector) {
232        let Self { entered } = self;
233        inspector.record_inspectable_value("Entered", entered);
234    }
235}
236
237/// Debugging counters for the core state machine.
238#[derive(Default, Debug)]
239pub struct Counters {
240    pub(crate) init: InitCounters,
241    pub(crate) selecting: SelectingCounters,
242    pub(crate) requesting: RequestingCounters,
243    pub(crate) bound: BoundCounters,
244    pub(crate) renewing: RenewingCounters,
245    pub(crate) rebinding: RebindingCounters,
246    pub(crate) waiting_to_restart: WaitingToRestartCounters,
247}
248
249impl Counters {
250    /// Records the counters in the given [`Inspector`].
251    pub fn record(&self, inspector: &mut impl Inspector) {
252        let Self { init, selecting, requesting, bound, renewing, rebinding, waiting_to_restart } =
253            self;
254        inspector.record_child("Init", |inspector| {
255            init.record(inspector);
256        });
257        inspector.record_child("Selecting", |inspector| {
258            selecting.record(inspector);
259        });
260        inspector.record_child("Requesting", |inspector| {
261            requesting.record(inspector);
262        });
263        inspector.record_child("Bound", |inspector| {
264            bound.record(inspector);
265        });
266        inspector.record_child("Renewing", |inspector| {
267            renewing.record(inspector);
268        });
269        inspector.record_child("Rebinding", |inspector| {
270            rebinding.record(inspector);
271        });
272        inspector.record_child("WaitingToRestart", |inspector| {
273            waiting_to_restart.record(inspector);
274        });
275    }
276}
dhcp_client_core/inspect.rs

dhcp_client_core/
inspect.rs
