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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
#[allow(unused_imports)]
use segmentation::{SegmentSelector};
use segmentation::{DescriptorBuilder, DescriptorType, GateDescriptorBuilder, TaskGateDescriptorBuilder, SegmentDescriptorBuilder, LdtDescriptorBuilder, BuildDescriptor, SystemDescriptorTypes32, CodeSegmentType, DataSegmentType};
use ::Ring;
/// Entry for IDT, GDT or LDT. Provides size and location of a segment.
///
/// See Intel 3a, Section 3.4.5 "Segment Descriptors", and Section 3.5.2
#[derive(Copy, Clone, Debug, Default)]
#[repr(C, packed)]
pub struct Descriptor32 {
pub lower: u32,
pub upper: u32,
}
impl Descriptor32 {
pub(crate) fn apply_builder_settings(&mut self, builder: &DescriptorBuilder) {
builder.dpl.map(|ring| self.set_dpl(ring));
builder.base_limit.map(|(base, limit)| self.set_base_limit(base as u32, limit as u32));
builder.selector_offset.map(|(selector, offset)| self.set_selector_offset(selector, offset as u32));
if builder.present {
self.set_p();
}
if builder.avl {
self.set_avl();
}
if builder.db {
self.set_db();
}
if builder.limit_granularity_4k {
self.set_g();
}
}
/// Create a new segment, TSS or LDT descriptor
/// by setting the three base and two limit fields.
pub fn set_base_limit(&mut self, base: u32, limit: u32) {
// Clear the base and limit fields in Descriptor
self.lower = 0;
self.upper = self.upper & 0x00F0FF00;
// Set the new base
self.lower |= base << 16;
self.upper |= (base >> 16) & 0xff;
self.upper |= (base >> 24) << 24;
// Set the new limit
self.lower |= limit & 0xffff;
let limit_last_four_bits = (limit >> 16) & 0x0f;
self.upper |= limit_last_four_bits << 16;
}
/// Creates a new descriptor with selector and offset (for IDT Gate descriptors,
/// e.g. Trap, Interrupts and Task gates)
pub fn set_selector_offset(&mut self, selector: SegmentSelector, offset: u32) {
// Clear the selector and offset
self.lower = 0;
self.upper = self.upper & 0x0000ffff;
// Set selector
self.lower |= (selector.bits() as u32) << 16;
// Set offset
self.lower |= offset & 0x0000ffff;
self.upper |= offset & 0xffff0000;
}
/// Set the type of the descriptor (bits 8-11).
/// Indicates the segment or gate type and specifies the kinds of access that can be made to the
/// segment and the direction of growth. The interpretation of this field depends on whether the descriptor
/// type flag specifies an application (code or data) descriptor or a system descriptor.
pub fn set_type(&mut self, typ: u8) {
self.upper &= !(0x0f << 8); // clear
self.upper |= (typ as u32 & 0x0f) << 8;
}
/// Specifies whether the segment descriptor is for a system segment (S flag is clear) or a code or data segment (S flag is set).
pub fn set_s(&mut self) {
self.upper |= bit!(12);
}
/// Specifies the privilege level of the segment. The DPL is used to control access to the segment.
pub fn set_dpl(&mut self, ring: Ring) {
assert!(ring as u32 <= 0b11);
self.upper &= !(0b11 << 13);
self.upper |= (ring as u32) << 13;
}
/// Set Present bit.
/// Indicates whether the segment is present in memory (set) or not present (clear).
/// If this flag is clear, the processor generates a segment-not-present exception (#NP) when a segment selector
/// that points to the segment descriptor is loaded into a segment register.
pub fn set_p(&mut self) {
self.upper |= bit!(15);
}
/// Set AVL bit. System software can use this bit to store information.
pub fn set_avl(&mut self) {
self.upper |= bit!(20);
}
/// Set L
/// In IA-32e mode, bit 21 of the second doubleword of the segment descriptor indicates whether a
/// code segment contains native 64-bit code. A value of 1 indicates instructions in this code
/// segment are executed in 64-bit mode. A value of 0 indicates the instructions in this code segment
/// are executed in compatibility mode. If L-bit is set, then D-bit must be cleared.
pub fn set_l(&mut self) {
self.upper |= bit!(21);
}
/// Set D/B.
/// Performs different functions depending on whether the segment descriptor is an executable code segment,
/// an expand-down data segment, or a stack segment.
pub fn set_db(&mut self) {
self.upper |= bit!(22);
}
/// Set G bit
/// Determines the scaling of the segment limit field.
/// When the granularity flag is clear, the segment limit is interpreted in byte units;
/// when flag is set, the segment limit is interpreted in 4-KByte units.
pub fn set_g(&mut self) {
self.upper |= bit!(23);
}
}
impl GateDescriptorBuilder<u32> for DescriptorBuilder {
fn tss_descriptor(selector: SegmentSelector, offset: u32, available: bool) -> DescriptorBuilder {
let typ = match available {
true => DescriptorType::System32(SystemDescriptorTypes32::TssAvailable32),
false => DescriptorType::System32(SystemDescriptorTypes32::TssBusy32),
};
DescriptorBuilder::with_selector_offset(selector, offset.into()).set_type(typ)
}
fn call_gate_descriptor(selector: SegmentSelector, offset: u32) -> DescriptorBuilder {
DescriptorBuilder::with_selector_offset(selector, offset.into()).set_type(DescriptorType::System32(SystemDescriptorTypes32::CallGate32))
}
fn interrupt_descriptor(selector: SegmentSelector, offset: u32) -> DescriptorBuilder {
DescriptorBuilder::with_selector_offset(selector, offset.into()).set_type(DescriptorType::System32(SystemDescriptorTypes32::InterruptGate32))
}
fn trap_gate_descriptor(selector: SegmentSelector, offset: u32) -> DescriptorBuilder {
DescriptorBuilder::with_selector_offset(selector, offset.into()).set_type(DescriptorType::System32(SystemDescriptorTypes32::TrapGate32))
}
}
impl TaskGateDescriptorBuilder for DescriptorBuilder {
fn task_gate_descriptor(selector: SegmentSelector) -> DescriptorBuilder {
DescriptorBuilder::with_selector_offset(selector, 0).set_type(DescriptorType::System32(SystemDescriptorTypes32::TaskGate))
}
}
impl SegmentDescriptorBuilder<u32> for DescriptorBuilder {
fn code_descriptor(base: u32, limit: u32, cst: CodeSegmentType) -> DescriptorBuilder {
DescriptorBuilder::with_base_limit(base.into(), limit.into()).set_type(DescriptorType::Code(cst)).db()
}
fn data_descriptor(base: u32, limit: u32, dst: DataSegmentType) -> DescriptorBuilder {
DescriptorBuilder::with_base_limit(base.into(), limit.into()).set_type(DescriptorType::Data(dst)).db()
}
}
impl LdtDescriptorBuilder<u32> for DescriptorBuilder {
fn ldt_descriptor(base: u32, limit: u32) -> DescriptorBuilder {
DescriptorBuilder::with_base_limit(base.into(), limit.into()).set_type(DescriptorType::System32(SystemDescriptorTypes32::LDT))
}
}
impl BuildDescriptor<Descriptor32> for DescriptorBuilder {
fn finish(&self) -> Descriptor32 {
let mut desc: Descriptor32 = Default::default();
desc.apply_builder_settings(self);
let typ = match self.typ {
Some(DescriptorType::System64(_)) => panic!("You shall not use 64-bit types on 32-bit descriptor."),
Some(DescriptorType::System32(typ)) => {
typ as u8
},
Some(DescriptorType::Data(typ)) => {
desc.set_s();
typ as u8
},
Some(DescriptorType::Code(typ)) => {
desc.set_s();
typ as u8
},
None => unreachable!("Type not set, this is a library bug in x86."),
};
desc.set_type(typ);
desc
}
}
/// Reload code segment register.
/// Note this is special since we can not directly move
/// to %cs. Instead we push the new segment selector
/// and return value on the stack and use lretl
/// to reload cs and continue at 1:.
#[cfg(target_arch="x86")]
pub unsafe fn set_cs(sel: SegmentSelector) {
asm!("pushl $0; \
pushl $$1f; \
lretl; \
1:" :: "ri" (sel.bits() as u32) : "memory");
}
|
