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
|
//! Functions and data-structures for working with descriptor tables.
use crate::segmentation::SegmentSelector;
use core::fmt;
use core::mem::size_of;
/// A struct describing a pointer to a descriptor table (GDT / IDT).
/// This is in a format suitable for giving to 'lgdt' or 'lidt'.
#[repr(C, packed)]
pub struct DescriptorTablePointer<Entry> {
/// Size of the DT.
pub limit: u16,
/// Pointer to the memory region containing the DT.
pub base: *const Entry,
}
impl<T> Default for DescriptorTablePointer<T> {
fn default() -> DescriptorTablePointer<T> {
DescriptorTablePointer {
limit: 0,
base: core::ptr::null(),
}
}
}
impl<T> DescriptorTablePointer<T> {
pub fn new(tbl: &T) -> Self {
// GDT, LDT, and IDT all expect the limit to be set to "one less".
// See Intel 3a, Section 3.5.1 "Segment Descriptor Tables" and
// Section 6.10 "Interrupt Descriptor Table (IDT)".
let len = size_of::<T>() - 1;
assert!(len < 0x10000);
DescriptorTablePointer {
base: tbl as *const T,
limit: len as u16,
}
}
pub fn new_from_slice(slice: &[T]) -> Self {
// GDT, LDT, and IDT all expect the limit to be set to "one less".
// See Intel 3a, Section 3.5.1 "Segment Descriptor Tables" and
// Section 6.10 "Interrupt Descriptor Table (IDT)".
let len = slice.len() * size_of::<T>() - 1;
assert!(len < 0x10000);
DescriptorTablePointer {
base: slice.as_ptr(),
limit: len as u16,
}
}
}
impl<T> fmt::Debug for DescriptorTablePointer<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
unsafe { write!(f, "DescriptorTablePointer ({} {:?})", self.limit, self.base) }
}
}
/// Load the GDTR register with the specified base and limit.
pub unsafe fn lgdt<T>(gdt: &DescriptorTablePointer<T>) {
asm!("lgdt ($0)" :: "r" (gdt) : "memory");
}
/// Retrieve base and limit from the GDTR register.
pub unsafe fn sgdt<T>(idt: &mut DescriptorTablePointer<T>) {
asm!("sgdt ($0)" : "=r" (idt as *mut DescriptorTablePointer<T>) :: "memory");
}
/// Loads the segment selector into the selector field of the local
/// descriptor table register (LDTR).
///
/// After the segment selector is loaded in the LDTR,
/// the processor uses the segment selector to locate
/// the segment descriptor for the LDT in the global
/// descriptor table (GDT).
pub unsafe fn load_ldtr(selector: SegmentSelector) {
asm!("lldt $0" :: "r" (selector.bits()) : "memory");
}
/// Returns the segment selector from the local descriptor table register (LDTR).
///
/// The returned segment selector points to the segment descriptor
/// (located in the GDT) for the current LDT.
pub unsafe fn ldtr() -> SegmentSelector {
let selector: u16;
asm!("sldt $0" : "=r"(selector));
SegmentSelector::from_raw(selector)
}
/// Load the IDTR register with the specified base and limit.
pub unsafe fn lidt<T>(idt: &DescriptorTablePointer<T>) {
asm!("lidt ($0)" :: "r" (idt) : "memory");
}
/// Retrieve base and limit from the IDTR register.
pub unsafe fn sidt<T>(idt: &mut DescriptorTablePointer<T>) {
asm!("sidt ($0)" : "=r" (idt as *mut DescriptorTablePointer<T>) :: "memory");
}
|
