Fix clippy warnings.

gz · gz · commit fc25186d57ca · 2023-03-10T20:53:49.000-08:00
diff --git a/kernel/src/arch/unix/process.rs b/kernel/src/arch/unix/process.rs
@@ -111,7 +111,7 @@ impl crate::nrproc::ProcessManager for ArchProcessManagement {
         ArrayVec<Arc<Replica<'static, NrProcess<Self::Process>>>, MAX_PROCESSES>,
         MAX_NUMA_NODES,
     > {
-        &*super::process::PROCESS_TABLE
+        &super::process::PROCESS_TABLE
     }
 }
 
@@ -227,13 +227,13 @@ impl Process for UnixProcess {
     }
 
     fn get_executor(&mut self, _for_region: atopology::NodeId) -> Result<Box<Self::E>, KError> {
-        Ok(Box::new(UnixThread::default()))
+        Ok(Box::default())
     }
 
     fn allocate_fd(&mut self) -> Option<(u64, &mut FileDescriptorEntry)> {
         if let Some(fid) = self.fds.iter().position(|fd| fd.is_none()) {
             self.fds[fid] = Some(Default::default());
-            Some((fid as u64, self.fds[fid as usize].as_mut().unwrap()))
+            Some((fid as u64, self.fds[fid].as_mut().unwrap()))
         } else {
             None
         }
diff --git a/kernel/src/arch/x86_64/vspace/mod.rs b/kernel/src/arch/x86_64/vspace/mod.rs
@@ -7,7 +7,7 @@ use core::ops::Bound::*;
 use fallible_collections::btree::BTreeMap;
 use lazy_static::lazy_static;
 use spin::Mutex;
-use x86::current::paging::{PDFlags, PDPTFlags, PTFlags, PML4Flags, PML4Entry};
+use x86::current::paging::{PDFlags, PDPTFlags, PML4Entry, PML4Flags, PTFlags};
 
 mod debug;
 pub mod page_table; /* TODO(encapsulation): This should be a private module but we break encapsulation in a few places */
@@ -18,7 +18,7 @@ use crate::error::KError;
 use crate::memory::{detmem::DA, vspace::*};
 use crate::memory::{Frame, PAddr, VAddr};
 
-use page_table::{PT_LAYOUT, PageTable};
+use page_table::{PageTable, PT_LAYOUT};
 
 lazy_static! {
     /// A handle to the initial kernel address space (created for us by the
diff --git a/kernel/src/environment.rs b/kernel/src/environment.rs
@@ -9,7 +9,7 @@ use crate::arch::{MAX_CORES, MAX_NUMA_NODES};
 /// The core id of the current core (hardware thread).
 #[thread_local]
 pub(crate) static CORE_ID: Lazy<usize> =
-    Lazy::new(|| atopology::MACHINE_TOPOLOGY.current_thread().id as usize);
+    Lazy::new(|| atopology::MACHINE_TOPOLOGY.current_thread().id);
 
 /// The NUMA node id of the current core (hardware thread).
 #[thread_local]
diff --git a/kernel/src/fs/cnrfs.rs b/kernel/src/fs/cnrfs.rs
@@ -590,7 +590,7 @@ impl Dispatch for MlnrKernelNode {
                     .read()
                     .get(&pid)
                     .ok_or(KError::NoProcessFoundForPid)?;
-                let _is_deleted = self.fs.delete(&filename)?;
+                self.fs.delete(&filename)?;
                 Ok(MlnrNodeResult::FileDeleted)
             }
 
@@ -600,7 +600,7 @@ impl Dispatch for MlnrKernelNode {
                     .read()
                     .get(&pid)
                     .ok_or(KError::NoProcessFoundForPid)?;
-                let _is_renamed = self.fs.rename(&oldname, newname)?;
+                self.fs.rename(&oldname, newname)?;
                 Ok(MlnrNodeResult::FileRenamed)
             }
 
@@ -610,7 +610,7 @@ impl Dispatch for MlnrKernelNode {
                     .read()
                     .get(&pid)
                     .ok_or(KError::NoProcessFoundForPid)?;
-                let _is_created = self.fs.mkdir(filename, modes)?;
+                self.fs.mkdir(filename, modes)?;
                 Ok(MlnrNodeResult::DirCreated)
             }
         }
diff --git a/kernel/src/fs/fd.rs b/kernel/src/fs/fd.rs
@@ -71,10 +71,7 @@ impl FileDescriptorTable {
     pub(crate) fn allocate_fd(&mut self) -> Option<(FileDescriptor, &mut FileDescriptorEntry)> {
         if let Some(fid) = self.table.iter().position(|fd| fd.is_none()) {
             self.table[fid] = Some(Default::default());
-            Some((
-                FileDescriptor::new(fid),
-                self.table[fid as usize].as_mut().unwrap(),
-            ))
+            Some((FileDescriptor::new(fid), self.table[fid].as_mut().unwrap()))
         } else {
             None
         }
diff --git a/kernel/src/fs/mnode.rs b/kernel/src/fs/mnode.rs
@@ -106,7 +106,7 @@ impl MemNode {
         }
         // Return error if start-offset is greater than or equal to new-offset OR
         // new offset is greater than the file size.
-        if offset >= new_offset || new_offset > self.get_file_size() as usize {
+        if offset >= new_offset || new_offset > self.get_file_size() {
             return Err(KError::InvalidOffset);
         }
 
diff --git a/kernel/src/graphviz.rs b/kernel/src/graphviz.rs
@@ -154,7 +154,7 @@ impl<'a> Id<'a> {
     }
 
     pub(crate) fn as_slice(&'a self) -> &'a str {
-        &*self.name
+        &self.name
     }
 
     pub(crate) fn name(self) -> Cow<'a, str> {
@@ -280,7 +280,7 @@ impl<'a> LabelText<'a> {
             Esc(s) => s,
             Label(s) => {
                 if s.contains('\\') {
-                    (&*s).escape_default().to_string().into()
+                    (*s).escape_default().to_string().into()
                 } else {
                     s
                 }
diff --git a/kernel/src/memory/global.rs b/kernel/src/memory/global.rs
@@ -69,7 +69,7 @@ impl GlobalMemory {
         // How many NUMA nodes are there in the system
         let max_affinity: usize = memory
             .iter()
-            .map(|f| f.affinity as usize)
+            .map(|f| f.affinity)
             .max()
             .expect("Need at least some frames")
             + 1;
diff --git a/kernel/src/memory/mod.rs b/kernel/src/memory/mod.rs
@@ -264,19 +264,11 @@ impl KernelAllocator {
         let (gmanager, mut mem_manager, affinity) = match mem_type {
             MemType::Mem => {
                 let affinity = { pcm.physical_memory.borrow().affinity };
-                (
-                    pcm.gmanager.unwrap(),
-                    pcm.try_mem_manager()?,
-                    affinity as usize,
-                )
+                (pcm.gmanager.unwrap(), pcm.try_mem_manager()?, affinity)
             }
             MemType::PMem => {
                 let affinity = { pcm.persistent_memory.borrow().affinity };
-                (
-                    pcm.pgmanager.unwrap(),
-                    pcm.pmem_manager(),
-                    affinity as usize,
-                )
+                (pcm.pgmanager.unwrap(), pcm.pmem_manager(), affinity)
             }
         };
         let mut ncache = gmanager.node_caches[affinity].lock();
@@ -496,8 +488,7 @@ unsafe impl GlobalAlloc for KernelAllocator {
                             Err(_e) => match pcm.gmanager {
                                 // Try adding frame to ncache.
                                 Some(gmanager) => {
-                                    let mut ncache =
-                                        gmanager.node_caches[frame.affinity as usize].lock();
+                                    let mut ncache = gmanager.node_caches[frame.affinity].lock();
                                     ncache
                                         .release_base_page(frame)
                                         .expect("Can't deallocate frame");
diff --git a/kernel/src/memory/per_core.rs b/kernel/src/memory/per_core.rs
@@ -137,7 +137,7 @@ impl PerCoreMemory {
             debug_assert_eq!(arena.affinity, node);
 
             core::mem::swap(&mut arena, current_arena);
-            arenas[arena.affinity as usize].replace(arena);
+            arenas[arena.affinity].replace(arena);
 
             Ok(())
         } else {
diff --git a/kernel/src/memory/vspace.rs b/kernel/src/memory/vspace.rs
@@ -42,7 +42,7 @@ impl TlbFlushHandle {
     }
 
     pub(crate) fn add_core(&mut self, gtid: atopology::GlobalThreadId) {
-        self.core_map.set_bit(gtid as usize, true)
+        self.core_map.set_bit(gtid, true)
     }
 
     pub(crate) fn cores(&self) -> CoreBitMapIter {
diff --git a/kernel/src/nr.rs b/kernel/src/nr.rs
@@ -140,7 +140,7 @@ impl Dispatch for KernelNode {
                 }
             },
             Op::SchedAllocateCore(pid, _affinity, Some(gtid), entry_point) => {
-                assert!((gtid as usize) < MAX_CORES, "Invalid gtid");
+                assert!(gtid < MAX_CORES, "Invalid gtid");
 
                 match self.scheduler_map.get(&gtid) {
                     Some(_cinfo) => Err(KError::CoreAlreadyAllocated),
diff --git a/kernel/src/nrproc.rs b/kernel/src/nrproc.rs
@@ -114,7 +114,7 @@ pub(crate) fn advance_all() {
     let node = *crate::environment::NODE_ID;
 
     for pid in 0..MAX_PROCESSES {
-        let _r = PROCESS_TABLE[node][pid].sync(PROCESS_TOKEN.get().unwrap()[pid]);
+        PROCESS_TABLE[node][pid].sync(PROCESS_TOKEN.get().unwrap()[pid]);
     }
 }
 
diff --git a/kernel/src/panic.rs b/kernel/src/panic.rs
@@ -31,7 +31,7 @@ fn new_ctxt(
             .find_section_by_name(S::section_name())
             .map(|s| s.raw_data(&elf.file))
             .unwrap_or(&[]);
-        S::from(gimli::EndianRcSlice::new(Rc::from(&*data), endian))
+        S::from(gimli::EndianRcSlice::new(Rc::from(data), endian))
     }
 
     let debug_abbrev: gimli::DebugAbbrev<_> = load_section(file, endian);
diff --git a/kernel/src/process.rs b/kernel/src/process.rs
@@ -232,7 +232,7 @@ impl elfloader::ElfLoader for DataSecAllocator {
             // We can't expect to get something that is page-aligned from ELF
             let page_mask = (LARGE_PAGE_SIZE - 1) as u64;
             let page_base: VAddr = VAddr::from(base & !page_mask); // Round down to nearest page-size
-            let size_page = round_up!(size + (base & page_mask) as usize, LARGE_PAGE_SIZE as usize);
+            let size_page = round_up!(size + (base & page_mask) as usize, LARGE_PAGE_SIZE);
             assert!(size_page >= size);
             assert_eq!(size_page % LARGE_PAGE_SIZE, 0);
             assert_eq!(page_base % LARGE_PAGE_SIZE, 0);
@@ -480,7 +480,7 @@ pub(crate) fn allocate_dispatchers<P: Process>(pid: Pid, affinity: NodeId) -> Re
         KernelAllocator::try_refill_tcache(20, 1, MemType::Mem)?;
         let mut frame = {
             let pcm = crate::arch::kcb::per_core_mem();
-            pcm.gmanager.unwrap().node_caches[affinity as usize]
+            pcm.gmanager.unwrap().node_caches[affinity]
                 .lock()
                 .allocate_large_page()?
         };

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ impl crate::nrproc::ProcessManager for ArchProcessManagement {`
`111`	`111`	`ArrayVec<Arc<Replica<'static, NrProcess<Self::Process>>>, MAX_PROCESSES>,`
`112`	`112`	`MAX_NUMA_NODES,`
`113`	`113`	`> {`
`114`		`- &*super::process::PROCESS_TABLE`
	`114`	`+ &super::process::PROCESS_TABLE`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`@@ -227,13 +227,13 @@ impl Process for UnixProcess {`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`fn get_executor(&mut self, _for_region: atopology::NodeId) -> Result<Box<Self::E>, KError> {`
`230`		`- Ok(Box::new(UnixThread::default()))`
	`230`	`+ Ok(Box::default())`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`fn allocate_fd(&mut self) -> Option<(u64, &mut FileDescriptorEntry)> {`
`234`	`234`	`if let Some(fid) = self.fds.iter().position(\|fd\| fd.is_none()) {`
`235`	`235`	`self.fds[fid] = Some(Default::default());`
`236`		`- Some((fid as u64, self.fds[fid as usize].as_mut().unwrap()))`
	`236`	`+ Some((fid as u64, self.fds[fid].as_mut().unwrap()))`
`237`	`237`	`} else {`
`238`	`238`	`None`
`239`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -590,7 +590,7 @@ impl Dispatch for MlnrKernelNode {`
`590`	`590`	`.read()`
`591`	`591`	`.get(&pid)`
`592`	`592`	`.ok_or(KError::NoProcessFoundForPid)?;`
`593`		`- let _is_deleted = self.fs.delete(&filename)?;`
	`593`	`+ self.fs.delete(&filename)?;`
`594`	`594`	`Ok(MlnrNodeResult::FileDeleted)`
`595`	`595`	`}`
`596`	`596`
`@@ -600,7 +600,7 @@ impl Dispatch for MlnrKernelNode {`
`600`	`600`	`.read()`
`601`	`601`	`.get(&pid)`
`602`	`602`	`.ok_or(KError::NoProcessFoundForPid)?;`
`603`		`- let _is_renamed = self.fs.rename(&oldname, newname)?;`
	`603`	`+ self.fs.rename(&oldname, newname)?;`
`604`	`604`	`Ok(MlnrNodeResult::FileRenamed)`
`605`	`605`	`}`
`606`	`606`
`@@ -610,7 +610,7 @@ impl Dispatch for MlnrKernelNode {`
`610`	`610`	`.read()`
`611`	`611`	`.get(&pid)`
`612`	`612`	`.ok_or(KError::NoProcessFoundForPid)?;`
`613`		`- let _is_created = self.fs.mkdir(filename, modes)?;`
	`613`	`+ self.fs.mkdir(filename, modes)?;`
`614`	`614`	`Ok(MlnrNodeResult::DirCreated)`
`615`	`615`	`}`
`616`	`616`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ impl MemNode {`
`106`	`106`	`}`
`107`	`107`	`// Return error if start-offset is greater than or equal to new-offset OR`
`108`	`108`	`// new offset is greater than the file size.`
`109`		`- if offset >= new_offset \|\| new_offset > self.get_file_size() as usize {`
	`109`	`+ if offset >= new_offset \|\| new_offset > self.get_file_size() {`
`110`	`110`	`return Err(KError::InvalidOffset);`
`111`	`111`	`}`
`112`	`112`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ impl<'a> Id<'a> {`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`pub(crate) fn as_slice(&'a self) -> &'a str {`
`157`		`- &*self.name`
	`157`	`+ &self.name`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`pub(crate) fn name(self) -> Cow<'a, str> {`
`@@ -280,7 +280,7 @@ impl<'a> LabelText<'a> {`
`280`	`280`	`Esc(s) => s,`
`281`	`281`	`Label(s) => {`
`282`	`282`	`if s.contains('\\') {`
`283`		`- (&*s).escape_default().to_string().into()`
	`283`	`+ (*s).escape_default().to_string().into()`
`284`	`284`	`} else {`
`285`	`285`	`s`
`286`	`286`	`}`