Skip to content

Commit ce0b6fc

Browse files
mkroeningmkroening
committed
feat(mapper): make OffsetPageTable a type alias
1 parent e9a9ea0 commit ce0b6fc

1 file changed

Lines changed: 8 additions & 272 deletions

File tree

‎src/structures/paging/mapper/offset_page_table.rs‎

Lines changed: 8 additions & 272 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,10 @@
11
#![cfg(target_pointer_width = "64")]
22

3-
use crate::structures::paging::{mapper::*, page_table::PageTable};
3+
use crate::structures::paging::{mapper::*, PageTable};
44

55
/// A Mapper implementation that requires that the complete physical memory is mapped at some
66
/// offset in the virtual address space.
7-
#[derive(Debug)]
8-
pub struct OffsetPageTable<'a> {
9-
inner: MappedPageTable<'a, PhysOffset>,
10-
}
7+
pub type OffsetPageTable<'a> = MappedPageTable<'a, PhysOffset>;
118

129
impl<'a> OffsetPageTable<'a> {
1310
/// Creates a new `OffsetPageTable` that uses the given offset for converting virtual
@@ -26,26 +23,17 @@ impl<'a> OffsetPageTable<'a> {
2623
/// of a valid page table hierarchy. Otherwise this function might break memory safety, e.g.
2724
/// by writing to an illegal memory location.
2825
#[inline]
29-
pub unsafe fn new(level_4_table: &'a mut PageTable, phys_offset: VirtAddr) -> Self {
26+
pub unsafe fn from_phys_offset(
27+
level_4_table: &'a mut PageTable,
28+
phys_offset: VirtAddr,
29+
) -> Self {
3030
let phys_offset = unsafe { PhysOffset::new(phys_offset) };
31-
Self {
32-
inner: unsafe { MappedPageTable::new(level_4_table, phys_offset) },
33-
}
34-
}
35-
36-
/// Returns an immutable reference to the wrapped level 4 `PageTable` instance.
37-
pub fn level_4_table(&self) -> &PageTable {
38-
self.inner.level_4_table()
39-
}
40-
41-
/// Returns a mutable reference to the wrapped level 4 `PageTable` instance.
42-
pub fn level_4_table_mut(&mut self) -> &mut PageTable {
43-
self.inner.level_4_table_mut()
31+
unsafe { MappedPageTable::new(level_4_table, phys_offset) }
4432
}
4533

4634
/// Returns the offset used for converting virtual to physical addresses.
4735
pub fn phys_offset(&self) -> VirtAddr {
48-
self.inner.page_table_frame_mapping().phys_offset()
36+
self.page_table_frame_mapping().phys_offset()
4937
}
5038
}
5139

@@ -88,255 +76,3 @@ unsafe impl PageTableFrameMapping for PhysOffset {
8876
virt.as_mut_ptr()
8977
}
9078
}
91-
92-
// delegate all trait implementations to inner
93-
94-
impl Mapper<Size1GiB> for OffsetPageTable<'_> {
95-
#[inline]
96-
unsafe fn map_to_with_table_flags<A>(
97-
&mut self,
98-
page: Page<Size1GiB>,
99-
frame: PhysFrame<Size1GiB>,
100-
flags: PageTableFlags,
101-
parent_table_flags: PageTableFlags,
102-
allocator: &mut A,
103-
) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
104-
where
105-
A: FrameAllocator<Size4KiB> + ?Sized,
106-
{
107-
unsafe {
108-
self.inner
109-
.map_to_with_table_flags(page, frame, flags, parent_table_flags, allocator)
110-
}
111-
}
112-
113-
#[inline]
114-
fn unmap(
115-
&mut self,
116-
page: Page<Size1GiB>,
117-
) -> Result<(PhysFrame<Size1GiB>, PageTableFlags, MapperFlush<Size1GiB>), UnmapError> {
118-
self.inner.unmap(page)
119-
}
120-
121-
#[inline]
122-
fn clear(&mut self, page: Page<Size1GiB>) -> Result<UnmappedFrame<Size1GiB>, UnmapError> {
123-
self.inner.clear(page)
124-
}
125-
126-
#[inline]
127-
unsafe fn update_flags(
128-
&mut self,
129-
page: Page<Size1GiB>,
130-
flags: PageTableFlags,
131-
) -> Result<MapperFlush<Size1GiB>, FlagUpdateError> {
132-
unsafe { self.inner.update_flags(page, flags) }
133-
}
134-
135-
#[inline]
136-
unsafe fn set_flags_p4_entry(
137-
&mut self,
138-
page: Page<Size1GiB>,
139-
flags: PageTableFlags,
140-
) -> Result<MapperFlushAll, FlagUpdateError> {
141-
unsafe { self.inner.set_flags_p4_entry(page, flags) }
142-
}
143-
144-
#[inline]
145-
unsafe fn set_flags_p3_entry(
146-
&mut self,
147-
page: Page<Size1GiB>,
148-
flags: PageTableFlags,
149-
) -> Result<MapperFlushAll, FlagUpdateError> {
150-
unsafe { self.inner.set_flags_p3_entry(page, flags) }
151-
}
152-
153-
#[inline]
154-
unsafe fn set_flags_p2_entry(
155-
&mut self,
156-
page: Page<Size1GiB>,
157-
flags: PageTableFlags,
158-
) -> Result<MapperFlushAll, FlagUpdateError> {
159-
unsafe { self.inner.set_flags_p2_entry(page, flags) }
160-
}
161-
162-
#[inline]
163-
fn translate_page(&self, page: Page<Size1GiB>) -> Result<PhysFrame<Size1GiB>, TranslateError> {
164-
self.inner.translate_page(page)
165-
}
166-
}
167-
168-
impl Mapper<Size2MiB> for OffsetPageTable<'_> {
169-
#[inline]
170-
unsafe fn map_to_with_table_flags<A>(
171-
&mut self,
172-
page: Page<Size2MiB>,
173-
frame: PhysFrame<Size2MiB>,
174-
flags: PageTableFlags,
175-
parent_table_flags: PageTableFlags,
176-
allocator: &mut A,
177-
) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
178-
where
179-
A: FrameAllocator<Size4KiB> + ?Sized,
180-
{
181-
unsafe {
182-
self.inner
183-
.map_to_with_table_flags(page, frame, flags, parent_table_flags, allocator)
184-
}
185-
}
186-
187-
#[inline]
188-
fn unmap(
189-
&mut self,
190-
page: Page<Size2MiB>,
191-
) -> Result<(PhysFrame<Size2MiB>, PageTableFlags, MapperFlush<Size2MiB>), UnmapError> {
192-
self.inner.unmap(page)
193-
}
194-
195-
#[inline]
196-
fn clear(&mut self, page: Page<Size2MiB>) -> Result<UnmappedFrame<Size2MiB>, UnmapError> {
197-
self.inner.clear(page)
198-
}
199-
200-
#[inline]
201-
unsafe fn update_flags(
202-
&mut self,
203-
page: Page<Size2MiB>,
204-
flags: PageTableFlags,
205-
) -> Result<MapperFlush<Size2MiB>, FlagUpdateError> {
206-
unsafe { self.inner.update_flags(page, flags) }
207-
}
208-
209-
#[inline]
210-
unsafe fn set_flags_p4_entry(
211-
&mut self,
212-
page: Page<Size2MiB>,
213-
flags: PageTableFlags,
214-
) -> Result<MapperFlushAll, FlagUpdateError> {
215-
unsafe { self.inner.set_flags_p4_entry(page, flags) }
216-
}
217-
218-
#[inline]
219-
unsafe fn set_flags_p3_entry(
220-
&mut self,
221-
page: Page<Size2MiB>,
222-
flags: PageTableFlags,
223-
) -> Result<MapperFlushAll, FlagUpdateError> {
224-
unsafe { self.inner.set_flags_p3_entry(page, flags) }
225-
}
226-
227-
#[inline]
228-
unsafe fn set_flags_p2_entry(
229-
&mut self,
230-
page: Page<Size2MiB>,
231-
flags: PageTableFlags,
232-
) -> Result<MapperFlushAll, FlagUpdateError> {
233-
unsafe { self.inner.set_flags_p2_entry(page, flags) }
234-
}
235-
236-
#[inline]
237-
fn translate_page(&self, page: Page<Size2MiB>) -> Result<PhysFrame<Size2MiB>, TranslateError> {
238-
self.inner.translate_page(page)
239-
}
240-
}
241-
242-
impl Mapper<Size4KiB> for OffsetPageTable<'_> {
243-
#[inline]
244-
unsafe fn map_to_with_table_flags<A>(
245-
&mut self,
246-
page: Page<Size4KiB>,
247-
frame: PhysFrame<Size4KiB>,
248-
flags: PageTableFlags,
249-
parent_table_flags: PageTableFlags,
250-
allocator: &mut A,
251-
) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
252-
where
253-
A: FrameAllocator<Size4KiB> + ?Sized,
254-
{
255-
unsafe {
256-
self.inner
257-
.map_to_with_table_flags(page, frame, flags, parent_table_flags, allocator)
258-
}
259-
}
260-
261-
#[inline]
262-
fn unmap(
263-
&mut self,
264-
page: Page<Size4KiB>,
265-
) -> Result<(PhysFrame<Size4KiB>, PageTableFlags, MapperFlush<Size4KiB>), UnmapError> {
266-
self.inner.unmap(page)
267-
}
268-
269-
#[inline]
270-
fn clear(&mut self, page: Page<Size4KiB>) -> Result<UnmappedFrame<Size4KiB>, UnmapError> {
271-
self.inner.clear(page)
272-
}
273-
274-
#[inline]
275-
unsafe fn update_flags(
276-
&mut self,
277-
page: Page<Size4KiB>,
278-
flags: PageTableFlags,
279-
) -> Result<MapperFlush<Size4KiB>, FlagUpdateError> {
280-
unsafe { self.inner.update_flags(page, flags) }
281-
}
282-
283-
#[inline]
284-
unsafe fn set_flags_p4_entry(
285-
&mut self,
286-
page: Page<Size4KiB>,
287-
flags: PageTableFlags,
288-
) -> Result<MapperFlushAll, FlagUpdateError> {
289-
unsafe { self.inner.set_flags_p4_entry(page, flags) }
290-
}
291-
292-
#[inline]
293-
unsafe fn set_flags_p3_entry(
294-
&mut self,
295-
page: Page<Size4KiB>,
296-
flags: PageTableFlags,
297-
) -> Result<MapperFlushAll, FlagUpdateError> {
298-
unsafe { self.inner.set_flags_p3_entry(page, flags) }
299-
}
300-
301-
#[inline]
302-
unsafe fn set_flags_p2_entry(
303-
&mut self,
304-
page: Page<Size4KiB>,
305-
flags: PageTableFlags,
306-
) -> Result<MapperFlushAll, FlagUpdateError> {
307-
unsafe { self.inner.set_flags_p2_entry(page, flags) }
308-
}
309-
310-
#[inline]
311-
fn translate_page(&self, page: Page<Size4KiB>) -> Result<PhysFrame<Size4KiB>, TranslateError> {
312-
self.inner.translate_page(page)
313-
}
314-
}
315-
316-
impl Translate for OffsetPageTable<'_> {
317-
#[inline]
318-
fn translate(&self, addr: VirtAddr) -> TranslateResult {
319-
self.inner.translate(addr)
320-
}
321-
}
322-
323-
impl CleanUp for OffsetPageTable<'_> {
324-
#[inline]
325-
unsafe fn clean_up<D>(&mut self, frame_deallocator: &mut D)
326-
where
327-
D: FrameDeallocator<Size4KiB>,
328-
{
329-
unsafe { self.inner.clean_up(frame_deallocator) }
330-
}
331-
332-
#[inline]
333-
unsafe fn clean_up_addr_range<D>(
334-
&mut self,
335-
range: PageRangeInclusive,
336-
frame_deallocator: &mut D,
337-
) where
338-
D: FrameDeallocator<Size4KiB>,
339-
{
340-
unsafe { self.inner.clean_up_addr_range(range, frame_deallocator) }
341-
}
342-
}

0 commit comments

Comments
 (0)