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
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::{EntryParam, Fuse, ReplyBufState, Request, ROOT_ID};
use proxmox_lang::io_format_err;
use proxmox_sys::fs::xattr;
/// 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
/// accessed.
struct Lookup {
@ -157,7 +144,10 @@ impl Lookup {
loop {
let old = self.refs.load(Ordering::Acquire);
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;
match self

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

@ -10,8 +10,8 @@ use anyhow::Error;
use futures::ready;
use tokio::io::{AsyncRead, AsyncSeek, ReadBuf};
use proxmox_sys::io_format_err;
use proxmox_sys::error::io_err_other;
use proxmox_lang::io_format_err;
use proxmox_lang::error::io_err_other;
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> {
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() {
proxmox_sys::io_bail!(
proxmox_lang::io_bail!(
"detected tape block with wrong sequence number ({} != {})",
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);
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 {
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)?;
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(())
@ -113,13 +113,13 @@ impl <R: BlockRead> BlockedReader<R> {
let mut tmp_buf = [0u8; 512]; // use a small buffer for testing EOF
match reader.read_block(&mut tmp_buf) {
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) => {
Ok(())
}
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(err)
@ -135,12 +135,12 @@ impl <R: BlockRead> BlockedReader<R> {
self.got_eod = true;
self.read_pos = self.buffer.payload.len();
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
}
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)) => {
return Err(err);
@ -167,10 +167,10 @@ impl <R: BlockRead> TapeRead for BlockedReader<R> {
fn is_incomplete(&self) -> Result<bool, std::io::Error> {
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 {
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)
@ -178,7 +178,7 @@ impl <R: BlockRead> TapeRead for BlockedReader<R> {
fn has_end_marker(&self) -> Result<bool, std::io::Error> {
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)
@ -207,7 +207,7 @@ impl <R: BlockRead> Read for BlockedReader<R> {
fn read(&mut self, buffer: &mut [u8]) -> Result<usize, std::io::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();

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> {
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;

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> {
fn read_block(&mut self, buffer: &mut [u8]) -> Result<usize, BlockReadError> {
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)? {
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)
if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE {
return Err(BlockReadError::Error(
proxmox_sys::io_format_err!(
proxmox_lang::io_format_err!(
"EmulateTapeReader: read_block with wrong block size ({} != {})",
buffer.len(),
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> {
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);
}
@ -59,7 +59,7 @@ impl <W: Write> BlockWrite for EmulateTapeWriter<W> {
fn write_filemark(&mut self) -> Result<(), std::io::Error> {
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
self.wrote_eof = true;

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

@ -528,11 +528,11 @@ impl SgTape {
) -> Result<(), std::io::Error> {
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)
.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);
let mut cmd = Vec::new();
@ -551,7 +551,7 @@ impl SgTape {
/* LEOM - ignore */
}
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();
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)
@ -654,7 +654,7 @@ impl SgTape {
Ok(true) // LEOM
}
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 {
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) => {
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 {
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> {
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) {
Ok(usize) => Ok(usize),

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

@ -34,7 +34,7 @@ pub trait TapeWrite {
data: &[u8],
) -> Result<bool, std::io::Error> {
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();

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| {
Body::wrap_stream(DeflateEncoder::with_quality(
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,
))

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

@ -309,7 +309,7 @@ impl TapeDriver for VirtualTapeHandle {
Ok(Box::new(reader))
}
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)
}
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 {
let got = file.read(&mut file_copy_buffer[..])?;
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])?;
remaining -= got as u64;
}
if remaining > 0 {
proxmox_sys::io_bail!("catalog '{}' shrunk while reading", uuid);
proxmox_lang::io_bail!("catalog '{}' shrunk while reading", uuid);
}
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> {
match self.writer {
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"),
}
}

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() {
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!({
let part_header: MediaContentHeader = unsafe { reader.read_le_value()? };
self.reader = Some(reader);
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 {
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;
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);
}
@ -72,7 +72,7 @@ impl <'a> Read for MultiVolumeReader<'a> {
Ok(())
}).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> {
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.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() {
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();
writer.finish(true)?;
@ -70,11 +70,11 @@ impl <'a> TapeWrite for MultiVolumeWriter<'a> {
if self.writer.is_none() {
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.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.wrote_header = false;
@ -107,12 +107,12 @@ impl <'a> TapeWrite for MultiVolumeWriter<'a> {
fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error> {
if incomplete {
proxmox_sys::io_bail!(
proxmox_lang::io_bail!(
"incomplete flag makes no sense for multi-volume stream: internal error");
}
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"),
None => Ok(false),
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() {
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 file_size = metadata.len();
let metadata: pxar::Metadata = metadata.into();
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;
@ -73,14 +73,14 @@ pub fn tape_write_snapshot_archive<'a>(
while remaining != 0 {
let got = file.read(&mut file_copy_buffer[..])?;
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])?;
remaining -= got as u64;
}
if remaining > 0 {
proxmox_sys::io_bail!("file '{}' shrunk while reading", filename);
proxmox_lang::io_bail!("file '{}' shrunk while reading", filename);
}
}
encoder.finish()?;

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

@ -15,9 +15,9 @@ use once_cell::sync::OnceCell;
use ::serde::{Deserialize, Serialize};
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::{io_bail, io_format_err};
use proxmox_lang::{io_bail, io_format_err};
use pbs_api_types::{StorageStatus, BLOCKDEVICE_NAME_REGEX};