Skip to content

Commit 2db599a

Browse files
wangrunji0408wangrunji0408
committed
fix deprecated warnings
1 parent f132e61 commit 2db599a

File tree

27 files changed

+110
-110
lines changed

27 files changed

+110
-110
lines changed

‎crate/memory/src/memory_set/handler/byframe.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,26 +6,26 @@ pub struct ByFrame<T: FrameAllocator> {
66
}
77

88
impl<T: FrameAllocator> MemoryHandler for ByFrame<T> {
9-
fn box_clone(&self) -> Box<MemoryHandler> {
9+
fn box_clone(&self) -> Box<dyn MemoryHandler> {
1010
Box::new(self.clone())
1111
}
1212

13-
fn map(&self, pt: &mut PageTable, addr: VirtAddr, attr: &MemoryAttr) {
13+
fn map(&self, pt: &mut dyn PageTable, addr: VirtAddr, attr: &MemoryAttr) {
1414
let target = self.allocator.alloc().expect("failed to allocate frame");
1515
let entry = pt.map(addr, target);
1616
attr.apply(entry);
1717
}
1818

19-
fn unmap(&self, pt: &mut PageTable, addr: VirtAddr) {
19+
fn unmap(&self, pt: &mut dyn PageTable, addr: VirtAddr) {
2020
let target = pt.get_entry(addr).expect("fail to get entry").target();
2121
self.allocator.dealloc(target);
2222
pt.unmap(addr);
2323
}
2424

2525
fn clone_map(
2626
&self,
27-
pt: &mut PageTable,
28-
src_pt: &mut PageTable,
27+
pt: &mut dyn PageTable,
28+
src_pt: &mut dyn PageTable,
2929
addr: VirtAddr,
3030
attr: &MemoryAttr,
3131
) {
@@ -34,7 +34,7 @@ impl<T: FrameAllocator> MemoryHandler for ByFrame<T> {
3434
pt.get_page_slice_mut(addr).copy_from_slice(data);
3535
}
3636

37-
fn handle_page_fault(&self, _pt: &mut PageTable, _addr: VirtAddr) -> bool {
37+
fn handle_page_fault(&self, _pt: &mut dyn PageTable, _addr: VirtAddr) -> bool {
3838
false
3939
}
4040
}

‎crate/memory/src/memory_set/handler/delay.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,17 +6,17 @@ pub struct Delay<T: FrameAllocator> {
66
}
77

88
impl<T: FrameAllocator> MemoryHandler for Delay<T> {
9-
fn box_clone(&self) -> Box<MemoryHandler> {
9+
fn box_clone(&self) -> Box<dyn MemoryHandler> {
1010
Box::new(self.clone())
1111
}
1212

13-
fn map(&self, pt: &mut PageTable, addr: VirtAddr, attr: &MemoryAttr) {
13+
fn map(&self, pt: &mut dyn PageTable, addr: VirtAddr, attr: &MemoryAttr) {
1414
let entry = pt.map(addr, 0);
1515
entry.set_present(false);
1616
attr.apply(entry);
1717
}
1818

19-
fn unmap(&self, pt: &mut PageTable, addr: VirtAddr) {
19+
fn unmap(&self, pt: &mut dyn PageTable, addr: VirtAddr) {
2020
let entry = pt.get_entry(addr).expect("failed to get entry");
2121
if entry.present() {
2222
self.allocator.dealloc(entry.target());
@@ -29,8 +29,8 @@ impl<T: FrameAllocator> MemoryHandler for Delay<T> {
2929

3030
fn clone_map(
3131
&self,
32-
pt: &mut PageTable,
33-
src_pt: &mut PageTable,
32+
pt: &mut dyn PageTable,
33+
src_pt: &mut dyn PageTable,
3434
addr: VirtAddr,
3535
attr: &MemoryAttr,
3636
) {
@@ -48,7 +48,7 @@ impl<T: FrameAllocator> MemoryHandler for Delay<T> {
4848
}
4949
}
5050

51-
fn handle_page_fault(&self, pt: &mut PageTable, addr: VirtAddr) -> bool {
51+
fn handle_page_fault(&self, pt: &mut dyn PageTable, addr: VirtAddr) -> bool {
5252
let entry = pt.get_entry(addr).expect("failed to get entry");
5353
if entry.present() {
5454
// not a delay case

‎crate/memory/src/memory_set/handler/file.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -15,17 +15,17 @@ pub trait Read: Clone + Send + Sync + 'static {
1515
}
1616

1717
impl<F: Read, T: FrameAllocator> MemoryHandler for File<F, T> {
18-
fn box_clone(&self) -> Box<MemoryHandler> {
18+
fn box_clone(&self) -> Box<dyn MemoryHandler> {
1919
Box::new(self.clone())
2020
}
2121

22-
fn map(&self, pt: &mut PageTable, addr: usize, attr: &MemoryAttr) {
22+
fn map(&self, pt: &mut dyn PageTable, addr: usize, attr: &MemoryAttr) {
2323
let entry = pt.map(addr, 0);
2424
entry.set_present(false);
2525
attr.apply(entry);
2626
}
2727

28-
fn unmap(&self, pt: &mut PageTable, addr: usize) {
28+
fn unmap(&self, pt: &mut dyn PageTable, addr: usize) {
2929
let entry = pt.get_entry(addr).expect("failed to get entry");
3030
if entry.present() {
3131
self.allocator.dealloc(entry.target());
@@ -38,8 +38,8 @@ impl<F: Read, T: FrameAllocator> MemoryHandler for File<F, T> {
3838

3939
fn clone_map(
4040
&self,
41-
pt: &mut PageTable,
42-
src_pt: &mut PageTable,
41+
pt: &mut dyn PageTable,
42+
src_pt: &mut dyn PageTable,
4343
addr: usize,
4444
attr: &MemoryAttr,
4545
) {
@@ -57,7 +57,7 @@ impl<F: Read, T: FrameAllocator> MemoryHandler for File<F, T> {
5757
}
5858
}
5959

60-
fn handle_page_fault(&self, pt: &mut PageTable, addr: usize) -> bool {
60+
fn handle_page_fault(&self, pt: &mut dyn PageTable, addr: usize) -> bool {
6161
let addr = addr & !(PAGE_SIZE - 1);
6262
let entry = pt.get_entry(addr).expect("failed to get entry");
6363
if entry.present() {
@@ -74,7 +74,7 @@ impl<F: Read, T: FrameAllocator> MemoryHandler for File<F, T> {
7474
}
7575

7676
impl<F: Read, T: FrameAllocator> File<F, T> {
77-
fn fill_data(&self, pt: &mut PageTable, addr: VirtAddr) {
77+
fn fill_data(&self, pt: &mut dyn PageTable, addr: VirtAddr) {
7878
let data = pt.get_page_slice_mut(addr);
7979
let file_offset = addr + self.file_start - self.mem_start;
8080
let read_size = (self.file_end as isize - file_offset as isize)

‎crate/memory/src/memory_set/handler/linear.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,31 +6,31 @@ pub struct Linear {
66
}
77

88
impl MemoryHandler for Linear {
9-
fn box_clone(&self) -> Box<MemoryHandler> {
9+
fn box_clone(&self) -> Box<dyn MemoryHandler> {
1010
Box::new(self.clone())
1111
}
1212

13-
fn map(&self, pt: &mut PageTable, addr: VirtAddr, attr: &MemoryAttr) {
13+
fn map(&self, pt: &mut dyn PageTable, addr: VirtAddr, attr: &MemoryAttr) {
1414
let target = (addr as isize + self.offset) as PhysAddr;
1515
let entry = pt.map(addr, target);
1616
attr.apply(entry);
1717
}
1818

19-
fn unmap(&self, pt: &mut PageTable, addr: VirtAddr) {
19+
fn unmap(&self, pt: &mut dyn PageTable, addr: VirtAddr) {
2020
pt.unmap(addr);
2121
}
2222

2323
fn clone_map(
2424
&self,
25-
pt: &mut PageTable,
26-
_src_pt: &mut PageTable,
25+
pt: &mut dyn PageTable,
26+
_src_pt: &mut dyn PageTable,
2727
addr: VirtAddr,
2828
attr: &MemoryAttr,
2929
) {
3030
self.map(pt, addr, attr);
3131
}
3232

33-
fn handle_page_fault(&self, _pt: &mut PageTable, _addr: VirtAddr) -> bool {
33+
fn handle_page_fault(&self, _pt: &mut dyn PageTable, _addr: VirtAddr) -> bool {
3434
false
3535
}
3636
}

‎crate/memory/src/memory_set/handler/mod.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2,31 +2,31 @@ use super::*;
22

33
// here may be a interesting part for lab
44
pub trait MemoryHandler: Debug + Send + Sync + 'static {
5-
fn box_clone(&self) -> Box<MemoryHandler>;
5+
fn box_clone(&self) -> Box<dyn MemoryHandler>;
66

77
/// Map `addr` in the page table
88
/// Should set page flags here instead of in `page_fault_handler`
9-
fn map(&self, pt: &mut PageTable, addr: VirtAddr, attr: &MemoryAttr);
9+
fn map(&self, pt: &mut dyn PageTable, addr: VirtAddr, attr: &MemoryAttr);
1010

1111
/// Unmap `addr` in the page table
12-
fn unmap(&self, pt: &mut PageTable, addr: VirtAddr);
12+
fn unmap(&self, pt: &mut dyn PageTable, addr: VirtAddr);
1313

1414
/// Clone map `addr` from page table `src_pt` to `pt`.
1515
fn clone_map(
1616
&self,
17-
pt: &mut PageTable,
18-
src_pt: &mut PageTable,
17+
pt: &mut dyn PageTable,
18+
src_pt: &mut dyn PageTable,
1919
addr: VirtAddr,
2020
attr: &MemoryAttr,
2121
);
2222

2323
/// Handle page fault on `addr`
2424
/// Return true if success, false if error
25-
fn handle_page_fault(&self, pt: &mut PageTable, addr: VirtAddr) -> bool;
25+
fn handle_page_fault(&self, pt: &mut dyn PageTable, addr: VirtAddr) -> bool;
2626
}
2727

28-
impl Clone for Box<MemoryHandler> {
29-
fn clone(&self) -> Box<MemoryHandler> {
28+
impl Clone for Box<dyn MemoryHandler> {
29+
fn clone(&self) -> Box<dyn MemoryHandler> {
3030
self.box_clone()
3131
}
3232
}

‎crate/memory/src/memory_set/mod.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ pub struct MemoryArea {
1818
start_addr: VirtAddr,
1919
end_addr: VirtAddr,
2020
attr: MemoryAttr,
21-
handler: Box<MemoryHandler>,
21+
handler: Box<dyn MemoryHandler>,
2222
name: &'static str,
2323
}
2424

@@ -58,13 +58,13 @@ impl MemoryArea {
5858
!(p1 <= p2 || p0 >= p3)
5959
}
6060
/// Map all pages in the area to page table `pt`
61-
fn map(&self, pt: &mut PageTable) {
61+
fn map(&self, pt: &mut dyn PageTable) {
6262
for page in Page::range_of(self.start_addr, self.end_addr) {
6363
self.handler.map(pt, page.start_address(), &self.attr);
6464
}
6565
}
6666
/// Unmap all pages in the area from page table `pt`
67-
fn unmap(&self, pt: &mut PageTable) {
67+
fn unmap(&self, pt: &mut dyn PageTable) {
6868
for page in Page::range_of(self.start_addr, self.end_addr) {
6969
self.handler.unmap(pt, page.start_address());
7070
}
@@ -103,7 +103,7 @@ impl MemoryAttr {
103103
}
104104
/// Apply the attributes to page table entry, then update it.
105105
/// NOTE: You may need to set present manually.
106-
pub fn apply(&self, entry: &mut Entry) {
106+
pub fn apply(&self, entry: &mut dyn Entry) {
107107
entry.set_user(self.user);
108108
entry.set_writable(!self.readonly);
109109
entry.set_execute(self.execute);

‎crate/memory/src/paging/mock_page_table.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -101,12 +101,12 @@ impl Entry for MockEntry {
101101
}
102102
}
103103

104-
type PageFaultHandler = Box<FnMut(&mut MockPageTable, VirtAddr)>;
104+
type PageFaultHandler = Box<dyn FnMut(&mut MockPageTable, VirtAddr)>;
105105

106106
impl PageTable for MockPageTable {
107107
// type Entry = MockEntry;
108108

109-
fn map(&mut self, addr: VirtAddr, target: PhysAddr) -> &mut Entry {
109+
fn map(&mut self, addr: VirtAddr, target: PhysAddr) -> &mut dyn Entry {
110110
let entry = &mut self.entries[addr / PAGE_SIZE];
111111
assert!(!entry.present);
112112
entry.present = true;
@@ -119,7 +119,7 @@ impl PageTable for MockPageTable {
119119
assert!(entry.present);
120120
entry.present = false;
121121
}
122-
fn get_entry(&mut self, addr: VirtAddr) -> Option<&mut Entry> {
122+
fn get_entry(&mut self, addr: VirtAddr) -> Option<&mut dyn Entry> {
123123
Some(&mut self.entries[addr / PAGE_SIZE])
124124
}
125125
fn get_page_slice_mut<'a, 'b>(&'a mut self, addr: VirtAddr) -> &'b mut [u8] {

‎crate/memory/src/paging/mod.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,14 +14,14 @@ pub trait PageTable {
1414

1515
/// Map a page of virual address `addr` to the frame of physics address `target`
1616
/// Return the page table entry of the mapped virual address
17-
fn map(&mut self, addr: VirtAddr, target: PhysAddr) -> &mut Entry;
17+
fn map(&mut self, addr: VirtAddr, target: PhysAddr) -> &mut dyn Entry;
1818

1919
/// Unmap a page of virual address `addr`
2020
fn unmap(&mut self, addr: VirtAddr);
2121

2222
/// Get the page table entry of a page of virual address `addr`
2323
/// If its page do not exist, return `None`
24-
fn get_entry(&mut self, addr: VirtAddr) -> Option<&mut Entry>;
24+
fn get_entry(&mut self, addr: VirtAddr) -> Option<&mut dyn Entry>;
2525

2626
/// Get a mutable reference of the content of a page of virtual address `addr`
2727
fn get_page_slice_mut<'a>(&mut self, addr: VirtAddr) -> &'a mut [u8];

‎kernel/src/arch/aarch64/paging.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ pub struct PageTableImpl {
2525
pub struct PageEntry(&'static mut PageTableEntry, Page);
2626

2727
impl PageTable for PageTableImpl {
28-
fn map(&mut self, addr: usize, target: usize) -> &mut Entry {
28+
fn map(&mut self, addr: usize, target: usize) -> &mut dyn Entry {
2929
let flags = EF::default();
3030
let attr = MairNormal::attr_value();
3131
unsafe {
@@ -51,7 +51,7 @@ impl PageTable for PageTableImpl {
5151
.flush();
5252
}
5353

54-
fn get_entry(&mut self, vaddr: usize) -> Option<&mut Entry> {
54+
fn get_entry(&mut self, vaddr: usize) -> Option<&mut dyn Entry> {
5555
let page = Page::of_addr(vaddr as u64);
5656
if let Ok(e) = self.page_table.get_entry_mut(page) {
5757
let e = unsafe { &mut *(e as *mut PageTableEntry) };

‎kernel/src/arch/mipsel/paging.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ pub struct PageTableImpl {
2020
pub struct PageEntry(&'static mut PageTableEntry, Page);
2121

2222
impl PageTable for PageTableImpl {
23-
fn map(&mut self, addr: usize, target: usize) -> &mut Entry {
23+
fn map(&mut self, addr: usize, target: usize) -> &mut dyn Entry {
2424
// map the 4K `page` to the 4K `frame` with `flags`
2525
let flags = EF::VALID | EF::WRITABLE | EF::CACHEABLE;
2626
let page = Page::of_addr(VirtAddr::new(addr));
@@ -39,7 +39,7 @@ impl PageTable for PageTableImpl {
3939
flush.flush();
4040
}
4141

42-
fn get_entry(&mut self, vaddr: usize) -> Option<&mut Entry> {
42+
fn get_entry(&mut self, vaddr: usize) -> Option<&mut dyn Entry> {
4343
let page = Page::of_addr(VirtAddr::new(vaddr));
4444
if let Ok(e) = self.page_table.ref_entry(page.clone()) {
4545
let e = unsafe { &mut *(e as *mut PageTableEntry) };

0 commit comments

Comments
 (0)