rust: kernel: apply rustfmt to from_kernel_result! blocks

Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Author: ojeda

rust/kernel/amba.rs

@@ -120,7 +120,11 @@ unsafe extern "C" fn probe_callback<T: Driver>(
         } else {
             // SAFETY: The offset comes from a previous call to `offset_from` in `IdArray::new`,
             // which guarantees that the resulting pointer is within the table.
-            let ptr = unsafe { aid.cast::<u8>().offset(offset as _).cast::<Option<T::IdInfo>>() };
+            let ptr = unsafe {
+                aid.cast::<u8>()
+                    .offset(offset as _)
+                    .cast::<Option<T::IdInfo>>()
+            };
             // SAFETY: The id table has a static lifetime, so `ptr` is guaranteed to be valid for
             // read.
             unsafe { (&*ptr).as_ref() }

rust/kernel/file.rs

@@ -361,8 +361,12 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
             // references to `file` have been released, so we know it can't be called while this
             // function is running.
             let f = unsafe { T::Data::borrow((*file).private_data) };
-            let read =
-                T::read(f, unsafe { File::from_ptr(file) }, &mut iter, offset.try_into()?)?;
+            let read = T::read(
+                f,
+                unsafe { File::from_ptr(file) },
+                &mut iter,
+                offset.try_into()?,
+            )?;
             unsafe { (*iocb).ki_pos += bindings::loff_t::try_from(read).unwrap() };
             Ok(read as _)
         }
@@ -389,7 +393,7 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
                 f,
                 unsafe { File::from_ptr(file) },
                 &mut data,
-                unsafe { *offset }.try_into()?
+                unsafe { *offset }.try_into()?,
             )?;
             unsafe { (*offset) += bindings::loff_t::try_from(written).unwrap() };
             Ok(written as _)
@@ -410,8 +414,12 @@ impl<A: OpenAdapter<T::OpenData>, T: Operations> OperationsVtable<A, T> {
             // references to `file` have been released, so we know it can't be called while this
             // function is running.
             let f = unsafe { T::Data::borrow((*file).private_data) };
-            let written =
-                T::write(f, unsafe { File::from_ptr(file) }, &mut iter, offset.try_into()?)?;
+            let written = T::write(
+                f,
+                unsafe { File::from_ptr(file) },
+                &mut iter,
+                offset.try_into()?,
+            )?;
             unsafe { (*iocb).ki_pos += bindings::loff_t::try_from(written).unwrap() };
             Ok(written as _)
         }

rust/kernel/fs.rs

@@ -166,7 +166,10 @@ impl<T: Type + ?Sized> Tables<T> {
             // SAFETY: The callback contract guarantees the parameter key to be valid and last at
             // least the duration of the callback.
             T::Context::parse_unknown_param(
-                &mut data, unsafe { CStr::from_char_ptr(param.key) }, val)?;
+                &mut data,
+                unsafe { CStr::from_char_ptr(param.key) },
+                val,
+            )?;
             Ok(0)
         }
     }
@@ -291,8 +294,9 @@ impl<T: Type + ?Sized> Tables<T> {
                 // SAFETY: Both `fc` and `buf` are guaranteed to be valid; the former because the
                 // callback is still ongoing and the latter because its lifefime is tied to that of
                 // `page`, which is also valid for the duration of the callback.
-                to_result(
-                    unsafe { bindings::generic_parse_monolithic(fc, buf.as_mut_ptr().cast()) })?;
+                to_result(unsafe {
+                    bindings::generic_parse_monolithic(fc, buf.as_mut_ptr().cast())
+                })?;
             }
             Ok(0)
         }

rust/kernel/irq.rs

@@ -213,7 +213,11 @@ unsafe extern "C" fn irq_set_type_callback<T: Chip>(
 
         // SAFETY: The value returned by `IrqData` is only valid until the end of this function, and
         // `irq_data` is guaranteed to be valid until then (by the contract with C code).
-        let ret = T::set_type(data, &mut LockedIrqData(unsafe { IrqData::from_ptr(irq_data) }), flow_type)?;
+        let ret = T::set_type(
+            data,
+            &mut LockedIrqData(unsafe { IrqData::from_ptr(irq_data) }),
+            flow_type,
+        )?;
         Ok(ret as _)
     }
 }