[PATCH proxmox-backup v2 07/10] tape: tape block: make `payload` field private

["Max R. Carrara" <m.carrara@proxmox.com>]

While all cases where we directly use the `payload` field are fine,
direct field access should IMO be used as sparingly as possible, as
the field *itself* is otherwise part of a type's public API.

Therefore, make the `payload` field of `TapeBlock` private and add
corresponding getters to allow obtaining it as a (mutable) slice.

Signed-off-by: Max R. Carrara <m.carrara@proxmox.com>
---
 pbs-tape/src/blocked_reader.rs | 11 +++++------
 pbs-tape/src/blocked_writer.rs | 13 ++++++++-----
 pbs-tape/src/tape_block.rs     | 12 +++++++++++-
 3 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/pbs-tape/src/blocked_reader.rs b/pbs-tape/src/blocked_reader.rs
index cf8150ba3..6b1e3c692 100644
--- a/pbs-tape/src/blocked_reader.rs
+++ b/pbs-tape/src/blocked_reader.rs
@@ -81,11 +81,11 @@ impl<R: BlockRead> BlockedReader<R> {
         let size = tape_block.size();
         let found_end_marker = tape_block.flags().contains(TapeBlockFlags::END_OF_STREAM);
 
-        if size > tape_block.payload.len() {
+        if size > tape_block.payload().len() {
             proxmox_lang::io_bail!(
                 "detected tape block with wrong payload size ({} > {}",
                 size,
-                tape_block.payload.len()
+                tape_block.payload().len()
             );
         } else if size == 0 && !found_end_marker {
             proxmox_lang::io_bail!("detected tape block with zero payload size");
@@ -130,7 +130,7 @@ impl<R: BlockRead> BlockedReader<R> {
             Ok(()) => { /* ok */ }
             Err(BlockReadError::EndOfFile) => {
                 self.got_eod = true;
-                self.read_pos = self.tape_block.payload.len();
+                self.read_pos = self.tape_block.payload().len();
                 if !self.found_end_marker && check_end_marker {
                     proxmox_lang::io_bail!("detected tape stream without end marker");
                 }
@@ -228,9 +228,8 @@ impl<R: BlockRead> Read for BlockedReader<R> {
             } else {
                 rest as usize
             };
-            buffer[..copy_len].copy_from_slice(
-                &self.tape_block.payload[self.read_pos..(self.read_pos + copy_len)],
-            );
+            let payload = self.tape_block.payload();
+            buffer[..copy_len].copy_from_slice(&payload[self.read_pos..(self.read_pos + copy_len)]);
             self.read_pos += copy_len;
             Ok(copy_len)
         }
diff --git a/pbs-tape/src/blocked_writer.rs b/pbs-tape/src/blocked_writer.rs
index 5e94f54b8..0d5d10147 100644
--- a/pbs-tape/src/blocked_writer.rs
+++ b/pbs-tape/src/blocked_writer.rs
@@ -69,16 +69,18 @@ impl<W: BlockWrite> BlockedWriter<W> {
             return Ok(0);
         }
 
-        let rest = self.tape_block.payload.len() - self.buffer_pos;
+        let payload = self.tape_block.payload_mut();
+        let payload_len = payload.len();
+
+        let rest = payload_len - self.buffer_pos;
         let bytes = if data.len() < rest { data.len() } else { rest };
-        self.tape_block.payload[self.buffer_pos..(self.buffer_pos + bytes)]
-            .copy_from_slice(&data[..bytes]);
+        payload[self.buffer_pos..(self.buffer_pos + bytes)].copy_from_slice(&data[..bytes]);
 
         let rest = rest - bytes;
 
         if rest == 0 {
             self.tape_block.set_flags(TapeBlockFlags::empty());
-            self.tape_block.set_size(self.tape_block.payload.len());
+            self.tape_block.set_size(payload_len);
             self.tape_block.set_seq_nr(self.seq_nr);
             self.seq_nr += 1;
             let leom = Self::write_block(&self.tape_block, &mut self.writer)?;
@@ -115,7 +117,8 @@ impl<W: BlockWrite> TapeWrite for BlockedWriter<W> {
     /// Note: This may write an empty block just including the
     /// END_OF_STREAM flag.
     fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error> {
-        vec::clear(&mut self.tape_block.payload[self.buffer_pos..]);
+        let payload = self.tape_block.payload_mut();
+        vec::clear(&mut payload[self.buffer_pos..]);
         let mut flags = TapeBlockFlags::END_OF_STREAM;
         if incomplete {
             flags |= TapeBlockFlags::INCOMPLETE;
diff --git a/pbs-tape/src/tape_block.rs b/pbs-tape/src/tape_block.rs
index 2db5ed137..c73efafa7 100644
--- a/pbs-tape/src/tape_block.rs
+++ b/pbs-tape/src/tape_block.rs
@@ -33,7 +33,7 @@ static_assert_size!(TapeBlockHeader, 16);
 #[repr(C, packed)]
 pub struct TapeBlock {
     header: TapeBlockHeader,
-    pub payload: [u8],
+    payload: [u8],
 }
 
 bitflags! {
@@ -107,4 +107,14 @@ impl TapeBlock {
     pub fn set_seq_nr(&mut self, seq_nr: u32) {
         self.header.seq_nr = seq_nr.to_le();
     }
+
+    /// Returns the tape block's data payload as a byte slice.
+    pub fn payload(&self) -> &[u8] {
+        &self.payload
+    }
+
+    /// Returns the tape block's data payload as a mutable byte slice.
+    pub fn payload_mut(&mut self) -> &mut [u8] {
+        &mut self.payload
+    }
 }
-- 
2.47.3