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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use anyhow::Result;
use std::collections::HashSet;
use std::fs::File;
use std::io::{self, BufRead};

#[derive(Debug, Default)]
pub struct Kallsyms {
    syms: Vec<(String, u64)>,
    hs: HashSet<String>,
}

impl TryFrom<&str> for Kallsyms {
    type Error = anyhow::Error;
    fn try_from(path: &str) -> Result<Self> {
        let mut ksyms = Kallsyms::new();
        let file = File::open(path)?;
        let lines = io::BufReader::new(file).lines();
        for line in lines {
            if let Ok(l) = line {
                let mut iter = l.trim().split_whitespace();
                if let Some(x) = iter.next() {
                    iter.next();
                    if let Some(y) = iter.next() {
                        ksyms.insert(y.to_string(), u64::from_str_radix(x, 16)?);
                    }
                }
            }
        }
        ksyms.sort();
        log::debug!(
            "Load ksyms done from {:?}, symbols length: {}",
            path,
            ksyms.get_ksyms_num()
        );
        Ok(ksyms)
    }
}

impl Kallsyms {
    pub fn new() -> Self {
        Kallsyms {
            syms: Vec::new(),
            hs: HashSet::default(),
        }
    }

    fn insert(&mut self, sym_name: String, sym_addr: u64) {
        self.syms.push((sym_name.clone(), sym_addr));
        self.hs.insert(sym_name);
    }

    fn get_ksyms_num(&self) -> usize {
        self.syms.len()
    }

    fn sort(&mut self) {
        self.syms.sort_by(|a, b| a.1.cmp(&b.1));
    }

    pub fn has_sym(&self, sym_name: &str) -> bool {
        self.hs.contains(sym_name)
    }

    pub fn addr_to_sym(&self, addr: u64) -> String {
        let mut start = 0;
        let mut end = self.syms.len() - 1;
        let mut mid;
        let mut sym_addr;

        while start < end {
            mid = start + (end - start + 1) / 2;
            sym_addr = self.syms[mid].1;

            if sym_addr <= addr {
                start = mid;
            } else {
                end = mid - 1;
            }
        }

        if start == end && self.syms[start].1 <= addr {
            let mut name = self.syms[start].0.clone();
            name.push_str(&format!("+{}", addr - self.syms[start].1 - 1));
            return name;
        }

        return String::from("Not Found");
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_ksyms_try_from() {
        assert_eq!(Kallsyms::try_from("/proc/kallsyms").is_ok(), true);
        assert_eq!(Kallsyms::try_from("/3124/2123").is_ok(), false);
    }

    #[test]
    fn test_ksyms_has_sym() {
        let ksym = Kallsyms::try_from("/proc/kallsyms").unwrap();
        assert_eq!(ksym.has_sym("schedule"), true);
        assert_eq!(ksym.has_sym("5813478"), false);
    }
}