hstrace 0.0.5

Syscall tracing from command line and as a library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use crossbeam_channel::Receiver;
use num_traits::FromPrimitive;

use crate::syscall::Ident;
use crate::trace_grouper;
use crate::TraceOutput;

pub struct HTraceIterator {
    matchers: Vec<trace_grouper::Match>,
    receiver: Receiver<TraceOutput>,
}

impl HTraceIterator {
    pub fn new(receiver: Receiver<TraceOutput>) -> Self {
        let matchers = trace_grouper::get_matchers();

        HTraceIterator { matchers, receiver }
    }
}

impl Iterator for HTraceIterator {
    type Item = trace_grouper::GroupedIdent;

    fn next(&mut self) -> Option<Self::Item> {
        let mut do_return = None;

        loop {
            let next = match self.receiver.recv() {
                Ok(r) => r,
                Err(_e) => return None,
            };

            let call: Ident = FromPrimitive::from_usize(next.nr).unwrap();

            for (matcher_num, matcher) in &mut self.matchers.iter_mut().enumerate() {
                if matcher.match_state > 0 {
                    let item = &mut matcher.items[matcher.match_state - 1];
                    if item.mode == trace_grouper::MatchMode::Multiple {
                        // were in multiple-match mode, check if we find one from there
                        if let Some(_) = item.calls.iter_mut().find(|c| call == c.call) {
                            // found one, break
                            item.match_count += 1;
                            matcher.grouped.as_mut().unwrap().calls.push(next);
                            break;
                        }
                    }
                }

                let items_len = matcher.items.len();
                let mut item = &mut matcher.items[matcher.match_state];
                // println!("\tstate: {} -> find from {:?}!", matcher.match_state, item);

                if let Some(found_item_call) = item.calls.iter().find(|c| call == c.call) {
                    matcher.match_state += 1;
                    item.match_count += 1;

                    if items_len == matcher.match_state {
                        // println!("\t\tReached last one!");
                        matcher.grouped.as_mut().unwrap().calls.push(next);
                        do_return = Some(matcher_num);
                        break;
                    } else {
                        // println!("\t\tincrement state");
                        if let Some(_store_arg) = &found_item_call.store_to {
                            // FIXME check inp len?
                            /*
                            matcher
                                .store
                                .insert(store_arg.to_hashmap, next.inp[store_arg.from_arg].clone());
                                 */ // FIXME doesn't work
                        }

                        matcher.grouped.as_mut().unwrap().calls.push(next);
                        break;
                    }
                } else {
                    // no matches, send just a single one
                    return Some(trace_grouper::GroupedIdent::from_call(next));
                }
            }

            if let Some(matcher_num) = do_return {
                let to_return = Some(self.matchers[matcher_num].grouped.take().unwrap());
                self.matchers[matcher_num].grouped = Some(trace_grouper::GroupedIdent::new());
                self.matchers[matcher_num].match_state = 0;

                return to_return;
            }
        }
    }
}