[fxfs] Move bitmap-based zeroing out of read_and_decrypt.

Externalized to be more in-keeping with "one function, one purpose".

Change-Id: I8467be7f20aa14aa13fe7b0317bfa29973b65869
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/1276525
Reviewed-by: Stephen Demos <[email protected]>
Commit-Queue: Auto-Submit <auto-submit-builder@fuchsia-internal-service-accts.iam.gserviceaccount.com>
Fuchsia-Auto-Submit: Aaron Drew <[email protected]>

Author: Aaron Drew

src/storage/fxfs/src/object_store/data_object_handle.rs

@@ -1175,14 +1175,8 @@ impl<S: HandleOwner> DataObjectHandle<S> {
                     // which case we don't actually need to bother zeroing out the tail. However,
                     // it's not strictly incorrect to change uninitialized data, so we skip the
                     // check and blindly do it to keep it simpler here.
-                    self.read_and_decrypt(
-                        device_offset,
-                        aligned_old_size,
-                        buf.as_mut(),
-                        *key_id,
-                        None,
-                    )
-                    .await?;
+                    self.read_and_decrypt(device_offset, aligned_old_size, buf.as_mut(), *key_id)
+                        .await?;
                     buf.as_mut_slice()[(old_size % block_size) as usize..].fill(0);
                     self.multi_write(
                         transaction,
@@ -1417,9 +1411,8 @@ impl<S: HandleOwner> DataObjectHandle<S> {
         file_offset: u64,
         buffer: MutableBufferRef<'_>,
         key_id: u64,
-        block_bitmap: Option<bit_vec::BitVec>,
     ) -> Result<(), Error> {
-        self.handle.read_and_decrypt(device_offset, file_offset, buffer, key_id, block_bitmap).await
+        self.handle.read_and_decrypt(device_offset, file_offset, buffer, key_id).await
     }
 
     /// Truncates a file to a given size (growing/shrinking as required).

src/storage/fxfs/src/object_store/store_object_handle.rs

@@ -57,6 +57,22 @@ pub const MAX_XATTR_VALUE_SIZE: usize = 64000;
 pub const EXTENDED_ATTRIBUTE_RANGE_START: u64 = 64;
 pub const EXTENDED_ATTRIBUTE_RANGE_END: u64 = 512;
 
+/// Zeroes blocks in 'buffer' based on `bitmap`, one bit per block from start of buffer.
+fn apply_bitmap_zeroing(
+    block_size: usize,
+    bitmap: &bit_vec::BitVec,
+    mut buffer: MutableBufferRef<'_>,
+) {
+    let buf = buffer.as_mut_slice();
+    debug_assert_eq!(bitmap.len() * block_size, buf.len());
+    for (i, block) in bitmap.iter().enumerate() {
+        if !block {
+            let start = i * block_size;
+            buf[start..start + block_size].fill(0);
+        }
+    }
+}
+
 /// When writing, often the logic should be generic over whether or not checksums are generated.
 /// This provides that and a handy way to convert to the more general ExtentMode that eventually
 /// stores it on disk.
@@ -697,10 +713,6 @@ impl<S: HandleOwner> StoreObjectHandle<S> {
         file_offset: u64,
         mut buffer: MutableBufferRef<'_>,
         key_id: u64,
-        // If provided, blocks in the bitmap that are zero will have their contents zeroed out. The
-        // bitmap should be exactly the size of the buffer and aligned to the offset in the extent
-        // the read is starting at.
-        block_bitmap: Option<bit_vec::BitVec>,
     ) -> Result<(), Error> {
         let store = self.store();
         store.device_read_ops.fetch_add(1, Ordering::Relaxed);
@@ -717,17 +729,6 @@ impl<S: HandleOwner> StoreObjectHandle<S> {
         if let Some(key) = key {
             key.decrypt(file_offset, buffer.as_mut_slice())?;
         }
-        if let Some(bitmap) = block_bitmap {
-            let block_size = self.block_size() as usize;
-            let buf = buffer.as_mut_slice();
-            debug_assert_eq!(bitmap.len() * block_size, buf.len());
-            for (i, block) in bitmap.iter().enumerate() {
-                if !block {
-                    let start = i * block_size;
-                    buf[start..start + block_size].fill(0);
-                }
-            }
-        }
         Ok(())
     }
 
@@ -985,7 +986,7 @@ impl<S: HandleOwner> StoreObjectHandle<S> {
                             "R",
                         );
                     }
-                    let (head, tail) = buf.split_at_mut(to_copy);
+                    let (mut head, tail) = buf.split_at_mut(to_copy);
                     let maybe_bitmap = match mode {
                         ExtentMode::OverwritePartial(bitmap) => {
                             let mut read_bitmap = bitmap.clone().split_off(
@@ -996,13 +997,15 @@ impl<S: HandleOwner> StoreObjectHandle<S> {
                         }
                         _ => None,
                     };
-                    reads.push(self.read_and_decrypt(
-                        device_offset,
-                        offset,
-                        head,
-                        key_id,
-                        maybe_bitmap,
-                    ));
+                    reads.push(async move {
+                        self
+                            .read_and_decrypt(device_offset, offset, head.reborrow(), key_id)
+                            .await?;
+                        if let Some(bitmap) = maybe_bitmap {
+                            apply_bitmap_zeroing(self.block_size() as usize, &bitmap, head);
+                        }
+                        Ok::<(), Error>(())
+                    });
                     buf = tail;
                     if buf.is_empty() {
                         break;
@@ -1031,7 +1034,7 @@ impl<S: HandleOwner> StoreObjectHandle<S> {
                             "RT",
                         );
                     }
-                    self.read_and_decrypt(device_offset, offset, align_buf.as_mut(), key_id, None)
+                    self.read_and_decrypt(device_offset, offset, align_buf.as_mut(), key_id)
                         .await?;
                     buf.as_mut_slice().copy_from_slice(&align_buf.as_slice()[..end_align]);
                     buf = buf.subslice_mut(0..0);
@@ -1112,9 +1115,15 @@ impl<S: HandleOwner> StoreObjectHandle<S> {
                             extent_key.range.start,
                             buffer.subslice_mut(offset..end as usize),
                             *key_id,
-                            maybe_bitmap,
                         )
                         .await?;
+                        if let Some(bitmap) = maybe_bitmap {
+                            apply_bitmap_zeroing(
+                                self.block_size() as usize,
+                                &bitmap,
+                                buffer.subslice_mut(offset..end as usize),
+                            );
+                        }
                         last_offset = end;
                         if last_offset >= size {
                             break;