Get the codebase clippy clean

Author: alex

src/allocator.rs

@@ -10,7 +10,7 @@ unsafe impl GlobalAlloc for KernelAllocator {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         // krealloc is used instead of kmalloc because kmalloc is an inline function and can't be
         // bound to as a result
-        return bindings::krealloc(ptr::null(), layout.size(), bindings::GFP_KERNEL) as *mut u8;
+        bindings::krealloc(ptr::null(), layout.size(), bindings::GFP_KERNEL) as *mut u8
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {

src/bindings.rs

@@ -1,7 +1,14 @@
-#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case, improper_ctypes)]
-
-use crate::c_types;
-
-include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+#[allow(
+    clippy::all,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    improper_ctypes
+)]
+mod bindings {
+    use crate::c_types;
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+}
+pub use bindings::*;
 
 pub const GFP_KERNEL: gfp_t = BINDINGS_GFP_KERNEL;

src/chrdev.rs

@@ -16,11 +16,11 @@ pub fn builder(name: &'static str, minors: Range<u16>) -> KernelResult<Builder>
         return Err(Error::EINVAL);
     }
 
-    return Ok(Builder {
+    Ok(Builder {
         name,
         minors,
         file_ops: vec![],
-    });
+    })
 }
 
 pub struct Builder {
@@ -35,7 +35,7 @@ impl Builder {
             panic!("More devices registered than minor numbers allocated.")
         }
         self.file_ops.push(&T::VTABLE);
-        return self;
+        self
     }
 
     pub fn build(self) -> KernelResult<Registration> {
@@ -71,11 +71,11 @@ impl Builder {
             }
         }
 
-        return Ok(Registration {
+        Ok(Registration {
             dev,
             count: self.minors.len(),
             cdevs,
-        });
+        })
     }
 }
 
@@ -110,7 +110,7 @@ unsafe extern "C" fn open_callback<T: FileOperations>(
         Err(e) => return e.to_kernel_errno(),
     };
     (*file).private_data = Box::into_raw(f) as *mut c_types::c_void;
-    return 0;
+    0
 }
 
 unsafe extern "C" fn read_callback<T: FileOperations>(
@@ -129,10 +129,10 @@ unsafe extern "C" fn read_callback<T: FileOperations>(
         Ok(()) => {
             let written = len - data.len();
             (*offset) += written as bindings::loff_t;
-            return written as c_types::c_ssize_t;
+            written as c_types::c_ssize_t
         }
-        Err(e) => return e.to_kernel_errno() as c_types::c_ssize_t,
-    };
+        Err(e) => e.to_kernel_errno() as c_types::c_ssize_t,
+    }
 }
 
 unsafe extern "C" fn release_callback<T: FileOperations>(
@@ -141,12 +141,12 @@ unsafe extern "C" fn release_callback<T: FileOperations>(
 ) -> c_types::c_int {
     let ptr = mem::replace(&mut (*file).private_data, ptr::null_mut());
     drop(Box::from_raw(ptr as *mut T));
-    return 0;
+    0
 }
 
 impl FileOperationsVtable {
     pub const fn new<T: FileOperations>() -> FileOperationsVtable {
-        return FileOperationsVtable(bindings::file_operations {
+        FileOperationsVtable(bindings::file_operations {
             open: Some(open_callback::<T>),
             read: Some(read_callback::<T>),
             release: Some(release_callback::<T>),
@@ -181,7 +181,7 @@ impl FileOperationsVtable {
             unlocked_ioctl: None,
             write: None,
             write_iter: None,
-        });
+        })
     }
 }
 

src/error.rs

@@ -11,17 +11,17 @@ impl Error {
     pub const EFAULT: Self = Error(-(bindings::EFAULT as i32));
 
     pub fn from_kernel_errno(errno: c_types::c_int) -> Error {
-        return Error(errno);
+        Error(errno)
     }
 
     pub fn to_kernel_errno(&self) -> c_types::c_int {
-        return self.0;
+        self.0
     }
 }
 
 impl From<TryFromIntError> for Error {
     fn from(_: TryFromIntError) -> Error {
-        return Error::EINVAL;
+        Error::EINVAL
     }
 }
 

src/filesystem.rs

@@ -78,5 +78,5 @@ pub fn register<T: FileSystem>() -> error::KernelResult<FileSystemRegistration<T
         return Err(error::Error::from_kernel_errno(result));
     }
 
-    return Ok(fs_registration);
+    Ok(fs_registration)
 }

