From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from gate001.proxmox.com (gate001.proxmox.com [IPv6:2a0f:8001:1:32::40]) by lore.proxmox.com (Postfix) with ESMTPS id BC5F41FF12C for ; Wed, 05 Aug 2026 16:14:38 +0200 (CEST) Received: from gate001.proxmox.com (localhost.localdomain [127.0.0.1]) by gate001.proxmox.com (Proxmox) with ESMTP id B8391219EC; Wed, 05 Aug 2026 16:14:33 +0200 (CEST) From: "Max R. Carrara" To: pve-devel@lists.proxmox.com Subject: [PATCH proxmox-backup 2/2] pbs-tape: rename `buffer` to `header` Date: Wed, 5 Aug 2026 16:13:28 +0200 Message-ID: <20260805141422.4187158-3-m.carrara@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260805141422.4187158-1-m.carrara@proxmox.com> References: <20260805141422.4187158-1-m.carrara@proxmox.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Bm-Milter-Handled: 55990f41-d878-4baa-be0a-ee34c49e34d2 X-Bm-Transport-Timestamp: 1785939252850 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.023 Adjusted score from AWL reputation of From: address DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment (newer systems) RCVD_IN_DNSWL_LOW -0.7 Sender listed at https://www.dnswl.org/, low trust SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record Message-ID-Hash: VI5LMEDSLPXOTCNA3CRRWVRNPG4E66AM X-Message-ID-Hash: VI5LMEDSLPXOTCNA3CRRWVRNPG4E66AM X-MailFrom: m.carrara@proxmox.com X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; loop; banned-address; emergency; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header X-Mailman-Version: 3.3.10 Precedence: list List-Id: Proxmox VE development discussion List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: ... since `BlockHeader` is now a smart pointer. Signed-off-by: Max R. Carrara --- 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 { reader: R, - buffer: BlockHeader, + header: BlockHeader, seq_nr: u32, found_end_marker: bool, incomplete: bool, @@ -33,24 +33,24 @@ impl BlockedReader { /// This tries to read the first block. Please inspect the error /// to detect EOF and EOT. pub fn open(mut reader: R) -> Result { - 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 BlockedReader { }) } - 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 BlockedReader { 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 BlockedReader { } fn read_block(&mut self, check_end_marker: bool) -> Result { - 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 BlockedReader { } } - 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 TapeRead for BlockedReader { // stream has no end marker. fn skip_data(&mut self) -> Result { 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 Read for BlockedReader { 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 Read for BlockedReader { }; 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 { writer: W, - buffer: BlockHeader, + header: BlockHeader, buffer_pos: usize, seq_nr: u32, logical_end_of_media: bool, @@ -36,7 +36,7 @@ impl BlockedWriter { 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 BlockedWriter { } } - fn write_block(buffer: &BlockHeader, writer: &mut W) -> Result { - writer.write_block(buffer.as_bytes()) + fn write_block(header: &BlockHeader, writer: &mut W) -> Result { + writer.write_block(header.as_bytes()) } fn write_eof(&mut self) -> Result<(), std::io::Error> { @@ -63,23 +63,23 @@ impl BlockedWriter { 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 TapeWrite for BlockedWriter { /// Note: This may write an empty block just including the /// END_OF_STREAM flag. fn finish(&mut self, incomplete: bool) -> Result { - 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