iptr_decoder/packet_handler/
combined.rs

1//! Handler for combining two sub handlers.
2
3use core::{self as std, num::NonZero}; // workaround for `perfect_derive`
4
5use perfect_derive::perfect_derive;
6use thiserror::Error;
7
8use crate::{DecoderContext, HandlePacket, IpReconstructionPattern};
9
10/// A [`HandlePacket`] instance for combining two sub handlers
11///
12/// Using this struct could leverage the static generic dispatch for
13/// maximum performance when you want to use multiple handlers.
14///
15/// Note that in all packet handle functions, the first handler is executed
16/// before the second handler, and if the first handler returns an error,
17/// the whole function will directly return without executing the second handler.
18pub struct CombinedPacketHandler<H1, H2>
19where
20    H1: HandlePacket,
21    H2: HandlePacket,
22{
23    handler1: H1,
24    handler2: H2,
25}
26
27impl<H1, H2> CombinedPacketHandler<H1, H2>
28where
29    H1: HandlePacket,
30    H2: HandlePacket,
31{
32    /// Create a new [`CombinedPacketHandler`]
33    #[must_use]
34    pub fn new(handler1: H1, handler2: H2) -> Self {
35        Self { handler1, handler2 }
36    }
37
38    /// Consume the handler and get the original two handler
39    pub fn into_inner(self) -> (H1, H2) {
40        (self.handler1, self.handler2)
41    }
42
43    /// Get shared reference to handler1
44    pub fn handler1(&self) -> &H1 {
45        &self.handler1
46    }
47
48    /// Get unique reference to handler1
49    pub fn handler1_mut(&mut self) -> &mut H1 {
50        &mut self.handler1
51    }
52
53    /// Get shared reference to handler2
54    pub fn handler2(&self) -> &H2 {
55        &self.handler2
56    }
57
58    /// Get unique reference to handler2
59    pub fn handler2_mut(&mut self) -> &mut H2 {
60        &mut self.handler2
61    }
62}
63
64/// Error for [`CombinedPacketHandler`]
65#[derive(Error)]
66#[perfect_derive(Debug)]
67pub enum CombinedError<H1, H2>
68where
69    H1: HandlePacket,
70    H2: HandlePacket,
71{
72    /// Error of the first handler
73    #[error(transparent)]
74    H1Error(H1::Error),
75    /// Error of the second handler
76    #[error(transparent)]
77    H2Error(H2::Error),
78}
79
80impl<H1, H2> HandlePacket for CombinedPacketHandler<H1, H2>
81where
82    H1: HandlePacket,
83    H2: HandlePacket,
84    CombinedError<H1, H2>: core::error::Error,
85{
86    type Error = CombinedError<H1, H2>;
87
88    fn at_decode_begin(&mut self) -> Result<(), Self::Error> {
89        self.handler1
90            .at_decode_begin()
91            .map_err(CombinedError::H1Error)?;
92        self.handler2
93            .at_decode_begin()
94            .map_err(CombinedError::H2Error)?;
95        Ok(())
96    }
97
98    fn on_short_tnt_packet(
99        &mut self,
100        context: &DecoderContext,
101        packet_byte: NonZero<u8>,
102        highest_bit: u32,
103    ) -> Result<(), Self::Error> {
104        self.handler1
105            .on_short_tnt_packet(context, packet_byte, highest_bit)
106            .map_err(CombinedError::H1Error)?;
107        self.handler2
108            .on_short_tnt_packet(context, packet_byte, highest_bit)
109            .map_err(CombinedError::H2Error)?;
110
111        Ok(())
112    }
113
114    fn on_long_tnt_packet(
115        &mut self,
116        context: &DecoderContext,
117        packet_bytes: NonZero<u64>,
118        highest_bit: u32,
119    ) -> Result<(), Self::Error> {
120        self.handler1
121            .on_long_tnt_packet(context, packet_bytes, highest_bit)
122            .map_err(CombinedError::H1Error)?;
123        self.handler2
124            .on_long_tnt_packet(context, packet_bytes, highest_bit)
125            .map_err(CombinedError::H2Error)?;
126
127        Ok(())
128    }
129
130    fn on_tip_packet(
131        &mut self,
132        context: &DecoderContext,
133        ip_reconstruction_pattern: IpReconstructionPattern,
134    ) -> Result<(), Self::Error> {
135        self.handler1
136            .on_tip_packet(context, ip_reconstruction_pattern)
137            .map_err(CombinedError::H1Error)?;
138        self.handler2
139            .on_tip_packet(context, ip_reconstruction_pattern)
140            .map_err(CombinedError::H2Error)?;
141
142        Ok(())
143    }
144
145    fn on_tip_pgd_packet(
146        &mut self,
147        context: &DecoderContext,
148        ip_reconstruction_pattern: IpReconstructionPattern,
149    ) -> Result<(), Self::Error> {
150        self.handler1
151            .on_tip_pgd_packet(context, ip_reconstruction_pattern)
152            .map_err(CombinedError::H1Error)?;
153        self.handler2
154            .on_tip_pgd_packet(context, ip_reconstruction_pattern)
155            .map_err(CombinedError::H2Error)?;
156
157        Ok(())
158    }
159
160    fn on_tip_pge_packet(
161        &mut self,
162        context: &DecoderContext,
163        ip_reconstruction_pattern: IpReconstructionPattern,
164    ) -> Result<(), Self::Error> {
165        self.handler1
166            .on_tip_pge_packet(context, ip_reconstruction_pattern)
167            .map_err(CombinedError::H1Error)?;
168        self.handler2
169            .on_tip_pge_packet(context, ip_reconstruction_pattern)
170            .map_err(CombinedError::H2Error)?;
171
172        Ok(())
173    }
174
175    fn on_fup_packet(
176        &mut self,
177        context: &DecoderContext,
178        ip_reconstruction_pattern: IpReconstructionPattern,
179    ) -> Result<(), Self::Error> {
180        self.handler1
181            .on_fup_packet(context, ip_reconstruction_pattern)
182            .map_err(CombinedError::H1Error)?;
183        self.handler2
184            .on_fup_packet(context, ip_reconstruction_pattern)
185            .map_err(CombinedError::H2Error)?;
186
187        Ok(())
188    }
189
190    fn on_pad_packet(&mut self, context: &DecoderContext) -> Result<(), Self::Error> {
191        self.handler1
192            .on_pad_packet(context)
193            .map_err(CombinedError::H1Error)?;
194        self.handler2
195            .on_pad_packet(context)
196            .map_err(CombinedError::H2Error)?;
197
198        Ok(())
199    }
200
201    fn on_cyc_packet(
202        &mut self,
203        context: &DecoderContext,
204        cyc_packet: &[u8],
205    ) -> Result<(), Self::Error> {
206        self.handler1
207            .on_cyc_packet(context, cyc_packet)
208            .map_err(CombinedError::H1Error)?;
209        self.handler2
210            .on_cyc_packet(context, cyc_packet)
211            .map_err(CombinedError::H2Error)?;
212
213        Ok(())
214    }
215
216    fn on_mode_packet(
217        &mut self,
218        context: &DecoderContext,
219        leaf_id: u8,
220        mode: u8,
221    ) -> Result<(), Self::Error> {
222        self.handler1
223            .on_mode_packet(context, leaf_id, mode)
224            .map_err(CombinedError::H1Error)?;
225        self.handler2
226            .on_mode_packet(context, leaf_id, mode)
227            .map_err(CombinedError::H2Error)?;
228
229        Ok(())
230    }
231
232    fn on_mtc_packet(
233        &mut self,
234        context: &DecoderContext,
235        ctc_payload: u8,
236    ) -> Result<(), Self::Error> {
237        self.handler1
238            .on_mtc_packet(context, ctc_payload)
239            .map_err(CombinedError::H1Error)?;
240        self.handler2
241            .on_mtc_packet(context, ctc_payload)
242            .map_err(CombinedError::H2Error)?;
243
244        Ok(())
245    }
246
247    fn on_tsc_packet(
248        &mut self,
249        context: &DecoderContext,
250        tsc_value: u64,
251    ) -> Result<(), Self::Error> {
252        self.handler1
253            .on_tsc_packet(context, tsc_value)
254            .map_err(CombinedError::H1Error)?;
255        self.handler2
256            .on_tsc_packet(context, tsc_value)
257            .map_err(CombinedError::H2Error)?;
258
259        Ok(())
260    }
261
262    fn on_cbr_packet(
263        &mut self,
264        context: &DecoderContext,
265        core_bus_ratio: u8,
266    ) -> Result<(), Self::Error> {
267        self.handler1
268            .on_cbr_packet(context, core_bus_ratio)
269            .map_err(CombinedError::H1Error)?;
270        self.handler2
271            .on_cbr_packet(context, core_bus_ratio)
272            .map_err(CombinedError::H2Error)?;
273
274        Ok(())
275    }
276
277    fn on_tma_packet(
278        &mut self,
279        context: &DecoderContext,
280        ctc: u16,
281        fast_counter: u8,
282        fc8: bool,
283    ) -> Result<(), Self::Error> {
284        self.handler1
285            .on_tma_packet(context, ctc, fast_counter, fc8)
286            .map_err(CombinedError::H1Error)?;
287        self.handler2
288            .on_tma_packet(context, ctc, fast_counter, fc8)
289            .map_err(CombinedError::H2Error)?;
290
291        Ok(())
292    }
293
294    fn on_vmcs_packet(
295        &mut self,
296        context: &DecoderContext,
297        vmcs_pointer: u64,
298    ) -> Result<(), Self::Error> {
299        self.handler1
300            .on_vmcs_packet(context, vmcs_pointer)
301            .map_err(CombinedError::H1Error)?;
302        self.handler2
303            .on_vmcs_packet(context, vmcs_pointer)
304            .map_err(CombinedError::H2Error)?;
305
306        Ok(())
307    }
308
309    fn on_ovf_packet(&mut self, context: &DecoderContext) -> Result<(), Self::Error> {
310        self.handler1
311            .on_ovf_packet(context)
312            .map_err(CombinedError::H1Error)?;
313        self.handler2
314            .on_ovf_packet(context)
315            .map_err(CombinedError::H2Error)?;
316
317        Ok(())
318    }
319
320    fn on_psb_packet(&mut self, context: &DecoderContext) -> Result<(), Self::Error> {
321        self.handler1
322            .on_psb_packet(context)
323            .map_err(CombinedError::H1Error)?;
324        self.handler2
325            .on_psb_packet(context)
326            .map_err(CombinedError::H2Error)?;
327
328        Ok(())
329    }
330
331    fn on_psbend_packet(&mut self, context: &DecoderContext) -> Result<(), Self::Error> {
332        self.handler1
333            .on_psbend_packet(context)
334            .map_err(CombinedError::H1Error)?;
335        self.handler2
336            .on_psbend_packet(context)
337            .map_err(CombinedError::H2Error)?;
338
339        Ok(())
340    }
341
342    fn on_trace_stop_packet(&mut self, context: &DecoderContext) -> Result<(), Self::Error> {
343        self.handler1
344            .on_trace_stop_packet(context)
345            .map_err(CombinedError::H1Error)?;
346        self.handler2
347            .on_trace_stop_packet(context)
348            .map_err(CombinedError::H2Error)?;
349
350        Ok(())
351    }
352
353    fn on_pip_packet(
354        &mut self,
355        context: &DecoderContext,
356        cr3: u64,
357        rsvd_nr: bool,
358    ) -> Result<(), Self::Error> {
359        self.handler1
360            .on_pip_packet(context, cr3, rsvd_nr)
361            .map_err(CombinedError::H1Error)?;
362        self.handler2
363            .on_pip_packet(context, cr3, rsvd_nr)
364            .map_err(CombinedError::H2Error)?;
365
366        Ok(())
367    }
368
369    fn on_mnt_packet(&mut self, context: &DecoderContext, payload: u64) -> Result<(), Self::Error> {
370        self.handler1
371            .on_mnt_packet(context, payload)
372            .map_err(CombinedError::H1Error)?;
373        self.handler2
374            .on_mnt_packet(context, payload)
375            .map_err(CombinedError::H2Error)?;
376
377        Ok(())
378    }
379
380    fn on_ptw_packet(
381        &mut self,
382        context: &DecoderContext,
383        ip_bit: bool,
384        payload: crate::PtwPayload,
385    ) -> Result<(), Self::Error> {
386        self.handler1
387            .on_ptw_packet(context, ip_bit, payload)
388            .map_err(CombinedError::H1Error)?;
389        self.handler2
390            .on_ptw_packet(context, ip_bit, payload)
391            .map_err(CombinedError::H2Error)?;
392
393        Ok(())
394    }
395
396    fn on_exstop_packet(
397        &mut self,
398        context: &DecoderContext,
399        ip_bit: bool,
400    ) -> Result<(), Self::Error> {
401        self.handler1
402            .on_exstop_packet(context, ip_bit)
403            .map_err(CombinedError::H1Error)?;
404        self.handler2
405            .on_exstop_packet(context, ip_bit)
406            .map_err(CombinedError::H2Error)?;
407
408        Ok(())
409    }
410
411    fn on_mwait_packet(
412        &mut self,
413        context: &DecoderContext,
414        mwait_hints: u8,
415        ext: u8,
416    ) -> Result<(), Self::Error> {
417        self.handler1
418            .on_mwait_packet(context, mwait_hints, ext)
419            .map_err(CombinedError::H1Error)?;
420        self.handler2
421            .on_mwait_packet(context, mwait_hints, ext)
422            .map_err(CombinedError::H2Error)?;
423
424        Ok(())
425    }
426
427    fn on_pwre_packet(
428        &mut self,
429        context: &DecoderContext,
430        hw: bool,
431        resolved_thread_c_state: u8,
432        resolved_thread_sub_c_state: u8,
433    ) -> Result<(), Self::Error> {
434        self.handler1
435            .on_pwre_packet(
436                context,
437                hw,
438                resolved_thread_c_state,
439                resolved_thread_sub_c_state,
440            )
441            .map_err(CombinedError::H1Error)?;
442        self.handler2
443            .on_pwre_packet(
444                context,
445                hw,
446                resolved_thread_c_state,
447                resolved_thread_sub_c_state,
448            )
449            .map_err(CombinedError::H2Error)?;
450
451        Ok(())
452    }
453
454    fn on_pwrx_packet(
455        &mut self,
456        context: &DecoderContext,
457        last_core_c_state: u8,
458        deepest_core_c_state: u8,
459        wake_reason: u8,
460    ) -> Result<(), Self::Error> {
461        self.handler1
462            .on_pwrx_packet(
463                context,
464                last_core_c_state,
465                deepest_core_c_state,
466                wake_reason,
467            )
468            .map_err(CombinedError::H1Error)?;
469        self.handler2
470            .on_pwrx_packet(
471                context,
472                last_core_c_state,
473                deepest_core_c_state,
474                wake_reason,
475            )
476            .map_err(CombinedError::H2Error)?;
477
478        Ok(())
479    }
480
481    fn on_evd_packet(
482        &mut self,
483        context: &DecoderContext,
484        r#type: u8,
485        payload: u64,
486    ) -> Result<(), Self::Error> {
487        self.handler1
488            .on_evd_packet(context, r#type, payload)
489            .map_err(CombinedError::H1Error)?;
490        self.handler2
491            .on_evd_packet(context, r#type, payload)
492            .map_err(CombinedError::H2Error)?;
493
494        Ok(())
495    }
496
497    fn on_cfe_packet(
498        &mut self,
499        context: &DecoderContext,
500        ip_bit: bool,
501        r#type: u8,
502        vector: u8,
503    ) -> Result<(), Self::Error> {
504        self.handler1
505            .on_cfe_packet(context, ip_bit, r#type, vector)
506            .map_err(CombinedError::H1Error)?;
507        self.handler2
508            .on_cfe_packet(context, ip_bit, r#type, vector)
509            .map_err(CombinedError::H2Error)?;
510
511        Ok(())
512    }
513}
iptr_decoder/packet_handler/combined.rs

iptr_decoder/packet_handler/
combined.rs