src/printk.rs

@@ -22,6 +22,7 @@ pub struct LogLineWriter {
     pos: usize,
 }
 
+#[allow(clippy::new_without_default)]
 impl LogLineWriter {
     pub fn new() -> LogLineWriter {
         LogLineWriter {
@@ -31,7 +32,7 @@ impl LogLineWriter {
     }
 
     pub fn as_bytes(&self) -> &[u8] {
-        return &self.data[..self.pos];
+        &self.data[..self.pos]
     }
 }
 
@@ -40,7 +41,7 @@ impl fmt::Write for LogLineWriter {
         let copy_len = cmp::min(LOG_LINE_MAX - self.pos, s.as_bytes().len());
         self.data[self.pos..self.pos + copy_len].copy_from_slice(&s.as_bytes()[..copy_len]);
         self.pos += copy_len;
-        return Ok(());
+        Ok(())
     }
 }
 

src/sysctl.rs

@@ -26,7 +26,7 @@ fn trim_whitespace(mut data: &[u8]) -> &[u8] {
     {
         data = &data[..data.len() - 1];
     }
-    return data;
+    data
 }
 
 impl SysctlStorage for atomic::AtomicBool {
@@ -42,7 +42,7 @@ impl SysctlStorage for atomic::AtomicBool {
             }
             _ => Err(error::Error::EINVAL),
         };
-        return (data.len(), result);
+        (data.len(), result)
     }
 
     fn read_value(&self, data: &mut UserSlicePtrWriter) -> (usize, error::KernelResult<()>) {
@@ -138,15 +138,15 @@ impl<T: SysctlStorage> Sysctl<T> {
             return Err(error::Error::ENOMEM);
         }
 
-        return Ok(Sysctl {
+        Ok(Sysctl {
             inner: storage,
             _table: table,
             header: result,
-        });
+        })
     }
 
     pub fn get(&self) -> &T {
-        return &self.inner;
+        &self.inner
     }
 }
 

src/types.rs

@@ -8,6 +8,6 @@ impl Mode {
     }
 
     pub fn as_int(&self) -> u16 {
-        return self.0;
+        self.0
     }
 }

src/user_ptr.rs

@@ -60,7 +60,7 @@ impl UserSlicePtr {
         if access_ok_helper(bindings::VERIFY_WRITE, ptr, length as c_types::c_ulong) == 0 {
             return Err(error::Error::EFAULT);
         }
-        return Ok(UserSlicePtr(ptr, length));
+        Ok(UserSlicePtr(ptr, length))
     }
 
     /// Read the entirety of the user slice and return it in a `Vec`.
@@ -70,13 +70,13 @@ impl UserSlicePtr {
     pub fn read_all(self) -> error::KernelResult<Vec<u8>> {
         let mut data = vec![0; self.1];
         self.reader().read(&mut data)?;
-        return Ok(data);
+        Ok(data)
     }
 
     /// Construct a `UserSlicePtrReader` that can incrementally read
     /// from the user slice.
     pub fn reader(self) -> UserSlicePtrReader {
-        return UserSlicePtrReader(self.0, self.1);
+        UserSlicePtrReader(self.0, self.1)
     }
 
     /// Write the provided slice into the user slice.
@@ -86,13 +86,13 @@ impl UserSlicePtr {
     /// fault may be written), or `data` is larger than the user slice
     /// (in which case no data is written).
     pub fn write_all(self, data: &[u8]) -> error::KernelResult<()> {
-        return self.writer().write(data);
+        self.writer().write(data)
     }
 
     /// Construct a `UserSlicePtrWrite` that can incrementally write
     /// into the user slice.
     pub fn writer(self) -> UserSlicePtrWriter {
-        return UserSlicePtrWriter(self.0, self.1);
+        UserSlicePtrWriter(self.0, self.1)
     }
 }
 
@@ -126,7 +126,11 @@ pub struct UserSlicePtrWriter(*mut c_types::c_void, usize);
 
 impl UserSlicePtrWriter {
     pub fn len(&self) -> usize {
-        return self.1;
+        self.1
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     pub fn write(&mut self, data: &[u8]) -> error::KernelResult<()> {