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
|
//! Fields which are common to all segment-section and gate descriptors
use shared::PrivilegeLevel;
use shared::segmentation;
/// System-Segment and Gate-Descriptor Types for IA32e mode. When the `S`
/// (descriptor type) flag in a segment descriptor is clear, the descriptor type
/// is a system descriptor.
///
/// See Intel manual 3a, 3.5 "System Descriptor Types", and Table 3-2,
/// System-Segment and Gate-Descriptor Types".
#[repr(u8)]
pub enum SystemType {
// Reserved = 0
TssAvailable = 1,
/// Only for 16-bit
LocalDescriptorTable = 2,
TssBusy = 3,
CallGate = 4,
/// Only for 16-bit
TaskGate = 5,
InterruptGate = 6,
TrapGate = 7,
}
/// A high-level representation of a descriptor type. One can convert to and
/// from the `Flags` bitfield to encode/decode an actual descriptor.
#[repr(u8)]
pub enum Type {
SystemDescriptor {
/// false/0: 16-bit
/// true/1: native (32- or 64-bit)
size: bool,
ty: SystemType
},
SegmentDescriptor {
ty: segmentation::Type,
accessed: bool
}
}
impl Type {
pub fn pack(self) -> u8 {
match self {
Type::SystemDescriptor { size, ty } =>
(size as u8) << 3 | (ty as u8) | FLAGS_TYPE_SYS.bits,
Type::SegmentDescriptor { ty, accessed } =>
(accessed as u8) | ty.pack() | FLAGS_TYPE_SYS.bits,
}
}
}
bitflags!{
/// Actual encoding of the flags in byte 6 common to all descriptors.
///
/// See Intel manual 3a, figures 3-8, 6-2, and 6-7.
pub flags Flags: u8 {
/// Descriptor is Present.
const FLAGS_PRESENT = 1 << 7,
// Descriptor privilege level
const FLAGS_DPL_RING_0 = 0b00 << 5,
const FLAGS_DPL_RING_1 = 0b01 << 5,
const FLAGS_DPL_RING_2 = 0b10 << 5,
const FLAGS_DPL_RING_3 = 0b11 << 5,
// Is system descriptor
const FLAGS_TYPE_SYS = 0 << 4,
const FLAGS_TYPE_SEG = 1 << 4,
// System-Segment and Gate-Descriptor Types.
// When the S (descriptor type) flag in a segment descriptor is clear,
// the descriptor type is a system descriptor
// All modes (supporting segments)
const TYPE_SYS_LDT = 0b0_0010,
// Protected Mode and older
const FLAGS_TYPE_SYS_16BIT_TSS_AVAILABLE = 0b0_0001,
const FLAGS_TYPE_SYS_16BIT_TSS_BUSY = 0b0_0011,
const FLAGS_TYPE_SYS_16BIT_CALL_GATE = 0b0_0100,
const FLAGS_TYPE_SYS_16BIT_TASK_GATE = 0b0_0101,
const FLAGS_TYPE_SYS_16BIT_INTERRUPT_GATE = 0b0_0110,
const FLAGS_TYPE_SYS_16BIT_TRAP_GATE = 0b0_0111,
// 64-bit in IA-32e Mode (either submode), 32-bit in Protected Mode
const FLAGS_TYPE_SYS_NATIVE_TSS_AVAILABLE = 0b0_1001,
const FLAGS_TYPE_SYS_NATIVE_TSS_BUSY = 0b0_1011,
const FLAGS_TYPE_SYS_NATIVE_CALL_GATE = 0b0_1100,
const FLAGS_TYPE_SYS_NATIVE_INTERRUPT_GATE = 0b0_1110,
const FLAGS_TYPE_SYS_NATIVE_TRAP_GATE = 0b0_1111,
// Code- and Data-Segment Descriptor Types.
// When the S (descriptor type) flag in a segment descriptor is set,
// the descriptor is for either a code or a data segment.
/// Data or code, accessed
const FLAGS_TYPE_SEG_ACCESSED = 0b1_0001,
const FLAGS_TYPE_DATA = 0b1_0000,
const FLAGS_TYPE_CODE = 0b1_1000,
// Data => permissions
const FLAGS_TYPE_SEG_D_WRITE = 0b1_0010,
const FLAGS_TYPE_SEG_D_EXPAND_DOWN = 0b1_0100,
// Code => permissions
const FLAGS_TYPE_SEG_C_READ = 0b1_0010,
const FLAGS_TYPE_SEG_C_CONFORMING = 0b1_0100,
/// Data Read-Only
const FLAGS_TYPE_SEG_D_RO = FLAGS_TYPE_DATA.bits,
/// Data Read-Only, accessed
const FLAGS_TYPE_SEG_D_ROA = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Data Read/Write
const FLAGS_TYPE_SEG_D_RW = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_D_WRITE.bits,
/// Data Read/Write, accessed
const FLAGS_TYPE_SEG_D_RWA = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_D_WRITE.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Data Read-Only, expand-down
const FLAGS_TYPE_SEG_D_ROEXD = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_D_EXPAND_DOWN.bits,
/// Data Read-Only, expand-down, accessed
const FLAGS_TYPE_SEG_D_ROEXDA = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_D_EXPAND_DOWN.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Data Read/Write, expand-down
const FLAGS_TYPE_SEG_D_RWEXD = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_D_WRITE.bits
| FLAGS_TYPE_SEG_D_EXPAND_DOWN.bits,
/// Data Read/Write, expand-down, accessed
const FLAGS_TYPE_SEG_D_RWEXDA = FLAGS_TYPE_DATA.bits
| FLAGS_TYPE_SEG_D_WRITE.bits
| FLAGS_TYPE_SEG_D_EXPAND_DOWN.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Code Execute-Only
const FLAGS_TYPE_SEG_C_EO = FLAGS_TYPE_CODE.bits,
/// Code Execute-Only, accessed
const FLAGS_TYPE_SEG_C_EOA = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Code Execute/Read
const FLAGS_TYPE_SEG_C_ER = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_C_READ.bits,
/// Code Execute/Read, accessed
const FLAGS_TYPE_SEG_C_ERA = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_C_READ.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Code Execute-Only, conforming
const FLAGS_TYPE_SEG_C_EOC = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_C_CONFORMING.bits,
/// Code Execute-Only, conforming, accessed
const FLAGS_TYPE_SEG_C_EOCA = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_C_CONFORMING.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
/// Code Execute/Read, conforming
const FLAGS_TYPE_SEG_C_ERC = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_C_READ.bits
| FLAGS_TYPE_SEG_C_CONFORMING.bits,
/// Code Execute/Read, conforming, accessed
const FLAGS_TYPE_SEG_C_ERCA = FLAGS_TYPE_CODE.bits
| FLAGS_TYPE_SEG_C_READ.bits
| FLAGS_TYPE_SEG_C_CONFORMING.bits
| FLAGS_TYPE_SEG_ACCESSED.bits,
}
}
impl Flags {
pub const BLANK: Flags = Flags { bits: 0 };
pub const fn from_priv(dpl: PrivilegeLevel) -> Flags {
Flags { bits: (dpl as u8) << 5 }
}
pub fn from_type(ty: Type) -> Flags {
Flags { bits: ty.pack() }
}
pub const fn const_or(self, other: Self) -> Flags {
Flags { bits: self.bits | other.bits }
}
pub const fn cond(self, cond: bool) -> Flags {
Flags { bits: (-(cond as i8) as u8) & self.bits }
}
pub const fn const_mux(self, other: Self, cond: bool) -> Flags {
self.cond(cond).const_or(other.cond(!cond))
}
}
|
