Skip to content

Commit bb4fd95

Browse files
Freax13Freax13
authored
Merge pull request #578 from mkroening/inline-map_to
fix(mapper): inline internal `map_to_*` functions
2 parents f054b0c + b66e100 commit bb4fd95

2 files changed

Lines changed: 116 additions & 212 deletions

File tree

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

Lines changed: 45 additions & 93 deletions
Original file line numberDiff line numberDiff line change
@@ -49,10 +49,11 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
4949
pub fn page_table_frame_mapping(&self) -> &P {
5050
&self.page_table_walker.page_table_frame_mapping
5151
}
52+
}
5253

53-
/// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
54-
/// https://github.com/rust-lang/rfcs/pull/2585.
55-
fn map_to_1gib<A>(
54+
impl<P: PageTableFrameMapping> Mapper<Size1GiB> for MappedPageTable<'_, P> {
55+
#[inline]
56+
unsafe fn map_to_with_table_flags<A>(
5657
&mut self,
5758
page: Page<Size1GiB>,
5859
frame: PhysFrame<Size1GiB>,
@@ -78,94 +79,6 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
7879
Ok(MapperFlush::new(page))
7980
}
8081

81-
/// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
82-
/// https://github.com/rust-lang/rfcs/pull/2585.
83-
fn map_to_2mib<A>(
84-
&mut self,
85-
page: Page<Size2MiB>,
86-
frame: PhysFrame<Size2MiB>,
87-
flags: PageTableFlags,
88-
parent_table_flags: PageTableFlags,
89-
allocator: &mut A,
90-
) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
91-
where
92-
A: FrameAllocator<Size4KiB> + ?Sized,
93-
{
94-
let p4 = &mut self.level_4_table;
95-
let p3 = self.page_table_walker.create_next_table(
96-
&mut p4[page.p4_index()],
97-
parent_table_flags,
98-
allocator,
99-
)?;
100-
let p2 = self.page_table_walker.create_next_table(
101-
&mut p3[page.p3_index()],
102-
parent_table_flags,
103-
allocator,
104-
)?;
105-
106-
if !p2[page.p2_index()].is_unused() {
107-
return Err(MapToError::PageAlreadyMapped(frame));
108-
}
109-
p2[page.p2_index()].set_addr(frame.start_address(), flags | PageTableFlags::HUGE_PAGE);
110-
111-
Ok(MapperFlush::new(page))
112-
}
113-
114-
/// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
115-
/// https://github.com/rust-lang/rfcs/pull/2585.
116-
fn map_to_4kib<A>(
117-
&mut self,
118-
page: Page<Size4KiB>,
119-
frame: PhysFrame<Size4KiB>,
120-
flags: PageTableFlags,
121-
parent_table_flags: PageTableFlags,
122-
allocator: &mut A,
123-
) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
124-
where
125-
A: FrameAllocator<Size4KiB> + ?Sized,
126-
{
127-
let p4 = &mut self.level_4_table;
128-
let p3 = self.page_table_walker.create_next_table(
129-
&mut p4[page.p4_index()],
130-
parent_table_flags,
131-
allocator,
132-
)?;
133-
let p2 = self.page_table_walker.create_next_table(
134-
&mut p3[page.p3_index()],
135-
parent_table_flags,
136-
allocator,
137-
)?;
138-
let p1 = self.page_table_walker.create_next_table(
139-
&mut p2[page.p2_index()],
140-
parent_table_flags,
141-
allocator,
142-
)?;
143-
144-
if !p1[page.p1_index()].is_unused() {
145-
return Err(MapToError::PageAlreadyMapped(frame));
146-
}
147-
p1[page.p1_index()].set_frame(frame, flags);
148-
149-
Ok(MapperFlush::new(page))
150-
}
151-
}
152-
153-
impl<P: PageTableFrameMapping> Mapper<Size1GiB> for MappedPageTable<'_, P> {
154-
#[inline]
155-
unsafe fn map_to_with_table_flags<A>(
156-
&mut self,
157-
page: Page<Size1GiB>,
158-
frame: PhysFrame<Size1GiB>,
159-
flags: PageTableFlags,
160-
parent_table_flags: PageTableFlags,
161-
allocator: &mut A,
162-
) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
163-
where
164-
A: FrameAllocator<Size4KiB> + ?Sized,
165-
{
166-
self.map_to_1gib(page, frame, flags, parent_table_flags, allocator)
167-
}
168-
16982
fn unmap(
17083
&mut self,
17184
page: Page<Size1GiB>,
@@ -271,7 +184,24 @@ impl<P: PageTableFrameMapping> Mapper<Size2MiB> for MappedPageTable<'_, P> {
271184
where
272185
A: FrameAllocator<Size4KiB> + ?Sized,
273186
{
274-
self.map_to_2mib(page, frame, flags, parent_table_flags, allocator)
187+
let p4 = &mut self.level_4_table;
188+
let p3 = self.page_table_walker.create_next_table(
189+
&mut p4[page.p4_index()],
190+
parent_table_flags,
191+
allocator,
192+
)?;
193+
let p2 = self.page_table_walker.create_next_table(
194+
&mut p3[page.p3_index()],
195+
parent_table_flags,
196+
allocator,
197+
)?;
198+
199+
if !p2[page.p2_index()].is_unused() {
200+
return Err(MapToError::PageAlreadyMapped(frame));
201+
}
202+
p2[page.p2_index()].set_addr(frame.start_address(), flags | PageTableFlags::HUGE_PAGE);
203+
204+
Ok(MapperFlush::new(page))
275205
}
276206

277207
fn unmap(
@@ -399,7 +329,29 @@ impl<P: PageTableFrameMapping> Mapper<Size4KiB> for MappedPageTable<'_, P> {
399329
where
400330
A: FrameAllocator<Size4KiB> + ?Sized,
401331
{
402-
self.map_to_4kib(page, frame, flags, parent_table_flags, allocator)
332+
let p4 = &mut self.level_4_table;
333+
let p3 = self.page_table_walker.create_next_table(
334+
&mut p4[page.p4_index()],
335+
parent_table_flags,
336+
allocator,
337+
)?;
338+
let p2 = self.page_table_walker.create_next_table(
339+
&mut p3[page.p3_index()],
340+
parent_table_flags,
341+
allocator,
342+
)?;
343+
let p1 = self.page_table_walker.create_next_table(
344+
&mut p2[page.p2_index()],
345+
parent_table_flags,
346+
allocator,
347+
)?;
348+
349+
if !p1[page.p1_index()].is_unused() {
350+
return Err(MapToError::PageAlreadyMapped(frame));
351+
}
352+
p1[page.p1_index()].set_frame(frame, flags);
353+
354+
Ok(MapperFlush::new(page))
403355
}
404356

405357
fn unmap(

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

Lines changed: 71 additions & 119 deletions
Original file line numberDiff line numberDiff line change
@@ -166,10 +166,11 @@ impl<'a> RecursivePageTable<'a> {
166166

167167
inner(entry, next_table_page, insert_flags, allocator)
168168
}
169+
}
169170

170-
/// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
171-
/// https://github.com/rust-lang/rfcs/pull/2585.
172-
fn map_to_1gib<A>(
171+
impl Mapper<Size1GiB> for RecursivePageTable<'_> {
172+
#[inline]
173+
unsafe fn map_to_with_table_flags<A>(
173174
&mut self,
174175
page: Page<Size1GiB>,
175176
frame: PhysFrame<Size1GiB>,
@@ -201,120 +202,6 @@ impl<'a> RecursivePageTable<'a> {
201202
Ok(MapperFlush::new(page))
202203
}
203204

204-
/// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
205-
/// https://github.com/rust-lang/rfcs/pull/2585.
206-
fn map_to_2mib<A>(
207-
&mut self,
208-
page: Page<Size2MiB>,
209-
frame: PhysFrame<Size2MiB>,
210-
flags: PageTableFlags,
211-
parent_table_flags: PageTableFlags,
212-
allocator: &mut A,
213-
) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
214-
where
215-
A: FrameAllocator<Size4KiB> + ?Sized,
216-
{
217-
use crate::structures::paging::PageTableFlags as Flags;
218-
let p4 = &mut self.p4;
219-
220-
let p3_page = p3_page(page, self.recursive_index);
221-
let p3 = unsafe {
222-
Self::create_next_table(
223-
&mut p4[page.p4_index()],
224-
p3_page,
225-
parent_table_flags,
226-
allocator,
227-
)?
228-
};
229-
230-
let p2_page = p2_page(page, self.recursive_index);
231-
let p2 = unsafe {
232-
Self::create_next_table(
233-
&mut p3[page.p3_index()],
234-
p2_page,
235-
parent_table_flags,
236-
allocator,
237-
)?
238-
};
239-
240-
if !p2[page.p2_index()].is_unused() {
241-
return Err(MapToError::PageAlreadyMapped(frame));
242-
}
243-
p2[page.p2_index()].set_addr(frame.start_address(), flags | Flags::HUGE_PAGE);
244-
245-
Ok(MapperFlush::new(page))
246-
}
247-
248-
/// Helper function for implementing Mapper. Safe to limit the scope of unsafe, see
249-
/// https://github.com/rust-lang/rfcs/pull/2585.
250-
fn map_to_4kib<A>(
251-
&mut self,
252-
page: Page<Size4KiB>,
253-
frame: PhysFrame<Size4KiB>,
254-
flags: PageTableFlags,
255-
parent_table_flags: PageTableFlags,
256-
allocator: &mut A,
257-
) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
258-
where
259-
A: FrameAllocator<Size4KiB> + ?Sized,
260-
{
261-
let p4 = &mut self.p4;
262-
263-
let p3_page = p3_page(page, self.recursive_index);
264-
let p3 = unsafe {
265-
Self::create_next_table(
266-
&mut p4[page.p4_index()],
267-
p3_page,
268-
parent_table_flags,
269-
allocator,
270-
)?
271-
};
272-
273-
let p2_page = p2_page(page, self.recursive_index);
274-
let p2 = unsafe {
275-
Self::create_next_table(
276-
&mut p3[page.p3_index()],
277-
p2_page,
278-
parent_table_flags,
279-
allocator,
280-
)?
281-
};
282-
283-
let p1_page = p1_page(page, self.recursive_index);
284-
let p1 = unsafe {
285-
Self::create_next_table(
286-
&mut p2[page.p2_index()],
287-
p1_page,
288-
parent_table_flags,
289-
allocator,
290-
)?
291-
};
292-
293-
if !p1[page.p1_index()].is_unused() {
294-
return Err(MapToError::PageAlreadyMapped(frame));
295-
}
296-
p1[page.p1_index()].set_frame(frame, flags);
297-
298-
Ok(MapperFlush::new(page))
299-
}
300-
}
301-
302-
impl Mapper<Size1GiB> for RecursivePageTable<'_> {
303-
#[inline]
304-
unsafe fn map_to_with_table_flags<A>(
305-
&mut self,
306-
page: Page<Size1GiB>,
307-
frame: PhysFrame<Size1GiB>,
308-
flags: PageTableFlags,
309-
parent_table_flags: PageTableFlags,
310-
allocator: &mut A,
311-
) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
312-
where
313-
A: FrameAllocator<Size4KiB> + ?Sized,
314-
{
315-
self.map_to_1gib(page, frame, flags, parent_table_flags, allocator)
316-
}
317-
318205
fn unmap(
319206
&mut self,
320207
page: Page<Size1GiB>,
@@ -432,7 +319,35 @@ impl Mapper<Size2MiB> for RecursivePageTable<'_> {
432319
where
433320
A: FrameAllocator<Size4KiB> + ?Sized,
434321
{
435-
self.map_to_2mib(page, frame, flags, parent_table_flags, allocator)
322+
use crate::structures::paging::PageTableFlags as Flags;
323+
let p4 = &mut self.p4;
324+
325+
let p3_page = p3_page(page, self.recursive_index);
326+
let p3 = unsafe {
327+
Self::create_next_table(
328+
&mut p4[page.p4_index()],
329+
p3_page,
330+
parent_table_flags,
331+
allocator,
332+
)?
333+
};
334+
335+
let p2_page = p2_page(page, self.recursive_index);
336+
let p2 = unsafe {
337+
Self::create_next_table(
338+
&mut p3[page.p3_index()],
339+
p2_page,
340+
parent_table_flags,
341+
allocator,
342+
)?
343+
};
344+
345+
if !p2[page.p2_index()].is_unused() {
346+
return Err(MapToError::PageAlreadyMapped(frame));
347+
}
348+
p2[page.p2_index()].set_addr(frame.start_address(), flags | Flags::HUGE_PAGE);
349+
350+
Ok(MapperFlush::new(page))
436351
}
437352

438353
fn unmap(
@@ -587,7 +502,44 @@ impl Mapper<Size4KiB> for RecursivePageTable<'_> {
587502
where
588503
A: FrameAllocator<Size4KiB> + ?Sized,
589504
{
590-
self.map_to_4kib(page, frame, flags, parent_table_flags, allocator)
505+
let p4 = &mut self.p4;
506+
507+
let p3_page = p3_page(page, self.recursive_index);
508+
let p3 = unsafe {
509+
Self::create_next_table(
510+
&mut p4[page.p4_index()],
511+
p3_page,
512+
parent_table_flags,
513+
allocator,
514+
)?
515+
};
516+
517+
let p2_page = p2_page(page, self.recursive_index);
518+
let p2 = unsafe {
519+
Self::create_next_table(
520+
&mut p3[page.p3_index()],
521+
p2_page,
522+
parent_table_flags,
523+
allocator,
524+
)?
525+
};
526+
527+
let p1_page = p1_page(page, self.recursive_index);
528+
let p1 = unsafe {
529+
Self::create_next_table(
530+
&mut p2[page.p2_index()],
531+
p1_page,
532+
parent_table_flags,
533+
allocator,
534+
)?
535+
};
536+
537+
if !p1[page.p1_index()].is_unused() {
538+
return Err(MapToError::PageAlreadyMapped(frame));
539+
}
540+
p1[page.p1_index()].set_frame(frame, flags);
541+
542+
Ok(MapperFlush::new(page))
591543
}
592544

593545
fn unmap(

0 commit comments

Comments
 (0)