106 lines
3.6 KiB
Rust
106 lines
3.6 KiB
Rust
|
use std::io::Write;
|
||
|
|
|
||
|
|
use endian_trait::Endian;
|
||
|
|
|
||
|
|
use proxmox::sys::error::SysError;
|
||
|
|
|
||
|
|
use crate::tape::file_formats::MediaContentHeader;
|
||
|
|
|
||
|
|
/// Write trait for tape devices
|
||
|
|
///
|
||
|
|
/// The 'write_all' function returns if the drive reached the Logical
|
||
|
|
/// End Of Media (early warning).
|
||
|
|
///
|
||
|
|
/// It is mandatory to call 'finish' before closing the stream to mark it
|
||
|
|
/// as correctly written.
|
||
|
|
///
|
||
|
|
/// Please note that there is no flush method. Tapes flush there internal
|
||
|
|
/// buffer when they write an EOF marker.
|
||
|
|
pub trait TapeWrite {
|
||
|
|
/// writes all data, returns true on LEOM
|
||
|
|
fn write_all(&mut self, data: &[u8]) -> Result<bool, std::io::Error>;
|
||
|
|
|
||
|
|
/// Returns how many bytes (raw data on tape) have been written
|
||
|
|
fn bytes_written(&self) -> usize;
|
||
|
|
|
||
|
|
/// flush last block, write file end mark
|
||
|
|
///
|
||
|
|
/// The incomplete flag is used to mark multivolume stream.
|
||
|
|
fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error>;
|
||
|
|
|
||
|
|
/// Returns true if the writer already detected the logical end of media
|
||
|
|
fn logical_end_of_media(&self) -> bool;
|
||
|
|
|
||
|
|
/// writes header and data, returns true on LEOM
|
||
|
|
fn write_header(
|
||
|
|
&mut self,
|
||
|
|
header: &MediaContentHeader,
|
||
|
|
data: &[u8],
|
||
|
|
) -> Result<bool, std::io::Error> {
|
||
|
|
if header.size as usize != data.len() {
|
||
|
|
proxmox::io_bail!("write_header with wrong size - internal error");
|
||
|
|
}
|
||
|
|
let header = header.to_le();
|
||
|
|
|
||
|
|
let res = self.write_all(unsafe { std::slice::from_raw_parts(
|
||
|
|
&header as *const MediaContentHeader as *const u8,
|
||
|
|
std::mem::size_of::<MediaContentHeader>(),
|
||
|
|
)})?;
|
||
|
|
|
||
|
|
if data.is_empty() { return Ok(res); }
|
||
|
|
|
||
|
|
self.write_all(data)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write a single block to a tape device
|
||
|
|
///
|
||
|
|
/// Assumes that 'writer' is a linux tape device.
|
||
|
|
///
|
||
|
|
/// EOM Behaviour on Linux: When the end of medium early warning is
|
||
|
|
/// encountered, the current write is finished and the number of bytes
|
||
|
|
/// is returned. The next write returns -1 and errno is set to
|
||
|
|
/// ENOSPC. To enable writing a trailer, the next write is allowed to
|
||
|
|
/// proceed and, if successful, the number of bytes is returned. After
|
||
|
|
/// this, -1 and the number of bytes are alternately returned until
|
||
|
|
/// the physical end of medium (or some other error) is encountered.
|
||
|
|
///
|
||
|
|
/// See: https://github.com/torvalds/linux/blob/master/Documentation/scsi/st.rst
|
||
|
|
///
|
||
|
|
/// On sucess, this returns if we en countered a EOM condition.
|
||
|
|
pub fn tape_device_write_block<W: Write>(
|
||
|
|
writer: &mut W,
|
||
|
|
data: &[u8],
|
||
|
|
) -> Result<bool, std::io::Error> {
|
||
|
|
|
||
|
|
let mut leof = false;
|
||
|
|
|
||
|
|
loop {
|
||
|
|
match writer.write(data) {
|
||
|
|
Ok(count) if count == data.len() => return Ok(leof),
|
||
|
|
Ok(count) if count > 0 => {
|
||
|
|
proxmox::io_bail!(
|
||
|
|
"short block write ({} < {}). Tape drive uses wrong block size.",
|
||
|
|
count, data.len());
|
||
|
|
}
|
||
|
|
Ok(_) => { // count is 0 here, assume EOT
|
||
|
|
return Err(std::io::Error::from_raw_os_error(nix::errno::Errno::ENOSPC as i32));
|
||
|
|
}
|
||
|
|
// handle interrupted system call
|
||
|
|
Err(err) if err.kind() == std::io::ErrorKind::Interrupted => {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// detect and handle LEOM (early warning)
|
||
|
|
Err(err) if err.is_errno(nix::errno::Errno::ENOSPC) => {
|
||
|
|
if leof {
|
||
|
|
return Err(err);
|
||
|
|
} else {
|
||
|
|
leof = true;
|
||
|
|
continue; // next write will succeed
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(err) => return Err(err),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|