From: "Max R. Carrara" <m.carrara@proxmox.com>
To: pbs-devel@lists.proxmox.com
Subject: [PATCH proxmox-backup 2/2] pbs-tape: rename `buffer` to `header`
Date: Wed, 5 Aug 2026 16:16:12 +0200 [thread overview]
Message-ID: <20260805141620.4190773-3-m.carrara@proxmox.com> (raw)
In-Reply-To: <20260805141620.4190773-1-m.carrara@proxmox.com>
... since `BlockHeader` is now a smart pointer.
Signed-off-by: Max R. Carrara <m.carrara@proxmox.com>
---
pbs-tape/src/blocked_reader.rs | 46 +++++++++++++++++-----------------
pbs-tape/src/blocked_writer.rs | 36 +++++++++++++-------------
2 files changed, 41 insertions(+), 41 deletions(-)
diff --git a/pbs-tape/src/blocked_reader.rs b/pbs-tape/src/blocked_reader.rs
index 33c5db780..9ad16c91f 100644
--- a/pbs-tape/src/blocked_reader.rs
+++ b/pbs-tape/src/blocked_reader.rs
@@ -18,7 +18,7 @@ use crate::{
/// the end of the stream).
pub struct BlockedReader<R> {
reader: R,
- buffer: BlockHeader,
+ header: BlockHeader,
seq_nr: u32,
found_end_marker: bool,
incomplete: bool,
@@ -33,24 +33,24 @@ impl<R: BlockRead> BlockedReader<R> {
/// This tries to read the first block. Please inspect the error
/// to detect EOF and EOT.
pub fn open(mut reader: R) -> Result<Self, BlockReadError> {
- let mut buffer = BlockHeader::new()?;
+ let mut header = BlockHeader::new()?;
- Self::read_block_frame(&mut buffer, &mut reader)?;
+ Self::read_block_frame(&mut header, &mut reader)?;
- let (_size, found_end_marker) = Self::check_buffer(&buffer, 0)?;
+ let (_size, found_end_marker) = Self::check_buffer(&header, 0)?;
let mut incomplete = false;
let mut got_eod = false;
if found_end_marker {
- incomplete = buffer.flags().contains(BlockHeaderFlags::INCOMPLETE);
+ incomplete = header.flags().contains(BlockHeaderFlags::INCOMPLETE);
Self::consume_eof_marker(&mut reader)?;
got_eod = true;
}
Ok(Self {
reader,
- buffer,
+ header,
found_end_marker,
incomplete,
got_eod,
@@ -60,29 +60,29 @@ impl<R: BlockRead> BlockedReader<R> {
})
}
- fn check_buffer(buffer: &BlockHeader, seq_nr: u32) -> Result<(usize, bool), std::io::Error> {
- if buffer.magic() != PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0 {
+ fn check_buffer(header: &BlockHeader, seq_nr: u32) -> Result<(usize, bool), std::io::Error> {
+ if header.magic() != PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0 {
proxmox_lang::io_bail!(
"got tape block with unknown magic number - not written by PBS or incompatible LTO version"
);
}
- if seq_nr != buffer.seq_nr() {
+ if seq_nr != header.seq_nr() {
proxmox_lang::io_bail!(
"detected tape block with wrong sequence number ({} != {})",
seq_nr,
- buffer.seq_nr()
+ header.seq_nr()
)
}
- let size = buffer.size();
- let found_end_marker = buffer.flags().contains(BlockHeaderFlags::END_OF_STREAM);
+ let size = header.size();
+ let found_end_marker = header.flags().contains(BlockHeaderFlags::END_OF_STREAM);
- if size > buffer.payload().len() {
+ if size > header.payload().len() {
proxmox_lang::io_bail!(
"detected tape block with wrong payload size ({} > {}",
size,
- buffer.payload().len()
+ header.payload().len()
);
} else if size == 0 && !found_end_marker {
proxmox_lang::io_bail!("detected tape block with zero payload size");
@@ -91,8 +91,8 @@ impl<R: BlockRead> BlockedReader<R> {
Ok((size, found_end_marker))
}
- fn read_block_frame(buffer: &mut BlockHeader, reader: &mut R) -> Result<(), BlockReadError> {
- let bytes = reader.read_block(buffer.as_bytes_mut())?;
+ fn read_block_frame(header: &mut BlockHeader, reader: &mut R) -> Result<(), BlockReadError> {
+ let bytes = reader.read_block(header.as_bytes_mut())?;
if bytes != BlockHeader::SIZE {
return Err(proxmox_lang::io_format_err!("got wrong block size").into());
@@ -116,11 +116,11 @@ impl<R: BlockRead> BlockedReader<R> {
}
fn read_block(&mut self, check_end_marker: bool) -> Result<usize, std::io::Error> {
- match Self::read_block_frame(&mut self.buffer, &mut self.reader) {
+ match Self::read_block_frame(&mut self.header, &mut self.reader) {
Ok(()) => { /* ok */ }
Err(BlockReadError::EndOfFile) => {
self.got_eod = true;
- self.read_pos = self.buffer.payload().len();
+ self.read_pos = self.header.payload().len();
if !self.found_end_marker && check_end_marker {
proxmox_lang::io_bail!("detected tape stream without end marker");
}
@@ -134,13 +134,13 @@ impl<R: BlockRead> BlockedReader<R> {
}
}
- let (size, found_end_marker) = Self::check_buffer(&self.buffer, self.seq_nr)?;
+ let (size, found_end_marker) = Self::check_buffer(&self.header, self.seq_nr)?;
self.seq_nr += 1;
if found_end_marker {
// consume EOF mark
self.found_end_marker = true;
- self.incomplete = self.buffer.flags().contains(BlockHeaderFlags::INCOMPLETE);
+ self.incomplete = self.header.flags().contains(BlockHeaderFlags::INCOMPLETE);
Self::consume_eof_marker(&mut self.reader)?;
self.got_eod = true;
}
@@ -175,7 +175,7 @@ impl<R: BlockRead> TapeRead for BlockedReader<R> {
// stream has no end marker.
fn skip_data(&mut self) -> Result<usize, std::io::Error> {
let mut bytes = 0;
- let buffer_size = self.buffer.size();
+ let buffer_size = self.header.size();
let rest = (buffer_size as isize) - (self.read_pos as isize);
if rest > 0 {
bytes = rest as usize;
@@ -195,7 +195,7 @@ impl<R: BlockRead> Read for BlockedReader<R> {
proxmox_lang::io_bail!("detected read after error - internal error");
}
- let mut buffer_size = self.buffer.size();
+ let mut buffer_size = self.header.size();
let mut rest = (buffer_size as isize) - (self.read_pos as isize);
if rest <= 0 && !self.got_eod {
@@ -220,7 +220,7 @@ impl<R: BlockRead> Read for BlockedReader<R> {
};
let (read_start, read_end) = (self.read_pos, self.read_pos + copy_len);
- let payload = self.buffer.payload();
+ let payload = self.header.payload();
buffer[..copy_len].copy_from_slice(&payload[read_start..read_end]);
self.read_pos += copy_len;
diff --git a/pbs-tape/src/blocked_writer.rs b/pbs-tape/src/blocked_writer.rs
index 57721ed4a..6ca621716 100644
--- a/pbs-tape/src/blocked_writer.rs
+++ b/pbs-tape/src/blocked_writer.rs
@@ -9,7 +9,7 @@ use crate::{BlockHeader, BlockHeaderFlags, BlockWrite, TapeWrite};
/// to the underlying writer.
pub struct BlockedWriter<W: BlockWrite> {
writer: W,
- buffer: BlockHeader,
+ header: BlockHeader,
buffer_pos: usize,
seq_nr: u32,
logical_end_of_media: bool,
@@ -36,7 +36,7 @@ impl<W: BlockWrite> BlockedWriter<W> {
pub fn new(writer: W) -> Self {
Self {
writer,
- buffer: BlockHeader::new().expect("failed to create block header"),
+ header: BlockHeader::new().expect("failed to create block header"),
buffer_pos: 0,
seq_nr: 0,
logical_end_of_media: false,
@@ -45,8 +45,8 @@ impl<W: BlockWrite> BlockedWriter<W> {
}
}
- fn write_block(buffer: &BlockHeader, writer: &mut W) -> Result<bool, std::io::Error> {
- writer.write_block(buffer.as_bytes())
+ fn write_block(header: &BlockHeader, writer: &mut W) -> Result<bool, std::io::Error> {
+ writer.write_block(header.as_bytes())
}
fn write_eof(&mut self) -> Result<(), std::io::Error> {
@@ -63,23 +63,23 @@ impl<W: BlockWrite> BlockedWriter<W> {
return Ok(0);
}
- let rest = self.buffer.payload().len() - self.buffer_pos;
+ let rest = self.header.payload().len() - self.buffer_pos;
let bytes = if data.len() < rest { data.len() } else { rest };
let (write_start, write_end) = (self.buffer_pos, self.buffer_pos + bytes);
- let payload = self.buffer.payload_mut();
+ let payload = self.header.payload_mut();
payload[write_start..write_end].copy_from_slice(&data[..bytes]);
let rest = rest - bytes;
if rest == 0 {
- self.buffer.set_flags(BlockHeaderFlags::empty());
- let payload_len = self.buffer.payload().len();
- self.buffer.set_size(payload_len);
- self.buffer.set_seq_nr(self.seq_nr);
+ self.header.set_flags(BlockHeaderFlags::empty());
+ let payload_len = self.header.payload().len();
+ self.header.set_size(payload_len);
+ self.header.set_seq_nr(self.seq_nr);
self.seq_nr += 1;
- let leom = Self::write_block(&self.buffer, &mut self.writer)?;
+ let leom = Self::write_block(&self.header, &mut self.writer)?;
if leom {
self.logical_end_of_media = true;
}
@@ -113,19 +113,19 @@ 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> {
- let payload = self.buffer.payload_mut();
+ let payload = self.header.payload_mut();
vec::clear(&mut payload[self.buffer_pos..]);
- self.buffer.set_flags(BlockHeaderFlags::END_OF_STREAM);
+ self.header.set_flags(BlockHeaderFlags::END_OF_STREAM);
if incomplete {
- let flags = self.buffer.flags() | BlockHeaderFlags::INCOMPLETE;
- self.buffer.set_flags(flags);
+ let flags = self.header.flags() | BlockHeaderFlags::INCOMPLETE;
+ self.header.set_flags(flags);
}
- self.buffer.set_size(self.buffer_pos);
- self.buffer.set_seq_nr(self.seq_nr);
+ self.header.set_size(self.buffer_pos);
+ self.header.set_seq_nr(self.seq_nr);
self.seq_nr += 1;
self.bytes_written += BlockHeader::SIZE;
- let leom = Self::write_block(&self.buffer, &mut self.writer)?;
+ let leom = Self::write_block(&self.header, &mut self.writer)?;
self.write_eof()?;
Ok(leom)
}
--
2.47.3
prev parent reply other threads:[~2026-08-05 14:16 UTC|newest]
Thread overview: 3+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-08-05 14:16 [PATCH proxmox-backup 0/2] Fix Undefined Behavior in Tape Block Header Deallocation Max R. Carrara
2026-08-05 14:16 ` [PATCH proxmox-backup 1/2] pbs-tape: fix undefined behavior in block header deallocation Max R. Carrara
2026-08-05 14:16 ` Max R. Carrara [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260805141620.4190773-3-m.carrara@proxmox.com \
--to=m.carrara@proxmox.com \
--cc=pbs-devel@lists.proxmox.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox