Fix a number of warnings

src/arch/x86_64/gdt.rs

@@ -10,8 +10,6 @@ use x86::dtables::{self, DescriptorTablePointer};
 use x86::segmentation::{self, Descriptor as SegmentDescriptor, SegmentSelector};
 use x86::task;
 
-use crate::paging::PAGE_SIZE;
-
 pub const GDT_NULL: usize = 0;
 pub const GDT_KERNEL_CODE: usize = 1;
 pub const GDT_KERNEL_DATA: usize = 2;

src/arch/x86_64/idt.rs

@@ -45,7 +45,7 @@ impl Idt {
         let byte_index = index / 64;
         let bit = index % 64;
 
-        unsafe { &self.reservations[usize::from(byte_index)] }.load(Ordering::Acquire) & (1 << bit) != 0
+        { &self.reservations[usize::from(byte_index)] }.load(Ordering::Acquire) & (1 << bit) != 0
     }
 
     #[inline]
@@ -53,14 +53,14 @@ impl Idt {
         let byte_index = index / 64;
         let bit = index % 64;
 
-        unsafe { &self.reservations[usize::from(byte_index)] }.fetch_or(u64::from(reserved) << bit, Ordering::AcqRel);
+        { &self.reservations[usize::from(byte_index)] }.fetch_or(u64::from(reserved) << bit, Ordering::AcqRel);
     }
     #[inline]
     pub fn is_reserved_mut(&mut self, index: u8) -> bool {
         let byte_index = index / 64;
         let bit = index % 64;
 
-        *unsafe { &mut self.reservations[usize::from(byte_index)] }.get_mut() & (1 << bit) != 0
+        *{ &mut self.reservations[usize::from(byte_index)] }.get_mut() & (1 << bit) != 0
     }
 
     #[inline]
@@ -68,7 +68,7 @@ impl Idt {
         let byte_index = index / 64;
         let bit = index % 64;
 
-        *unsafe { &mut self.reservations[usize::from(byte_index)] }.get_mut() |= u64::from(reserved) << bit;
+        *{ &mut self.reservations[usize::from(byte_index)] }.get_mut() |= u64::from(reserved) << bit;
     }
 }
 
@@ -82,7 +82,7 @@ pub fn is_reserved(cpu_id: usize, index: u8) -> bool {
     let byte_index = index / 64;
     let bit = index % 64;
 
-    unsafe { &IDTS.read().as_ref().unwrap().get(&cpu_id).unwrap().reservations[usize::from(byte_index)] }.load(Ordering::Acquire) & (1 << bit) != 0
+    { &IDTS.read().as_ref().unwrap().get(&cpu_id).unwrap().reservations[usize::from(byte_index)] }.load(Ordering::Acquire) & (1 << bit) != 0
 }
 
 #[inline]
@@ -90,7 +90,7 @@ pub fn set_reserved(cpu_id: usize, index: u8, reserved: bool) {
     let byte_index = index / 64;
     let bit = index % 64;
 
-    unsafe { &IDTS.read().as_ref().unwrap().get(&cpu_id).unwrap().reservations[usize::from(byte_index)] }.fetch_or(u64::from(reserved) << bit, Ordering::AcqRel);
+    { &IDTS.read().as_ref().unwrap().get(&cpu_id).unwrap().reservations[usize::from(byte_index)] }.fetch_or(u64::from(reserved) << bit, Ordering::AcqRel);
 }
 
 pub fn allocate_interrupt() -> Option<NonZeroU8> {

src/arch/x86_64/paging/table.rs

@@ -54,7 +54,7 @@ impl<L> Table<L> where L: TableLevel {
     }
 
     pub fn zero(&mut self) {
-        for entry in unsafe { &mut self.entries }.iter_mut() {
+        for entry in self.entries.iter_mut() {
             entry.set_zero();
         }
     }
@@ -62,12 +62,12 @@ impl<L> Table<L> where L: TableLevel {
     /// Set number of entries in first table entry
     fn set_entry_count(&mut self, count: u64) {
         debug_assert!(count <= ENTRY_COUNT as u64, "count can't be greater than ENTRY_COUNT");
-        unsafe { &mut self.entries[0] }.set_counter_bits(count)
+        self.entries[0].set_counter_bits(count)
     }
 
     /// Get number of entries in first table entry
     fn entry_count(&self) -> u64 {
-        unsafe { &self.entries[0] }.counter_bits()
+        self.entries[0].counter_bits()
     }
 
     pub fn increment_entry_count(&mut self) {
@@ -124,12 +124,12 @@ impl<L> Index<usize> for Table<L> where L: TableLevel {
     type Output = Entry;
 
     fn index(&self, index: usize) -> &Entry {
-        unsafe { &self.entries[index] }
+        &self.entries[index]
     }
 }
 
 impl<L> IndexMut<usize> for Table<L> where L: TableLevel {
     fn index_mut(&mut self, index: usize) -> &mut Entry {
-        unsafe { &mut self.entries[index] }
+        &mut self.entries[index]
     }
 }