Merge pull request torvalds#222 from wedsonaf/clear

Add `UserSlicePtrWriter::clear`.

rust/helpers.c

@@ -22,6 +22,11 @@ unsigned long rust_helper_copy_to_user(void __user *to, const void *from, unsign
  return copy_to_user(to, from, n);
 }
 
+unsigned long rust_helper_clear_user(void __user *to, unsigned long n)
+{
+ return clear_user(to, n);
+}
+
 void rust_helper_spin_lock_init(spinlock_t *lock, const char *name,
  struct lock_class_key *key)
 {

rust/kernel/user_ptr.rs

@@ -20,6 +20,8 @@ extern "C" {
  from: *const c_types::c_void,
  n: c_types::c_ulong,
  ) -> c_types::c_ulong;
+
+ fn rust_helper_clear_user(to: *mut c_types::c_void, n: c_types::c_ulong) -> c_types::c_ulong;
 }
 
 /// Specifies that a type is safely readable from byte slices.
@@ -242,6 +244,34 @@ impl UserSlicePtrWriter {
  self.len() == 0
  }
 
+ /// Writes zeroes to the user slice.
+ ///
+ /// Differently from the other write functions, `clear` will zero as much as it can and update
+ /// the writer internal state to reflect this. It will, however, return an error if it cannot
+ /// clear `len` bytes.
+ ///
+ /// For example, if a caller requests that 100 bytes be cleared but a segfault happens after
+ /// 20 bytes, then EFAULT is returned and the writer is advanced by 20 bytes.
+ pub fn clear(&mut self, mut len: usize) -> KernelResult {
+ let mut ret = Ok(());
+ if len > self.1 {
+ ret = Err(Error::EFAULT);
+ len = self.1;
+ }
+
+ // SAFETY: The buffer will be validated by `clear_user`. We ensure that `len` is within
+ // bounds in the check above.
+ let left = unsafe { rust_helper_clear_user(self.0, len as _) } as usize;
+ if left != 0 {
+ ret = Err(Error::EFAULT);
+ len -= left;
+ }
+
+ self.0 = self.0.wrapping_add(len);
+ self.1 -= len;
+ ret
+ }
+
  /// Writes a byte slice to the user slice.
  ///
  /// Returns `EFAULT` if the byte slice is bigger than the remaining size