vminer-core 0.1.0

Core library for vminer
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::{arch, endian::RuntimeEndian, Endianness, HasVcpus, PhysicalAddress, VirtualAddress};

#[derive(Debug, Clone, Copy)]
pub enum Architecture {
    X86_64(arch::X86_64),
    Aarch64(arch::Aarch64),
}

#[derive(Debug, Clone, Copy)]
pub enum Registers {
    X86_64(arch::x86_64::Registers),
    Aarch64(arch::aarch64::Registers),
}

#[allow(clippy::large_enum_variant)]
#[derive(Debug, Clone, Copy)]
pub enum SpecialRegisters {
    X86_64(arch::x86_64::SpecialRegisters),
    Aarch64(arch::aarch64::SpecialRegisters),
}

#[derive(Debug, Clone, Copy)]
pub enum OtherRegisters {
    X86_64(arch::x86_64::OtherRegisters),
    Aarch64(arch::aarch64::OtherRegisters),
}

macro_rules! dispatch {
    ($val:expr => |$arch:ident| $expr:expr) => {
        match $val {
            Architecture::X86_64($arch) => $expr,
            Architecture::Aarch64($arch) => $expr,
        }
    };
    ($val:expr, $vcpus:ident => |$arch:ident| $expr:expr) => {
        match $val {
            Architecture::X86_64($arch) => {
                let $vcpus = &super::AssumeX86_64($vcpus);
                $expr
            }
            Architecture::Aarch64($arch) => {
                let $vcpus = &super::AssumeAarch64($vcpus);
                $expr
            }
        }
    };
}

impl arch::Architecture for Architecture {
    type Endian = RuntimeEndian;

    type Registers = Registers;
    type SpecialRegisters = SpecialRegisters;
    type OtherRegisters = OtherRegisters;

    #[inline]
    fn into_runtime(self) -> Architecture {
        self
    }

    #[inline]
    fn endianness(&self) -> RuntimeEndian {
        dispatch!(self => |arch|arch.endianness().as_runtime_endian())
    }

    #[inline]
    fn virtual_to_physical<M: crate::Memory + ?Sized>(
        &self,
        memory: &M,
        mmu_addr: PhysicalAddress,
        addr: VirtualAddress,
    ) -> crate::TranslationResult<PhysicalAddress> {
        dispatch!(self => |arch| arch.virtual_to_physical(memory, mmu_addr, addr))
    }

    #[inline]
    fn find_kernel_pgd<M: crate::Memory + ?Sized>(
        &self,
        memory: &M,
        vcpus: &(impl HasVcpus<Arch = Self> + ?Sized),
        use_per_cpu: bool,
        additional: &[VirtualAddress],
    ) -> crate::VmResult<Option<PhysicalAddress>> {
        dispatch!(self, vcpus => |arch| arch.find_kernel_pgd(memory, vcpus, use_per_cpu, additional))
    }

    #[inline]
    fn find_in_kernel_memory_raw<M: crate::Memory + ?Sized>(
        &self,
        memory: &M,
        mmu_addr: PhysicalAddress,
        base_search_addr: VirtualAddress,
        finder: &memchr::memmem::Finder,
        buf: &mut [u8],
    ) -> crate::MemoryAccessResult<Option<VirtualAddress>> {
        dispatch!(self => |arch| arch.find_in_kernel_memory_raw(memory, mmu_addr, base_search_addr, finder, buf))
    }

    #[inline]
    fn find_in_kernel_memory<M: crate::Memory + ?Sized>(
        &self,
        memory: &M,
        mmu_addr: PhysicalAddress,
        needle: &[u8],
    ) -> crate::MemoryAccessResult<Option<VirtualAddress>> {
        dispatch!(self => |arch| arch.find_in_kernel_memory(memory, mmu_addr, needle))
    }

    #[inline]
    fn kernel_base(&self) -> VirtualAddress {
        dispatch!(self => |arch| arch.kernel_base())
    }

    #[inline]
    fn instruction_pointer<Vcpus: HasVcpus<Arch = Self> + ?Sized>(
        &self,
        vcpus: &Vcpus,
        vcpu: crate::VcpuId,
    ) -> crate::VcpuResult<VirtualAddress> {
        dispatch!(self, vcpus => |arch| arch.instruction_pointer(vcpus, vcpu))
    }

    #[inline]
    fn stack_pointer<Vcpus: HasVcpus<Arch = Self> + ?Sized>(
        &self,
        vcpus: &Vcpus,
        vcpu: crate::VcpuId,
    ) -> crate::VcpuResult<VirtualAddress> {
        dispatch!(self, vcpus => |arch| arch.stack_pointer(vcpus, vcpu))
    }

    #[inline]
    fn base_pointer<Vcpus: HasVcpus<Arch = Self> + ?Sized>(
        &self,
        vcpus: &Vcpus,
        vcpu: crate::VcpuId,
    ) -> crate::VcpuResult<Option<VirtualAddress>> {
        dispatch!(self, vcpus => |arch| arch.base_pointer(vcpus, vcpu))
    }

    #[inline]
    fn pgd<Vcpus: HasVcpus<Arch = Self> + ?Sized>(
        &self,
        vcpus: &Vcpus,
        vcpu: crate::VcpuId,
    ) -> crate::VcpuResult<PhysicalAddress> {
        dispatch!(self, vcpus => |arch| arch.pgd(vcpus, vcpu))
    }

    #[inline]
    fn kernel_per_cpu<Vcpus: HasVcpus<Arch = Self> + ?Sized>(
        &self,
        vcpus: &Vcpus,
        vcpu: crate::VcpuId,
    ) -> crate::VcpuResult<Option<VirtualAddress>> {
        dispatch!(self, vcpus => |arch| arch.kernel_per_cpu(vcpus, vcpu))
    }
}