tyler/proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

use io_format_err, io_bail, io_err_other from proxmox-lang

Browse Source 
and move the comment from the local io_bail in pbs-client/src/pxar/fuse.rs
to the only use

Signed-off-by: Dominik Csapak <d.csapak@proxmox.com>
Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>
This commit is contained in:
Dominik Csapak 2022-02-21 11:39:18 +01:00 committed by Wolfgang Bumiller
parent b066586a47
commit f26d7ca5c5
16 changed files with 59 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
pbs-client/src/pxar/fuse.rs
View File

@ -25,6 +25,7 @@ use pxar::accessor::{self, EntryRangeInfo, ReadAt};
use proxmox_fuse::requests::{self, FuseRequest}; use proxmox_fuse::requests::{self, FuseRequest};
use proxmox_fuse::{EntryParam, Fuse, ReplyBufState, Request, ROOT_ID}; use proxmox_fuse::{EntryParam, Fuse, ReplyBufState, Request, ROOT_ID};
use proxmox_lang::io_format_err;
use proxmox_sys::fs::xattr; use proxmox_sys::fs::xattr;
/// We mark inodes for regular files this way so we know how to access them. /// We mark inodes for regular files this way so we know how to access them.
@ -110,20 +111,6 @@ macro_rules! io_return {
}}; }};
} }
/// Format an "other" error, see `io_bail` below for details.
macro_rules! io_format_err {
($($fmt:tt)*) => {
::std::io::Error::new(::std::io::ErrorKind::Other, format!($($fmt)*))
}
}
/// We use this to bail out of a functionin an unexpected error case. This will cause the fuse
/// request to be answered with a generic `EIO` error code. The error message contained in here
/// will be printed to stdout if the verbose flag is used, otherwise silently dropped.
macro_rules! io_bail {
($($fmt:tt)*) => { return Err(io_format_err!($($fmt)*).into()); }
}
/// This is what we need to cache as a "lookup" entry. The kernel assumes that these are easily /// This is what we need to cache as a "lookup" entry. The kernel assumes that these are easily
/// accessed. /// accessed.
struct Lookup { struct Lookup {
@ -157,7 +144,10 @@ impl Lookup {
loop { loop {
let old = self.refs.load(Ordering::Acquire); let old = self.refs.load(Ordering::Acquire);
if count >= old { if count >= old {
io_bail!("reference count underflow"); // We use this to bail out of a functionin an unexpected error case. This will cause the fuse
// request to be answered with a generic `EIO` error code. The error message contained in here
// will be printed to stdout if the verbose flag is used, otherwise silently dropped.
return Err(io_format_err!("reference count underflow").into());
} }
let new = old - count; let new = old - count;
match self match self

4
pbs-datastore/src/cached_chunk_reader.rs
View File

@ -10,8 +10,8 @@ use anyhow::Error;
use futures::ready; use futures::ready;
use tokio::io::{AsyncRead, AsyncSeek, ReadBuf}; use tokio::io::{AsyncRead, AsyncSeek, ReadBuf};
use proxmox_sys::io_format_err; use proxmox_lang::io_format_err;
use proxmox_sys::error::io_err_other; use proxmox_lang::error::io_err_other;
use pbs_tools::async_lru_cache::{AsyncCacher, AsyncLruCache}; use pbs_tools::async_lru_cache::{AsyncCacher, AsyncLruCache};

26
pbs-tape/src/blocked_reader.rs
View File

@ -69,11 +69,11 @@ impl <R: BlockRead> BlockedReader<R> {
fn check_buffer(buffer: &BlockHeader, seq_nr: u32) -> Result<(usize, bool), std::io::Error> { fn check_buffer(buffer: &BlockHeader, seq_nr: u32) -> Result<(usize, bool), std::io::Error> {
if buffer.magic != PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0 { if buffer.magic != PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0 {
proxmox_sys::io_bail!("detected tape block with wrong magic number - not written by proxmox tape"); proxmox_lang::io_bail!("detected tape block with wrong magic number - not written by proxmox tape");
} }
if seq_nr != buffer.seq_nr() { if seq_nr != buffer.seq_nr() {
proxmox_sys::io_bail!( proxmox_lang::io_bail!(
"detected tape block with wrong sequence number ({} != {})", "detected tape block with wrong sequence number ({} != {})",
seq_nr, buffer.seq_nr()) seq_nr, buffer.seq_nr())
} }
@ -82,9 +82,9 @@ impl <R: BlockRead> BlockedReader<R> {
let found_end_marker = buffer.flags.contains(BlockHeaderFlags::END_OF_STREAM); let found_end_marker = buffer.flags.contains(BlockHeaderFlags::END_OF_STREAM);
if size > buffer.payload.len() { if size > buffer.payload.len() {
proxmox_sys::io_bail!("detected tape block with wrong payload size ({} > {}", size, buffer.payload.len()); proxmox_lang::io_bail!("detected tape block with wrong payload size ({} > {}", size, buffer.payload.len());
} else if size == 0 && !found_end_marker { } else if size == 0 && !found_end_marker {
proxmox_sys::io_bail!("detected tape block with zero payload size"); proxmox_lang::io_bail!("detected tape block with zero payload size");
} }
@ -103,7 +103,7 @@ impl <R: BlockRead> BlockedReader<R> {
let bytes = reader.read_block(data)?; let bytes = reader.read_block(data)?;
if bytes != BlockHeader::SIZE { if bytes != BlockHeader::SIZE {
return Err(proxmox_sys::io_format_err!("got wrong block size").into()); return Err(proxmox_lang::io_format_err!("got wrong block size").into());
} }
Ok(()) Ok(())
@ -113,13 +113,13 @@ impl <R: BlockRead> BlockedReader<R> {
let mut tmp_buf = [0u8; 512]; // use a small buffer for testing EOF let mut tmp_buf = [0u8; 512]; // use a small buffer for testing EOF
match reader.read_block(&mut tmp_buf) { match reader.read_block(&mut tmp_buf) {
Ok(_) => { Ok(_) => {
proxmox_sys::io_bail!("detected tape block after block-stream end marker"); proxmox_lang::io_bail!("detected tape block after block-stream end marker");
} }
Err(BlockReadError::EndOfFile) => { Err(BlockReadError::EndOfFile) => {
Ok(()) Ok(())
} }
Err(BlockReadError::EndOfStream) => { Err(BlockReadError::EndOfStream) => {
proxmox_sys::io_bail!("got unexpected end of tape"); proxmox_lang::io_bail!("got unexpected end of tape");
} }
Err(BlockReadError::Error(err)) => { Err(BlockReadError::Error(err)) => {
Err(err) Err(err)
@ -135,12 +135,12 @@ impl <R: BlockRead> BlockedReader<R> {
self.got_eod = true; self.got_eod = true;
self.read_pos = self.buffer.payload.len(); self.read_pos = self.buffer.payload.len();
if !self.found_end_marker && check_end_marker { if !self.found_end_marker && check_end_marker {
proxmox_sys::io_bail!("detected tape stream without end marker"); proxmox_lang::io_bail!("detected tape stream without end marker");
} }
return Ok(0); // EOD return Ok(0); // EOD
} }
Err(BlockReadError::EndOfStream) => { Err(BlockReadError::EndOfStream) => {
proxmox_sys::io_bail!("got unexpected end of tape"); proxmox_lang::io_bail!("got unexpected end of tape");
} }
Err(BlockReadError::Error(err)) => { Err(BlockReadError::Error(err)) => {
return Err(err); return Err(err);
@ -167,10 +167,10 @@ impl <R: BlockRead> TapeRead for BlockedReader<R> {
fn is_incomplete(&self) -> Result<bool, std::io::Error> { fn is_incomplete(&self) -> Result<bool, std::io::Error> {
if !self.got_eod { if !self.got_eod {
proxmox_sys::io_bail!("is_incomplete failed: EOD not reached"); proxmox_lang::io_bail!("is_incomplete failed: EOD not reached");
} }
if !self.found_end_marker { if !self.found_end_marker {
proxmox_sys::io_bail!("is_incomplete failed: no end marker found"); proxmox_lang::io_bail!("is_incomplete failed: no end marker found");
} }
Ok(self.incomplete) Ok(self.incomplete)
@ -178,7 +178,7 @@ impl <R: BlockRead> TapeRead for BlockedReader<R> {
fn has_end_marker(&self) -> Result<bool, std::io::Error> { fn has_end_marker(&self) -> Result<bool, std::io::Error> {
if !self.got_eod { if !self.got_eod {
proxmox_sys::io_bail!("has_end_marker failed: EOD not reached"); proxmox_lang::io_bail!("has_end_marker failed: EOD not reached");
} }
Ok(self.found_end_marker) Ok(self.found_end_marker)
@ -207,7 +207,7 @@ impl <R: BlockRead> Read for BlockedReader<R> {
fn read(&mut self, buffer: &mut [u8]) -> Result<usize, std::io::Error> { fn read(&mut self, buffer: &mut [u8]) -> Result<usize, std::io::Error> {
if self.read_error { if self.read_error {
proxmox_sys::io_bail!("detected read after error - internal error"); proxmox_lang::io_bail!("detected read after error - internal error");
} }
let mut buffer_size = self.buffer.size(); let mut buffer_size = self.buffer.size();

2
pbs-tape/src/blocked_writer.rs
View File

@ -65,7 +65,7 @@ impl <W: BlockWrite> BlockedWriter<W> {
fn write_eof(&mut self) -> Result<(), std::io::Error> { fn write_eof(&mut self) -> Result<(), std::io::Error> {
if self.wrote_eof { if self.wrote_eof {
proxmox_sys::io_bail!("BlockedWriter: detected multiple EOF writes"); proxmox_lang::io_bail!("BlockedWriter: detected multiple EOF writes");
} }
self.wrote_eof = true; self.wrote_eof = true;

4
pbs-tape/src/emulate_tape_reader.rs
View File

@ -22,7 +22,7 @@ impl <R: Read> EmulateTapeReader<R> {
impl <R: Read> BlockRead for EmulateTapeReader<R> { impl <R: Read> BlockRead for EmulateTapeReader<R> {
fn read_block(&mut self, buffer: &mut [u8]) -> Result<usize, BlockReadError> { fn read_block(&mut self, buffer: &mut [u8]) -> Result<usize, BlockReadError> {
if self.got_eof { if self.got_eof {
return Err(BlockReadError::Error(proxmox_sys::io_format_err!("detected read after EOF!"))); return Err(BlockReadError::Error(proxmox_lang::io_format_err!("detected read after EOF!")));
} }
match self.reader.read_exact_or_eof(buffer)? { match self.reader.read_exact_or_eof(buffer)? {
false => { false => {
@ -33,7 +33,7 @@ impl <R: Read> BlockRead for EmulateTapeReader<R> {
// test buffer len after EOF test (to allow EOF test with small buffers in BufferedReader) // test buffer len after EOF test (to allow EOF test with small buffers in BufferedReader)
if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE { if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE {
return Err(BlockReadError::Error( return Err(BlockReadError::Error(
proxmox_sys::io_format_err!( proxmox_lang::io_format_err!(
"EmulateTapeReader: read_block with wrong block size ({} != {})", "EmulateTapeReader: read_block with wrong block size ({} != {})",
buffer.len(), buffer.len(),
PROXMOX_TAPE_BLOCK_SIZE, PROXMOX_TAPE_BLOCK_SIZE,

4
pbs-tape/src/emulate_tape_writer.rs
View File

@ -39,7 +39,7 @@ impl <W: Write> BlockWrite for EmulateTapeWriter<W> {
fn write_block(&mut self, buffer: &[u8]) -> Result<bool, io::Error> { fn write_block(&mut self, buffer: &[u8]) -> Result<bool, io::Error> {
if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE { if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE {
proxmox_sys::io_bail!("EmulateTapeWriter: got write with wrong block size ({} != {}", proxmox_lang::io_bail!("EmulateTapeWriter: got write with wrong block size ({} != {}",
buffer.len(), PROXMOX_TAPE_BLOCK_SIZE); buffer.len(), PROXMOX_TAPE_BLOCK_SIZE);
} }
@ -59,7 +59,7 @@ impl <W: Write> BlockWrite for EmulateTapeWriter<W> {
fn write_filemark(&mut self) -> Result<(), std::io::Error> { fn write_filemark(&mut self) -> Result<(), std::io::Error> {
if self.wrote_eof { if self.wrote_eof {
proxmox_sys::io_bail!("EmulateTapeWriter: detected multiple EOF writes"); proxmox_lang::io_bail!("EmulateTapeWriter: detected multiple EOF writes");
} }
// do nothing, just record the call // do nothing, just record the call
self.wrote_eof = true; self.wrote_eof = true;

18
pbs-tape/src/sg_tape.rs
View File

@ -528,11 +528,11 @@ impl SgTape {
) -> Result<(), std::io::Error> { ) -> Result<(), std::io::Error> {
if count > 255 { if count > 255 {
proxmox_sys::io_bail!("write_filemarks failed: got strange count '{}'", count); proxmox_lang::io_bail!("write_filemarks failed: got strange count '{}'", count);
} }
let mut sg_raw = SgRaw::new(&mut self.file, 16) let mut sg_raw = SgRaw::new(&mut self.file, 16)
.map_err(|err| proxmox_sys::io_format_err!("write_filemarks failed (alloc) - {}", err))?; .map_err(|err| proxmox_lang::io_format_err!("write_filemarks failed (alloc) - {}", err))?;
sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT); sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
let mut cmd = Vec::new(); let mut cmd = Vec::new();
@ -551,7 +551,7 @@ impl SgTape {
/* LEOM - ignore */ /* LEOM - ignore */
} }
Err(err) => { Err(err) => {
proxmox_sys::io_bail!("write filemark failed - {}", err); proxmox_lang::io_bail!("write filemark failed - {}", err);
} }
} }
@ -630,7 +630,7 @@ impl SgTape {
let transfer_len = data.len(); let transfer_len = data.len();
if transfer_len > 0x800000 { if transfer_len > 0x800000 {
proxmox_sys::io_bail!("write failed - data too large"); proxmox_lang::io_bail!("write failed - data too large");
} }
let mut sg_raw = SgRaw::new(&mut self.file, 0) let mut sg_raw = SgRaw::new(&mut self.file, 0)
@ -654,7 +654,7 @@ impl SgTape {
Ok(true) // LEOM Ok(true) // LEOM
} }
Err(err) => { Err(err) => {
proxmox_sys::io_bail!("write failed - {}", err); proxmox_lang::io_bail!("write failed - {}", err);
} }
} }
} }
@ -664,7 +664,7 @@ impl SgTape {
if transfer_len > 0xFFFFFF { if transfer_len > 0xFFFFFF {
return Err(BlockReadError::Error( return Err(BlockReadError::Error(
proxmox_sys::io_format_err!("read failed - buffer too large") proxmox_lang::io_format_err!("read failed - buffer too large")
)); ));
} }
@ -691,14 +691,14 @@ impl SgTape {
} }
Err(err) => { Err(err) => {
return Err(BlockReadError::Error( return Err(BlockReadError::Error(
proxmox_sys::io_format_err!("read failed - {}", err) proxmox_lang::io_format_err!("read failed - {}", err)
)); ));
} }
}; };
if data.len() != transfer_len { if data.len() != transfer_len {
return Err(BlockReadError::Error( return Err(BlockReadError::Error(
proxmox_sys::io_format_err!("read failed - unexpected block len ({} != {})", data.len(), buffer.len()) proxmox_lang::io_format_err!("read failed - unexpected block len ({} != {})", data.len(), buffer.len())
)); ));
} }
@ -949,7 +949,7 @@ impl <'a> BlockRead for SgTapeReader<'a> {
fn read_block(&mut self, buffer: &mut [u8]) -> Result<usize, BlockReadError> { fn read_block(&mut self, buffer: &mut [u8]) -> Result<usize, BlockReadError> {
if self.end_of_file { if self.end_of_file {
return Err(BlockReadError::Error(proxmox_sys::io_format_err!("detected read after EOF!"))); return Err(BlockReadError::Error(proxmox_lang::io_format_err!("detected read after EOF!")));
} }
match self.sg_tape.read_block(buffer) { match self.sg_tape.read_block(buffer) {
Ok(usize) => Ok(usize), Ok(usize) => Ok(usize),

2
pbs-tape/src/tape_write.rs
View File

@ -34,7 +34,7 @@ pub trait TapeWrite {
data: &[u8], data: &[u8],
) -> Result<bool, std::io::Error> { ) -> Result<bool, std::io::Error> {
if header.size as usize != data.len() { if header.size as usize != data.len() {
proxmox_sys::io_bail!("write_header with wrong size - internal error"); proxmox_lang::io_bail!("write_header with wrong size - internal error");
} }
let header = header.to_le(); let header = header.to_le();

2
proxmox-rest-server/src/rest.rs
View File

@ -476,7 +476,7 @@ pub(crate) async fn handle_api_request<Env: RpcEnvironment, S: 'static + BuildHa
resp.map(|body| { resp.map(|body| {
Body::wrap_stream(DeflateEncoder::with_quality( Body::wrap_stream(DeflateEncoder::with_quality(
TryStreamExt::map_err(body, |err| { TryStreamExt::map_err(body, |err| {
proxmox_sys::io_format_err!("error during compression: {}", err) proxmox_lang::io_format_err!("error during compression: {}", err)
}), }),
Level::Default, Level::Default,
)) ))

4
src/tape/drive/virtual_tape.rs
View File

@ -309,7 +309,7 @@ impl TapeDriver for VirtualTapeHandle {
Ok(Box::new(reader)) Ok(Box::new(reader))
} }
None => { None => {
return Err(BlockReadError::Error(proxmox_sys::io_format_err!("drive is empty (no tape loaded)."))); return Err(BlockReadError::Error(proxmox_lang::io_format_err!("drive is empty (no tape loaded).")));
} }
} }
} }
@ -362,7 +362,7 @@ impl TapeDriver for VirtualTapeHandle {
Ok(writer) Ok(writer)
} }
None => proxmox_sys::io_bail!("drive is empty (no tape loaded)."), None => proxmox_lang::io_bail!("drive is empty (no tape loaded)."),
} }
} }

4
src/tape/file_formats/catalog_archive.rs
View File

@ -61,13 +61,13 @@ pub fn tape_write_catalog<'a>(
while remaining != 0 { while remaining != 0 {
let got = file.read(&mut file_copy_buffer[..])?; let got = file.read(&mut file_copy_buffer[..])?;
if got as u64 > remaining { if got as u64 > remaining {
proxmox_sys::io_bail!("catalog '{}' changed while reading", uuid); proxmox_lang::io_bail!("catalog '{}' changed while reading", uuid);
} }
writer.write_all(&file_copy_buffer[..got])?; writer.write_all(&file_copy_buffer[..got])?;
remaining -= got as u64; remaining -= got as u64;
} }
if remaining > 0 { if remaining > 0 {
proxmox_sys::io_bail!("catalog '{}' shrunk while reading", uuid); proxmox_lang::io_bail!("catalog '{}' shrunk while reading", uuid);
} }
Ok(()) Ok(())
}); });

2
src/tape/file_formats/chunk_archive.rs
View File

@ -69,7 +69,7 @@ impl <'a> ChunkArchiveWriter<'a> {
fn write_all(&mut self, data: &[u8]) -> Result<bool, std::io::Error> { fn write_all(&mut self, data: &[u8]) -> Result<bool, std::io::Error> {
match self.writer { match self.writer {
Some(ref mut writer) => writer.write_all(data), Some(ref mut writer) => writer.write_all(data),
None => proxmox_sys::io_bail!( None => proxmox_lang::io_bail!(
"detected write after archive finished - internal error"), "detected write after archive finished - internal error"),
} }
} }

10
src/tape/file_formats/multi_volume_reader.rs
View File

@ -48,23 +48,23 @@ impl <'a> Read for MultiVolumeReader<'a> {
if self.reader.is_none() { if self.reader.is_none() {
let mut reader = (self.next_reader_fn)() let mut reader = (self.next_reader_fn)()
.map_err(|err| proxmox_sys::io_format_err!("multi-volume next failed: {}", err))?; .map_err(|err| proxmox_lang::io_format_err!("multi-volume next failed: {}", err))?;
proxmox_lang::try_block!({ proxmox_lang::try_block!({
let part_header: MediaContentHeader = unsafe { reader.read_le_value()? }; let part_header: MediaContentHeader = unsafe { reader.read_le_value()? };
self.reader = Some(reader); self.reader = Some(reader);
if part_header.uuid != self.header.uuid { if part_header.uuid != self.header.uuid {
proxmox_sys::io_bail!("got wrong part uuid"); proxmox_lang::io_bail!("got wrong part uuid");
} }
if part_header.content_magic!= self.header.content_magic { if part_header.content_magic!= self.header.content_magic {
proxmox_sys::io_bail!("got wrong part content magic"); proxmox_lang::io_bail!("got wrong part content magic");
} }
let expect_part_number = self.header.part_number + 1; let expect_part_number = self.header.part_number + 1;
if part_header.part_number != expect_part_number { if part_header.part_number != expect_part_number {
proxmox_sys::io_bail!("got wrong part number ({} != {})", proxmox_lang::io_bail!("got wrong part number ({} != {})",
part_header.part_number, expect_part_number); part_header.part_number, expect_part_number);
} }
@ -72,7 +72,7 @@ impl <'a> Read for MultiVolumeReader<'a> {
Ok(()) Ok(())
}).map_err(|err| { }).map_err(|err| {
proxmox_sys::io_format_err!("multi-volume read content header failed: {}", err) proxmox_lang::io_format_err!("multi-volume read content header failed: {}", err)
})?; })?;
} }

14
src/tape/file_formats/multi_volume_writer.rs
View File

@ -53,16 +53,16 @@ impl <'a> TapeWrite for MultiVolumeWriter<'a> {
fn write_all(&mut self, buf: &[u8]) -> Result<bool, std::io::Error> { fn write_all(&mut self, buf: &[u8]) -> Result<bool, std::io::Error> {
if self.finished { if self.finished {
proxmox_sys::io_bail!("multi-volume writer already finished: internal error"); proxmox_lang::io_bail!("multi-volume writer already finished: internal error");
} }
if self.got_leom { if self.got_leom {
if !self.wrote_header { if !self.wrote_header {
proxmox_sys::io_bail!("multi-volume writer: got LEOM before writing anything - internal error"); proxmox_lang::io_bail!("multi-volume writer: got LEOM before writing anything - internal error");
} }
let mut writer = match self.writer.take() { let mut writer = match self.writer.take() {
Some(writer) => writer, Some(writer) => writer,
None => proxmox_sys::io_bail!("multi-volume writer: no writer -internal error"), None => proxmox_lang::io_bail!("multi-volume writer: no writer -internal error"),
}; };
self.bytes_written = writer.bytes_written(); self.bytes_written = writer.bytes_written();
writer.finish(true)?; writer.finish(true)?;
@ -70,11 +70,11 @@ impl <'a> TapeWrite for MultiVolumeWriter<'a> {
if self.writer.is_none() { if self.writer.is_none() {
if self.header.part_number == u8::MAX { if self.header.part_number == u8::MAX {
proxmox_sys::io_bail!("multi-volume writer: too many parts"); proxmox_lang::io_bail!("multi-volume writer: too many parts");
} }
self.writer = Some( self.writer = Some(
(self.next_writer_fn)() (self.next_writer_fn)()
.map_err(|err| proxmox_sys::io_format_err!("multi-volume get next volume failed: {}", err))? .map_err(|err| proxmox_lang::io_format_err!("multi-volume get next volume failed: {}", err))?
); );
self.got_leom = false; self.got_leom = false;
self.wrote_header = false; self.wrote_header = false;
@ -107,12 +107,12 @@ impl <'a> TapeWrite for MultiVolumeWriter<'a> {
fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error> { fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error> {
if incomplete { if incomplete {
proxmox_sys::io_bail!( proxmox_lang::io_bail!(
"incomplete flag makes no sense for multi-volume stream: internal error"); "incomplete flag makes no sense for multi-volume stream: internal error");
} }
match self.writer.take() { match self.writer.take() {
None if self.finished => proxmox_sys::io_bail!( None if self.finished => proxmox_lang::io_bail!(
"multi-volume writer already finished: internal error"), "multi-volume writer already finished: internal error"),
None => Ok(false), None => Ok(false),
Some(ref mut writer) => { Some(ref mut writer) => {

8
src/tape/file_formats/snapshot_archive.rs
View File

@ -58,14 +58,14 @@ pub fn tape_write_snapshot_archive<'a>(
for filename in file_list.iter() { for filename in file_list.iter() {
let mut file = snapshot_reader.open_file(filename) let mut file = snapshot_reader.open_file(filename)
.map_err(|err| proxmox_sys::io_format_err!("open file '{}' failed - {}", filename, err))?; .map_err(|err| proxmox_lang::io_format_err!("open file '{}' failed - {}", filename, err))?;
let metadata = file.metadata()?; let metadata = file.metadata()?;
let file_size = metadata.len(); let file_size = metadata.len();
let metadata: pxar::Metadata = metadata.into(); let metadata: pxar::Metadata = metadata.into();
if !metadata.is_regular_file() { if !metadata.is_regular_file() {
proxmox_sys::io_bail!("file '{}' is not a regular file", filename); proxmox_lang::io_bail!("file '{}' is not a regular file", filename);
} }
let mut remaining = file_size; let mut remaining = file_size;
@ -73,14 +73,14 @@ pub fn tape_write_snapshot_archive<'a>(
while remaining != 0 { while remaining != 0 {
let got = file.read(&mut file_copy_buffer[..])?; let got = file.read(&mut file_copy_buffer[..])?;
if got as u64 > remaining { if got as u64 > remaining {
proxmox_sys::io_bail!("file '{}' changed while reading", filename); proxmox_lang::io_bail!("file '{}' changed while reading", filename);
} }
out.write_all(&file_copy_buffer[..got])?; out.write_all(&file_copy_buffer[..got])?;
remaining -= got as u64; remaining -= got as u64;
} }
if remaining > 0 { if remaining > 0 {
proxmox_sys::io_bail!("file '{}' shrunk while reading", filename); proxmox_lang::io_bail!("file '{}' shrunk while reading", filename);
} }
} }
encoder.finish()?; encoder.finish()?;

4
src/tools/disks/mod.rs
View File

@ -15,9 +15,9 @@ use once_cell::sync::OnceCell;
use ::serde::{Deserialize, Serialize}; use ::serde::{Deserialize, Serialize};
use proxmox_schema::api; use proxmox_schema::api;
use proxmox_sys::error::io_err_other; use proxmox_lang::error::io_err_other;
use proxmox_sys::linux::procfs::{mountinfo::Device, MountInfo}; use proxmox_sys::linux::procfs::{mountinfo::Device, MountInfo};
use proxmox_sys::{io_bail, io_format_err}; use proxmox_lang::{io_bail, io_format_err};
use pbs_api_types::{StorageStatus, BLOCKDEVICE_NAME_REGEX}; use pbs_api_types::{StorageStatus, BLOCKDEVICE_NAME_REGEX};