* [pbs-devel] [PATCH 00/11] Userspace tape driver
@ 2021-04-07 10:22 Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 01/11] tape: introduce trait BlockRead Dietmar Maurer
` (10 more replies)
0 siblings, 11 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:22 UTC (permalink / raw)
To: pbs-devel
This is a userspace drive implementation using SG_IO.
Why we do not use the Linux tape driver anymore, because:
- missing features (MAM, Encryption, ...)
- strange permission handling - only root (or CAP_SYS_RAWIO) can
do SG_IO (SYS_RAW_IO)
- unability to detect EOT (you just get EIO)
Dietmar Maurer (11):
tape: introduce trait BlockRead
tape: introduce trait BlockWrite
tape: implement LTO userspace driver
tape: implement format/erase
tape: fix LEOM handling
tape: make fsf/bsf driver specific
tape: make sure there is a filemark at the end of the tape
sgutils2: add scsi_mode_sense helper
tape: correctly set/display drive option
tape: pmt - re-implement fsr/bsr
tape: pmt - re-implement lock/unlock command
debian/proxmox-backup-server.udev | 18 +
src/api2/config/changer.rs | 4 +-
src/api2/config/drive.rs | 44 +-
src/api2/tape/changer.rs | 4 +-
src/api2/tape/drive.rs | 65 +--
src/api2/tape/mod.rs | 4 +-
src/api2/types/tape/drive.rs | 34 +-
src/bin/pmt.rs | 347 +++---------
src/bin/pmtx.rs | 4 +-
src/bin/proxmox-tape.rs | 17 +-
src/bin/proxmox_tape/drive.rs | 8 +-
src/bin/sg-tape-cmd.rs | 189 +------
src/config/drive.rs | 18 +-
src/tape/changer/mod.rs | 4 +-
src/tape/drive/linux_tape.rs | 173 ++++--
src/tape/drive/lto/mod.rs | 474 ++++++++++++++++
src/tape/drive/lto/sg_tape.rs | 720 ++++++++++++++++++++++++
src/tape/drive/mod.rs | 53 +-
src/tape/drive/virtual_tape.rs | 116 ++--
src/tape/file_formats/blocked_reader.rs | 70 ++-
src/tape/file_formats/blocked_writer.rs | 37 +-
src/tape/helpers/emulate_tape_reader.rs | 64 +--
src/tape/helpers/emulate_tape_writer.rs | 37 +-
src/tape/linux_list_drives.rs | 51 +-
src/tape/pool_writer/mod.rs | 2 +-
src/tape/tape_read.rs | 35 +-
src/tape/tape_write.rs | 61 +-
src/tools/sgutils2.rs | 125 +++-
www/Utils.js | 2 +-
www/tape/DriveStatus.js | 8 +-
www/tape/window/Erase.js | 4 +-
31 files changed, 1939 insertions(+), 853 deletions(-)
create mode 100644 debian/proxmox-backup-server.udev
create mode 100644 src/tape/drive/lto/mod.rs
create mode 100644 src/tape/drive/lto/sg_tape.rs
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 01/11] tape: introduce trait BlockRead
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
@ 2021-04-07 10:22 ` Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 02/11] tape: introduce trait BlockWrite Dietmar Maurer
` (9 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:22 UTC (permalink / raw)
To: pbs-devel
---
src/api2/tape/drive.rs | 1 +
src/tape/drive/linux_tape.rs | 53 ++++++++++++++++++-
src/tape/drive/virtual_tape.rs | 3 +-
src/tape/file_formats/blocked_reader.rs | 70 +++++++++++++++++++------
src/tape/helpers/emulate_tape_reader.rs | 64 ++++++++++------------
src/tape/tape_read.rs | 35 ++++---------
6 files changed, 145 insertions(+), 81 deletions(-)
diff --git a/src/api2/tape/drive.rs b/src/api2/tape/drive.rs
index b753eb5b..b17f4203 100644
--- a/src/api2/tape/drive.rs
+++ b/src/api2/tape/drive.rs
@@ -531,6 +531,7 @@ pub fn label_media(
Ok(Some(_file)) => bail!("media is not empty (erase first)"),
Ok(None) => { /* EOF mark at BOT, assume tape is empty */ },
Err(err) => {
+ println!("TEST {:?}", err);
if err.is_errno(nix::errno::Errno::ENOSPC) || err.is_errno(nix::errno::Errno::EIO) {
/* assume tape is empty */
} else {
diff --git a/src/tape/drive/linux_tape.rs b/src/tape/drive/linux_tape.rs
index f8949196..9e86d0a3 100644
--- a/src/tape/drive/linux_tape.rs
+++ b/src/tape/drive/linux_tape.rs
@@ -1,6 +1,7 @@
//! Driver for Linux SCSI tapes
use std::fs::{OpenOptions, File};
+use std::io::Read;
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use std::convert::TryFrom;
@@ -24,6 +25,8 @@ use crate::{
LinuxDriveAndMediaStatus,
},
tape::{
+ BlockRead,
+ BlockReadStatus,
TapeRead,
TapeWrite,
drive::{
@@ -507,7 +510,8 @@ impl TapeDriver for LinuxTapeHandle {
}
fn read_next_file<'a>(&'a mut self) -> Result<Option<Box<dyn TapeRead + 'a>>, std::io::Error> {
- match BlockedReader::open(&mut self.file)? {
+ let reader = LinuxTapeReader::new(&mut self.file);
+ match BlockedReader::open(reader)? {
Some(reader) => Ok(Some(Box::new(reader))),
None => Ok(None),
}
@@ -766,3 +770,50 @@ impl TapeWrite for TapeWriterHandle<'_> {
self.writer.logical_end_of_media()
}
}
+
+pub struct LinuxTapeReader<'a> {
+ /// Assumes that 'file' is a linux tape device.
+ file: &'a mut File,
+ got_eof: bool,
+}
+
+impl <'a> LinuxTapeReader<'a> {
+
+ pub fn new(file: &'a mut File) -> Self {
+ Self { file, got_eof: false }
+ }
+}
+
+impl <'a> BlockRead for LinuxTapeReader<'a> {
+
+ /// Read a single block from a linux tape device
+ ///
+ /// Return true on success, false on EOD
+ fn read_block(&mut self, buffer: &mut [u8]) -> Result<BlockReadStatus, std::io::Error> {
+ loop {
+ match self.file.read(buffer) {
+ Ok(0) => {
+ let eod = self.got_eof;
+ self.got_eof = true;
+ if eod {
+ return Ok(BlockReadStatus::EndOfStream);
+ } else {
+ return Ok(BlockReadStatus::EndOfFile);
+ }
+ }
+ Ok(count) => {
+ if count == buffer.len() {
+ return Ok(BlockReadStatus::Ok(count));
+ }
+ proxmox::io_bail!("short block read ({} < {}). Tape drive uses wrong block size.",
+ count, buffer.len());
+ }
+ // handle interrupted system call
+ Err(err) if err.kind() == std::io::ErrorKind::Interrupted => {
+ continue;
+ }
+ Err(err) => return Err(err),
+ }
+ }
+ }
+}
diff --git a/src/tape/drive/virtual_tape.rs b/src/tape/drive/virtual_tape.rs
index d6b3d0c9..2fc9fdea 100644
--- a/src/tape/drive/virtual_tape.rs
+++ b/src/tape/drive/virtual_tape.rs
@@ -222,8 +222,7 @@ impl TapeDriver for VirtualTapeHandle {
self.store_status(&status)
.map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
- let reader = Box::new(file);
- let reader = Box::new(EmulateTapeReader::new(reader));
+ let reader = EmulateTapeReader::new(file);
match BlockedReader::open(reader)? {
Some(reader) => Ok(Some(Box::new(reader))),
diff --git a/src/tape/file_formats/blocked_reader.rs b/src/tape/file_formats/blocked_reader.rs
index 3ef7e7f4..3df84a1b 100644
--- a/src/tape/file_formats/blocked_reader.rs
+++ b/src/tape/file_formats/blocked_reader.rs
@@ -2,7 +2,8 @@ use std::io::Read;
use crate::tape::{
TapeRead,
- tape_device_read_block,
+ BlockRead,
+ BlockReadStatus,
file_formats::{
PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0,
BlockHeader,
@@ -32,7 +33,7 @@ pub struct BlockedReader<R> {
read_pos: usize,
}
-impl <R: Read> BlockedReader<R> {
+impl <R: BlockRead> BlockedReader<R> {
/// Create a new BlockedReader instance.
///
@@ -103,15 +104,41 @@ impl <R: Read> BlockedReader<R> {
)
};
- tape_device_read_block(reader, data)
+ match reader.read_block(data) {
+ Ok(BlockReadStatus::Ok(bytes)) => {
+ if bytes != BlockHeader::SIZE {
+ proxmox::io_bail!("got wrong block size");
+ }
+ Ok(true)
+ }
+ Ok(BlockReadStatus::EndOfFile) => {
+ Ok(false)
+ }
+ Ok(BlockReadStatus::EndOfStream) => {
+ return Err(std::io::Error::from_raw_os_error(nix::errno::Errno::ENOSPC as i32));
+ }
+ Err(err) => {
+ Err(err)
+ }
+ }
}
fn consume_eof_marker(reader: &mut R) -> Result<(), std::io::Error> {
let mut tmp_buf = [0u8; 512]; // use a small buffer for testing EOF
- if tape_device_read_block(reader, &mut tmp_buf)? {
- proxmox::io_bail!("detected tape block after stream end marker");
+ match reader.read_block(&mut tmp_buf) {
+ Ok(BlockReadStatus::Ok(_)) => {
+ proxmox::io_bail!("detected tape block after block-stream end marker");
+ }
+ Ok(BlockReadStatus::EndOfFile) => {
+ return Ok(());
+ }
+ Ok(BlockReadStatus::EndOfStream) => {
+ proxmox::io_bail!("got unexpected end of tape");
+ }
+ Err(err) => {
+ return Err(err);
+ }
}
- Ok(())
}
fn read_block(&mut self) -> Result<usize, std::io::Error> {
@@ -141,7 +168,7 @@ impl <R: Read> BlockedReader<R> {
}
}
-impl <R: Read> TapeRead for BlockedReader<R> {
+impl <R: BlockRead> TapeRead for BlockedReader<R> {
fn is_incomplete(&self) -> Result<bool, std::io::Error> {
if !self.got_eod {
@@ -163,7 +190,7 @@ impl <R: Read> TapeRead for BlockedReader<R> {
}
}
-impl <R: Read> Read for BlockedReader<R> {
+impl <R: BlockRead> Read for BlockedReader<R> {
fn read(&mut self, buffer: &mut [u8]) -> Result<usize, std::io::Error> {
@@ -207,6 +234,7 @@ mod test {
use anyhow::Error;
use crate::tape::{
TapeWrite,
+ helpers::{EmulateTapeReader, EmulateTapeWriter},
file_formats::{
PROXMOX_TAPE_BLOCK_SIZE,
BlockedReader,
@@ -218,11 +246,14 @@ mod test {
let mut tape_data = Vec::new();
- let mut writer = BlockedWriter::new(&mut tape_data);
+ {
+ let writer = EmulateTapeWriter::new(&mut tape_data, 1024*1024*10);
+ let mut writer = BlockedWriter::new(writer);
- writer.write_all(data)?;
+ writer.write_all(data)?;
- writer.finish(false)?;
+ writer.finish(false)?;
+ }
assert_eq!(
tape_data.len(),
@@ -231,6 +262,7 @@ mod test {
);
let reader = &mut &tape_data[..];
+ let reader = EmulateTapeReader::new(reader);
let mut reader = BlockedReader::open(reader)?.unwrap();
let mut read_data = Vec::with_capacity(PROXMOX_TAPE_BLOCK_SIZE);
@@ -263,6 +295,7 @@ mod test {
fn no_data() -> Result<(), Error> {
let tape_data = Vec::new();
let reader = &mut &tape_data[..];
+ let reader = EmulateTapeReader::new(reader);
let reader = BlockedReader::open(reader)?;
assert!(reader.is_none());
@@ -273,13 +306,16 @@ mod test {
fn no_end_marker() -> Result<(), Error> {
let mut tape_data = Vec::new();
{
- let mut writer = BlockedWriter::new(&mut tape_data);
+ let writer = EmulateTapeWriter::new(&mut tape_data, 1024*1024);
+ let mut writer = BlockedWriter::new(writer);
// write at least one block
let data = proxmox::sys::linux::random_data(PROXMOX_TAPE_BLOCK_SIZE)?;
writer.write_all(&data)?;
// but do not call finish here
}
+
let reader = &mut &tape_data[..];
+ let reader = EmulateTapeReader::new(reader);
let mut reader = BlockedReader::open(reader)?.unwrap();
let mut data = Vec::with_capacity(PROXMOX_TAPE_BLOCK_SIZE);
@@ -292,13 +328,17 @@ mod test {
fn small_read_buffer() -> Result<(), Error> {
let mut tape_data = Vec::new();
- let mut writer = BlockedWriter::new(&mut tape_data);
+ {
+ let writer = EmulateTapeWriter::new(&mut tape_data, 1024*1024);
+ let mut writer = BlockedWriter::new(writer);
- writer.write_all(b"ABC")?;
+ writer.write_all(b"ABC")?;
- writer.finish(false)?;
+ writer.finish(false)?;
+ }
let reader = &mut &tape_data[..];
+ let reader = EmulateTapeReader::new(reader);
let mut reader = BlockedReader::open(reader)?.unwrap();
let mut buf = [0u8; 1];
diff --git a/src/tape/helpers/emulate_tape_reader.rs b/src/tape/helpers/emulate_tape_reader.rs
index 1b6d4c5e..fbb19028 100644
--- a/src/tape/helpers/emulate_tape_reader.rs
+++ b/src/tape/helpers/emulate_tape_reader.rs
@@ -1,56 +1,46 @@
-use std::io::{self, Read};
+use std::io::Read;
-use crate::tape::file_formats::PROXMOX_TAPE_BLOCK_SIZE;
+use proxmox::tools::io::ReadExt;
+
+use crate::tape::{
+ BlockRead,
+ BlockReadStatus,
+ file_formats::PROXMOX_TAPE_BLOCK_SIZE,
+};
/// Emulate tape read behavior on a normal Reader
///
/// Tapes reads are always return one whole block PROXMOX_TAPE_BLOCK_SIZE.
-pub struct EmulateTapeReader<R> {
+pub struct EmulateTapeReader<R: Read> {
reader: R,
+ got_eof: bool,
}
impl <R: Read> EmulateTapeReader<R> {
pub fn new(reader: R) -> Self {
- Self { reader }
+ Self { reader, got_eof: false }
}
}
-impl <R: Read> Read for EmulateTapeReader<R> {
-
- fn read(&mut self, mut buffer: &mut [u8]) -> Result<usize, io::Error> {
-
- let initial_buffer_len = buffer.len(); // store, check later
-
- let mut bytes = 0;
-
- while !buffer.is_empty() {
- match self.reader.read(buffer) {
- Ok(0) => break,
- Ok(n) => {
- bytes += n;
- let tmp = buffer;
- buffer = &mut tmp[n..];
+impl <R: Read> BlockRead for EmulateTapeReader<R> {
+ fn read_block(&mut self, buffer: &mut [u8]) -> Result<BlockReadStatus, std::io::Error> {
+ if self.got_eof {
+ proxmox::io_bail!("detected read after EOF!");
+ }
+ match self.reader.read_exact_or_eof(buffer)? {
+ false => {
+ self.got_eof = true;
+ Ok(BlockReadStatus::EndOfFile)
+ }
+ true => {
+ // test buffer len after EOF test (to allow EOF test with small buffers in BufferedReader)
+ if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE {
+ proxmox::io_bail!("EmulateTapeReader: read_block with wrong block size ({} != {})",
+ buffer.len(), PROXMOX_TAPE_BLOCK_SIZE);
}
- Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
- Err(e) => return Err(e),
+ Ok(BlockReadStatus::Ok(buffer.len()))
}
}
-
- if bytes == 0 {
- return Ok(0);
- }
-
- // test buffer len after EOF test (to allow EOF test with small buffers in BufferedReader)
- if initial_buffer_len != PROXMOX_TAPE_BLOCK_SIZE {
- proxmox::io_bail!("EmulateTapeReader: got read with wrong block size ({} != {})",
- buffer.len(), PROXMOX_TAPE_BLOCK_SIZE);
- }
-
- if !buffer.is_empty() {
- Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer"))
- } else {
- Ok(bytes)
- }
}
}
diff --git a/src/tape/tape_read.rs b/src/tape/tape_read.rs
index c1ba52e6..7cbe2b8b 100644
--- a/src/tape/tape_read.rs
+++ b/src/tape/tape_read.rs
@@ -15,31 +15,14 @@ pub trait TapeRead: Read {
fn has_end_marker(&self) -> Result<bool, std::io::Error>;
}
-/// Read a single block from a tape device
-///
-/// Assumes that 'reader' is a linux tape device.
-///
-/// Return true on success, false on EOD
-pub fn tape_device_read_block<R: Read>(
- reader: &mut R,
- buffer: &mut [u8],
-) -> Result<bool, std::io::Error> {
+pub enum BlockReadStatus {
+ Ok(usize),
+ EndOfFile,
+ EndOfStream,
+}
- loop {
- match reader.read(buffer) {
- Ok(0) => { return Ok(false); /* EOD */ }
- Ok(count) => {
- if count == buffer.len() {
- return Ok(true);
- }
- proxmox::io_bail!("short block read ({} < {}). Tape drive uses wrong block size.",
- count, buffer.len());
- }
- // handle interrupted system call
- Err(err) if err.kind() == std::io::ErrorKind::Interrupted => {
- continue;
- }
- Err(err) => return Err(err),
- }
- }
+/// Read streams of blocks
+pub trait BlockRead {
+ /// Read the next block (whole buffer)
+ fn read_block(&mut self, buffer: &mut [u8]) -> Result<BlockReadStatus, std::io::Error>;
}
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 02/11] tape: introduce trait BlockWrite
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 01/11] tape: introduce trait BlockRead Dietmar Maurer
@ 2021-04-07 10:22 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 03/11] tape: implement LTO userspace driver Dietmar Maurer
` (8 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:22 UTC (permalink / raw)
To: pbs-devel
---
src/tape/drive/linux_tape.rs | 126 +++++++++++++++---------
src/tape/drive/virtual_tape.rs | 3 +-
src/tape/file_formats/blocked_writer.rs | 37 +++++--
src/tape/helpers/emulate_tape_writer.rs | 37 +++----
src/tape/tape_write.rs | 61 ++----------
5 files changed, 141 insertions(+), 123 deletions(-)
diff --git a/src/tape/drive/linux_tape.rs b/src/tape/drive/linux_tape.rs
index 9e86d0a3..d556f0f5 100644
--- a/src/tape/drive/linux_tape.rs
+++ b/src/tape/drive/linux_tape.rs
@@ -1,7 +1,7 @@
//! Driver for Linux SCSI tapes
use std::fs::{OpenOptions, File};
-use std::io::Read;
+use std::io::{Read, Write};
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use std::convert::TryFrom;
@@ -9,8 +9,10 @@ use std::convert::TryFrom;
use anyhow::{bail, format_err, Error};
use nix::fcntl::{fcntl, FcntlArg, OFlag};
-use proxmox::sys::error::SysResult;
-use proxmox::tools::Uuid;
+use proxmox::{
+ tools::Uuid,
+ sys::error::{SysError, SysResult},
+};
use crate::{
config,
@@ -25,6 +27,7 @@ use crate::{
LinuxDriveAndMediaStatus,
},
tape::{
+ BlockWrite,
BlockRead,
BlockReadStatus,
TapeRead,
@@ -257,10 +260,9 @@ impl LinuxTapeHandle {
Ok(())
}
- /// Write a single EOF mark
- pub fn write_eof_mark(&self) -> Result<(), Error> {
- tape_write_eof_mark(&self.file)?;
- Ok(())
+ /// Write a single EOF mark without flushing buffers
+ pub fn write_eof_mark(&mut self) -> Result<(), std::io::Error> {
+ tape_write_eof_mark(&mut self.file)
}
/// Set the drive's block length to the value specified.
@@ -519,10 +521,8 @@ impl TapeDriver for LinuxTapeHandle {
fn write_file<'a>(&'a mut self) -> Result<Box<dyn TapeWrite + 'a>, std::io::Error> {
- let handle = TapeWriterHandle {
- writer: BlockedWriter::new(&mut self.file),
- };
-
+ let writer = LinuxTapeWriter::new(&mut self.file);
+ let handle = BlockedWriter::new(writer);
Ok(Box::new(handle))
}
@@ -545,27 +545,27 @@ impl TapeDriver for LinuxTapeHandle {
self.set_encryption(None)?;
- let mut handle = TapeWriterHandle {
- writer: BlockedWriter::new(&mut self.file),
- };
+ { // limit handle scope
+ let mut handle = self.write_file()?;
- let mut value = serde_json::to_value(media_set_label)?;
- if media_set_label.encryption_key_fingerprint.is_some() {
- match key_config {
- Some(key_config) => {
- value["key-config"] = serde_json::to_value(key_config)?;
- }
- None => {
- bail!("missing encryption key config");
+ let mut value = serde_json::to_value(media_set_label)?;
+ if media_set_label.encryption_key_fingerprint.is_some() {
+ match key_config {
+ Some(key_config) => {
+ value["key-config"] = serde_json::to_value(key_config)?;
+ }
+ None => {
+ bail!("missing encryption key config");
+ }
}
}
- }
- let raw = serde_json::to_string_pretty(&value)?;
+ let raw = serde_json::to_string_pretty(&value)?;
- let header = MediaContentHeader::new(PROXMOX_BACKUP_MEDIA_SET_LABEL_MAGIC_1_0, raw.len() as u32);
- handle.write_header(&header, raw.as_bytes())?;
- handle.finish(false)?;
+ let header = MediaContentHeader::new(PROXMOX_BACKUP_MEDIA_SET_LABEL_MAGIC_1_0, raw.len() as u32);
+ handle.write_header(&header, raw.as_bytes())?;
+ handle.finish(false)?;
+ }
self.sync()?; // sync data to tape
@@ -655,7 +655,7 @@ impl TapeDriver for LinuxTapeHandle {
}
/// Write a single EOF mark without flushing buffers
-fn tape_write_eof_mark(file: &File) -> Result<(), std::io::Error> {
+fn tape_write_eof_mark(file: &mut File) -> Result<(), std::io::Error> {
let cmd = mtop { mt_op: MTCmd::MTWEOFI, mt_count: 1 };
@@ -745,29 +745,67 @@ pub fn read_tapedev_options(file: &File) -> Result<SetDrvBufferOptions, Error> {
}
-/// like BlockedWriter, but writes EOF mark on finish
-pub struct TapeWriterHandle<'a> {
- writer: BlockedWriter<&'a mut File>,
+struct LinuxTapeWriter<'a> {
+ /// Assumes that 'file' is a linux tape device.
+ file: &'a mut File,
}
-impl TapeWrite for TapeWriterHandle<'_> {
-
- fn write_all(&mut self, data: &[u8]) -> Result<bool, std::io::Error> {
- self.writer.write_all(data)
+impl <'a> LinuxTapeWriter<'a> {
+ pub fn new(file: &'a mut File) -> Self {
+ Self { file }
}
+}
- fn bytes_written(&self) -> usize {
- self.writer.bytes_written()
- }
+impl <'a> BlockWrite for LinuxTapeWriter<'a> {
- fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error> {
- let leof = self.writer.finish(incomplete)?;
- tape_write_eof_mark(self.writer.writer_ref_mut())?;
- Ok(leof)
+ /// Write a single block to 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 success, this returns if we en countered a EOM condition.
+ fn write_block(&mut self, data: &[u8]) -> Result<bool, std::io::Error> {
+
+ let mut leof = false;
+
+ loop {
+ match self.file.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),
+ }
+ }
}
- fn logical_end_of_media(&self) -> bool {
- self.writer.logical_end_of_media()
+ fn write_filemark(&mut self) -> Result<(), std::io::Error> {
+ tape_write_eof_mark(&mut self.file)
}
}
diff --git a/src/tape/drive/virtual_tape.rs b/src/tape/drive/virtual_tape.rs
index 2fc9fdea..54e0887f 100644
--- a/src/tape/drive/virtual_tape.rs
+++ b/src/tape/drive/virtual_tape.rs
@@ -276,8 +276,7 @@ impl TapeDriver for VirtualTapeHandle {
free_space = self.max_size - used_space;
}
- let writer = Box::new(file);
- let writer = Box::new(EmulateTapeWriter::new(writer, free_space));
+ let writer = EmulateTapeWriter::new(file, free_space);
let writer = Box::new(BlockedWriter::new(writer));
Ok(writer)
diff --git a/src/tape/file_formats/blocked_writer.rs b/src/tape/file_formats/blocked_writer.rs
index 961b2ed2..33fa2955 100644
--- a/src/tape/file_formats/blocked_writer.rs
+++ b/src/tape/file_formats/blocked_writer.rs
@@ -1,10 +1,8 @@
-use std::io::Write;
-
use proxmox::tools::vec;
use crate::tape::{
TapeWrite,
- tape_device_write_block,
+ BlockWrite,
file_formats::{
BlockHeader,
BlockHeaderFlags,
@@ -16,16 +14,27 @@ use crate::tape::{
/// This type implement 'TapeWrite'. Data written is assembled to
/// equally sized blocks (see 'BlockHeader'), which are then written
/// to the underlying writer.
-pub struct BlockedWriter<W> {
+pub struct BlockedWriter<W: BlockWrite> {
writer: W,
buffer: Box<BlockHeader>,
buffer_pos: usize,
seq_nr: u32,
logical_end_of_media: bool,
bytes_written: usize,
+ wrote_eof: bool,
+}
+
+impl <W: BlockWrite> Drop for BlockedWriter<W> {
+
+ // Try to make sure to end the file with a filemark
+ fn drop(&mut self) {
+ if !self.wrote_eof {
+ let _ = self.writer.write_filemark();
+ }
+ }
}
-impl <W: Write> BlockedWriter<W> {
+impl <W: BlockWrite> BlockedWriter<W> {
/// Allow access to underlying writer
pub fn writer_ref_mut(&mut self) -> &mut W {
@@ -41,6 +50,7 @@ impl <W: Write> BlockedWriter<W> {
seq_nr: 0,
logical_end_of_media: false,
bytes_written: 0,
+ wrote_eof: false,
}
}
@@ -52,7 +62,16 @@ impl <W: Write> BlockedWriter<W> {
BlockHeader::SIZE,
)
};
- tape_device_write_block(writer, data)
+ writer.write_block(data)
+ }
+
+ fn write_eof(&mut self) -> Result<(), std::io::Error> {
+ if self.wrote_eof {
+ proxmox::io_bail!("BlockedWriter: detected multiple EOF writes");
+ }
+ self.wrote_eof = true;
+
+ self.writer.write_filemark()
}
fn write(&mut self, data: &[u8]) -> Result<usize, std::io::Error> {
@@ -85,7 +104,7 @@ impl <W: Write> BlockedWriter<W> {
}
-impl <W: Write> TapeWrite for BlockedWriter<W> {
+impl <W: BlockWrite> TapeWrite for BlockedWriter<W> {
fn write_all(&mut self, mut data: &[u8]) -> Result<bool, std::io::Error> {
while !data.is_empty() {
@@ -113,7 +132,9 @@ impl <W: Write> TapeWrite for BlockedWriter<W> {
self.buffer.set_seq_nr(self.seq_nr);
self.seq_nr += 1;
self.bytes_written += BlockHeader::SIZE;
- Self::write_block(&self.buffer, &mut self.writer)
+ let leom = Self::write_block(&self.buffer, &mut self.writer)?;
+ self.write_eof()?;
+ Ok(leom)
}
/// Returns if the writer already detected the logical end of media
diff --git a/src/tape/helpers/emulate_tape_writer.rs b/src/tape/helpers/emulate_tape_writer.rs
index b385d6b3..eb4f29d7 100644
--- a/src/tape/helpers/emulate_tape_writer.rs
+++ b/src/tape/helpers/emulate_tape_writer.rs
@@ -1,6 +1,9 @@
use std::io::{self, Write};
-use crate::tape::file_formats::PROXMOX_TAPE_BLOCK_SIZE;
+use crate::tape::{
+ BlockWrite,
+ file_formats::PROXMOX_TAPE_BLOCK_SIZE,
+};
/// Emulate tape write behavior on a normal Writer
///
@@ -11,7 +14,7 @@ pub struct EmulateTapeWriter<W> {
block_nr: usize,
max_blocks: usize,
writer: W,
- leom_sent: bool,
+ wrote_eof: bool,
}
impl <W: Write> EmulateTapeWriter<W> {
@@ -27,16 +30,16 @@ impl <W: Write> EmulateTapeWriter<W> {
Self {
block_nr: 0,
- leom_sent: false,
+ wrote_eof: false,
writer,
max_blocks,
}
}
}
-impl <W: Write> Write for EmulateTapeWriter<W> {
+impl <W: Write> BlockWrite for EmulateTapeWriter<W> {
- fn write(&mut self, buffer: &[u8]) -> Result<usize, io::Error> {
+ fn write_block(&mut self, buffer: &[u8]) -> Result<bool, io::Error> {
if buffer.len() != PROXMOX_TAPE_BLOCK_SIZE {
proxmox::io_bail!("EmulateTapeWriter: got write with wrong block size ({} != {}",
@@ -47,22 +50,22 @@ impl <W: Write> Write for EmulateTapeWriter<W> {
return Err(io::Error::from_raw_os_error(nix::errno::Errno::ENOSPC as i32));
}
- if self.block_nr >= self.max_blocks {
- if !self.leom_sent {
- self.leom_sent = true;
- return Err(io::Error::from_raw_os_error(nix::errno::Errno::ENOSPC as i32));
- } else {
- self.leom_sent = false;
- }
- }
-
self.writer.write_all(buffer)?;
self.block_nr += 1;
- Ok(buffer.len())
+ if self.block_nr > self.max_blocks {
+ Ok(true)
+ } else {
+ Ok(false)
+ }
}
- fn flush(&mut self) -> Result<(), io::Error> {
- proxmox::io_bail!("EmulateTapeWriter does not support flush");
+ fn write_filemark(&mut self) -> Result<(), std::io::Error> {
+ if self.wrote_eof {
+ proxmox::io_bail!("EmulateTapeWriter: detected multiple EOF writes");
+ }
+ // do nothing, just record the call
+ self.wrote_eof = true;
+ Ok(())
}
}
diff --git a/src/tape/tape_write.rs b/src/tape/tape_write.rs
index 8a3d4fd6..593d1a29 100644
--- a/src/tape/tape_write.rs
+++ b/src/tape/tape_write.rs
@@ -1,9 +1,5 @@
-use std::io::Write;
-
use endian_trait::Endian;
-use proxmox::sys::error::SysError;
-
use crate::tape::file_formats::MediaContentHeader;
/// Write trait for tape devices
@@ -53,53 +49,14 @@ pub trait TapeWrite {
}
}
-/// 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 success, 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;
+/// Write streams of blocks
+pub trait BlockWrite {
+ /// Write a data block
+ ///
+ /// Returns true if the drive reached the Logical End Of Media
+ /// (early warning)
+ fn write_block(&mut self, buffer: &[u8]) -> Result<bool, std::io::Error>;
- 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),
- }
- }
+ /// Write a filemark
+ fn write_filemark(&mut self) -> Result<(), std::io::Error>;
}
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 03/11] tape: implement LTO userspace driver
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 01/11] tape: introduce trait BlockRead Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 02/11] tape: introduce trait BlockWrite Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 04/11] tape: implement format/erase Dietmar Maurer
` (7 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
debian/proxmox-backup-server.udev | 18 ++
src/api2/config/changer.rs | 4 +-
src/api2/config/drive.rs | 44 +--
src/api2/tape/changer.rs | 4 +-
src/api2/tape/drive.rs | 36 +--
src/api2/tape/mod.rs | 4 +-
src/api2/types/tape/drive.rs | 24 +-
src/bin/pmt.rs | 314 ++++-----------------
src/bin/pmtx.rs | 4 +-
src/bin/proxmox_tape/drive.rs | 8 +-
src/bin/sg-tape-cmd.rs | 189 ++-----------
src/config/drive.rs | 18 +-
src/tape/changer/mod.rs | 4 +-
src/tape/drive/lto/mod.rs | 420 ++++++++++++++++++++++++++++
src/tape/drive/lto/sg_tape.rs | 445 ++++++++++++++++++++++++++++++
src/tape/drive/mod.rs | 22 +-
src/tape/linux_list_drives.rs | 51 ++--
17 files changed, 1078 insertions(+), 531 deletions(-)
create mode 100644 debian/proxmox-backup-server.udev
create mode 100644 src/tape/drive/lto/mod.rs
create mode 100644 src/tape/drive/lto/sg_tape.rs
diff --git a/debian/proxmox-backup-server.udev b/debian/proxmox-backup-server.udev
new file mode 100644
index 00000000..afdfb2bc
--- /dev/null
+++ b/debian/proxmox-backup-server.udev
@@ -0,0 +1,18 @@
+# do not edit this file, it will be overwritten on update
+
+# persistent storage links: /dev/tape/{by-id,by-path}
+
+ACTION=="remove", GOTO="persistent_storage_tape_end"
+ENV{UDEV_DISABLE_PERSISTENT_STORAGE_RULES_FLAG}=="1", GOTO="persistent_storage_tape_end"
+
+# also see: /lib/udev/rules.d/60-persistent-storage-tape.rules
+
+SUBSYSTEM=="scsi_generic", SUBSYSTEMS=="scsi", ATTRS{type}=="1", IMPORT{program}="scsi_id --sg-version=3 --export --whitelisted -d $devnode", \
+ SYMLINK+="tape/by-id/scsi-$env{ID_SERIAL}-sg"
+
+# iSCSI devices from the same host have all the same ID_SERIAL,
+# but additionally a property named ID_SCSI_SERIAL.
+SUBSYSTEM=="scsi_generic", SUBSYSTEMS=="scsi", ATTRS{type}=="1", ENV{ID_SCSI_SERIAL}=="?*", \
+ SYMLINK+="tape/by-id/scsi-$env{ID_SCSI_SERIAL}-sg"
+
+LABEL="persistent_storage_tape_end"
diff --git a/src/api2/config/changer.rs b/src/api2/config/changer.rs
index 380eb089..62a0fba4 100644
--- a/src/api2/config/changer.rs
+++ b/src/api2/config/changer.rs
@@ -27,7 +27,7 @@ use crate::{
SLOT_ARRAY_SCHEMA,
EXPORT_SLOT_LIST_SCHEMA,
ScsiTapeChanger,
- LinuxTapeDrive,
+ LtoTapeDrive,
},
tape::{
linux_tape_changer_list,
@@ -303,7 +303,7 @@ pub fn delete_changer(name: String, _param: Value) -> Result<(), Error> {
None => bail!("Delete changer '{}' failed - no such entry", name),
}
- let drive_list: Vec<LinuxTapeDrive> = config.convert_to_typed_array("linux")?;
+ let drive_list: Vec<LtoTapeDrive> = config.convert_to_typed_array("lto")?;
for drive in drive_list {
if let Some(changer) = drive.changer {
if changer == name {
diff --git a/src/api2/config/drive.rs b/src/api2/config/drive.rs
index 98337024..e2626e14 100644
--- a/src/api2/config/drive.rs
+++ b/src/api2/config/drive.rs
@@ -19,12 +19,12 @@ use crate::{
DRIVE_NAME_SCHEMA,
CHANGER_NAME_SCHEMA,
CHANGER_DRIVENUM_SCHEMA,
- LINUX_DRIVE_PATH_SCHEMA,
- LinuxTapeDrive,
+ LTO_DRIVE_PATH_SCHEMA,
+ LtoTapeDrive,
ScsiTapeChanger,
},
tape::{
- linux_tape_device_list,
+ lto_tape_device_list,
check_drive_path,
},
};
@@ -37,7 +37,7 @@ use crate::{
schema: DRIVE_NAME_SCHEMA,
},
path: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
},
changer: {
schema: CHANGER_NAME_SCHEMA,
@@ -60,13 +60,13 @@ pub fn create_drive(param: Value) -> Result<(), Error> {
let (mut config, _digest) = config::drive::config()?;
- let item: LinuxTapeDrive = serde_json::from_value(param)?;
+ let item: LtoTapeDrive = serde_json::from_value(param)?;
- let linux_drives = linux_tape_device_list();
+ let lto_drives = lto_tape_device_list();
- check_drive_path(&linux_drives, &item.path)?;
+ check_drive_path(<o_drives, &item.path)?;
- let existing: Vec<LinuxTapeDrive> = config.convert_to_typed_array("linux")?;
+ let existing: Vec<LtoTapeDrive> = config.convert_to_typed_array("lto")?;
for drive in existing {
if drive.name == item.name {
@@ -77,7 +77,7 @@ pub fn create_drive(param: Value) -> Result<(), Error> {
}
}
- config.set_data(&item.name, "linux", &item)?;
+ config.set_data(&item.name, "lto", &item)?;
config::drive::save_config(&config)?;
@@ -93,7 +93,7 @@ pub fn create_drive(param: Value) -> Result<(), Error> {
},
},
returns: {
- type: LinuxTapeDrive,
+ type: LtoTapeDrive,
},
access: {
permission: &Permission::Privilege(&["tape", "device", "{name}"], PRIV_TAPE_AUDIT, false),
@@ -104,11 +104,11 @@ pub fn get_config(
name: String,
_param: Value,
mut rpcenv: &mut dyn RpcEnvironment,
-) -> Result<LinuxTapeDrive, Error> {
+) -> Result<LtoTapeDrive, Error> {
let (config, digest) = config::drive::config()?;
- let data: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let data: LtoTapeDrive = config.lookup("lto", &name)?;
rpcenv["digest"] = proxmox::tools::digest_to_hex(&digest).into();
@@ -123,7 +123,7 @@ pub fn get_config(
description: "The list of configured drives (with config digest).",
type: Array,
items: {
- type: LinuxTapeDrive,
+ type: LtoTapeDrive,
},
},
access: {
@@ -135,13 +135,13 @@ pub fn get_config(
pub fn list_drives(
_param: Value,
mut rpcenv: &mut dyn RpcEnvironment,
-) -> Result<Vec<LinuxTapeDrive>, Error> {
+) -> Result<Vec<LtoTapeDrive>, Error> {
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let user_info = CachedUserInfo::new()?;
let (config, digest) = config::drive::config()?;
- let drive_list: Vec<LinuxTapeDrive> = config.convert_to_typed_array("linux")?;
+ let drive_list: Vec<LtoTapeDrive> = config.convert_to_typed_array("lto")?;
let drive_list = drive_list
.into_iter()
@@ -176,7 +176,7 @@ pub enum DeletableProperty {
schema: DRIVE_NAME_SCHEMA,
},
path: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
changer: {
@@ -225,7 +225,7 @@ pub fn update_drive(
crate::tools::detect_modified_configuration_file(&digest, &expected_digest)?;
}
- let mut data: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let mut data: LtoTapeDrive = config.lookup("lto", &name)?;
if let Some(delete) = delete {
for delete_prop in delete {
@@ -240,8 +240,8 @@ pub fn update_drive(
}
if let Some(path) = path {
- let linux_drives = linux_tape_device_list();
- check_drive_path(&linux_drives, &path)?;
+ let lto_drives = lto_tape_device_list();
+ check_drive_path(<o_drives, &path)?;
data.path = path;
}
@@ -261,7 +261,7 @@ pub fn update_drive(
}
}
- config.set_data(&name, "linux", &data)?;
+ config.set_data(&name, "lto", &data)?;
config::drive::save_config(&config)?;
@@ -290,8 +290,8 @@ pub fn delete_drive(name: String, _param: Value) -> Result<(), Error> {
match config.sections.get(&name) {
Some((section_type, _)) => {
- if section_type != "linux" {
- bail!("Entry '{}' exists, but is not a linux tape drive", name);
+ if section_type != "lto" {
+ bail!("Entry '{}' exists, but is not a lto tape drive", name);
}
config.sections.remove(&name);
},
diff --git a/src/api2/tape/changer.rs b/src/api2/tape/changer.rs
index e2d1edc0..59dfe044 100644
--- a/src/api2/tape/changer.rs
+++ b/src/api2/tape/changer.rs
@@ -20,7 +20,7 @@ use crate::{
Authid,
CHANGER_NAME_SCHEMA,
ChangerListEntry,
- LinuxTapeDrive,
+ LtoTapeDrive,
MtxEntryKind,
MtxStatusEntry,
ScsiTapeChanger,
@@ -88,7 +88,7 @@ pub async fn get_status(
inventory.update_online_status(&map)?;
- let drive_list: Vec<LinuxTapeDrive> = config.convert_to_typed_array("linux")?;
+ let drive_list: Vec<LtoTapeDrive> = config.convert_to_typed_array("lto")?;
let mut drive_map: HashMap<u64, String> = HashMap::new();
for drive in drive_list {
diff --git a/src/api2/tape/drive.rs b/src/api2/tape/drive.rs
index b17f4203..80d17a27 100644
--- a/src/api2/tape/drive.rs
+++ b/src/api2/tape/drive.rs
@@ -42,11 +42,11 @@ use crate::{
MEDIA_POOL_NAME_SCHEMA,
Authid,
DriveListEntry,
- LinuxTapeDrive,
+ LtoTapeDrive,
MediaIdFlat,
LabelUuidMap,
MamAttribute,
- LinuxDriveAndMediaStatus,
+ LtoDriveAndMediaStatus,
},
tape::restore::{
fast_catalog_restore,
@@ -62,7 +62,7 @@ use crate::{
lock_media_set,
lock_media_pool,
lock_unassigned_media_pool,
- linux_tape_device_list,
+ lto_tape_device_list,
lookup_device_identification,
file_formats::{
MediaLabel,
@@ -70,9 +70,9 @@ use crate::{
},
drive::{
TapeDriver,
- LinuxTapeHandle,
+ LtoTapeHandle,
Lp17VolumeStatistics,
- open_linux_tape_device,
+ open_lto_tape_device,
media_changer,
required_media_changer,
open_drive,
@@ -794,9 +794,9 @@ pub fn clean_drive(
changer.clean_drive()?;
- if let Ok(drive_config) = config.lookup::<LinuxTapeDrive>("linux", &drive) {
+ if let Ok(drive_config) = config.lookup::<LtoTapeDrive>("lto", &drive) {
// Note: clean_drive unloads the cleaning media, so we cannot use drive_config.open
- let mut handle = LinuxTapeHandle::new(open_linux_tape_device(&drive_config.path)?);
+ let mut handle = LtoTapeHandle::new(open_lto_tape_device(&drive_config.path)?)?;
// test for critical tape alert flags
if let Ok(alert_flags) = handle.tape_alert_flags() {
@@ -1144,7 +1144,7 @@ pub async fn cartridge_memory(drive: String) -> Result<Vec<MamAttribute>, Error>
drive.clone(),
"reading cartridge memory".to_string(),
move |config| {
- let drive_config: LinuxTapeDrive = config.lookup("linux", &drive)?;
+ let drive_config: LtoTapeDrive = config.lookup("lto", &drive)?;
let mut handle = drive_config.open()?;
handle.cartridge_memory()
@@ -1174,7 +1174,7 @@ pub async fn volume_statistics(drive: String) -> Result<Lp17VolumeStatistics, Er
drive.clone(),
"reading volume statistics".to_string(),
move |config| {
- let drive_config: LinuxTapeDrive = config.lookup("linux", &drive)?;
+ let drive_config: LtoTapeDrive = config.lookup("lto", &drive)?;
let mut handle = drive_config.open()?;
handle.volume_statistics()
@@ -1192,24 +1192,24 @@ pub async fn volume_statistics(drive: String) -> Result<Lp17VolumeStatistics, Er
},
},
returns: {
- type: LinuxDriveAndMediaStatus,
+ type: LtoDriveAndMediaStatus,
},
access: {
permission: &Permission::Privilege(&["tape", "device", "{drive}"], PRIV_TAPE_AUDIT, false),
},
)]
/// Get drive/media status
-pub async fn status(drive: String) -> Result<LinuxDriveAndMediaStatus, Error> {
+pub async fn status(drive: String) -> Result<LtoDriveAndMediaStatus, Error> {
run_drive_blocking_task(
drive.clone(),
"reading drive status".to_string(),
move |config| {
- let drive_config: LinuxTapeDrive = config.lookup("linux", &drive)?;
+ let drive_config: LtoTapeDrive = config.lookup("lto", &drive)?;
- // Note: use open_linux_tape_device, because this also works if no medium loaded
- let file = open_linux_tape_device(&drive_config.path)?;
+ // Note: use open_lto_tape_device, because this also works if no medium loaded
+ let file = open_lto_tape_device(&drive_config.path)?;
- let mut handle = LinuxTapeHandle::new(file);
+ let mut handle = LtoTapeHandle::new(file)?;
handle.get_drive_and_media_status()
}
@@ -1382,9 +1382,9 @@ pub fn list_drives(
let (config, _) = config::drive::config()?;
- let linux_drives = linux_tape_device_list();
+ let lto_drives = lto_tape_device_list();
- let drive_list: Vec<LinuxTapeDrive> = config.convert_to_typed_array("linux")?;
+ let drive_list: Vec<LtoTapeDrive> = config.convert_to_typed_array("lto")?;
let mut list = Vec::new();
@@ -1398,7 +1398,7 @@ pub fn list_drives(
continue;
}
- let info = lookup_device_identification(&linux_drives, &drive.path);
+ let info = lookup_device_identification(<o_drives, &drive.path);
let state = get_tape_device_state(&config, &drive.name)?;
let entry = DriveListEntry { config: drive, info, state };
list.push(entry);
diff --git a/src/api2/tape/mod.rs b/src/api2/tape/mod.rs
index b560f077..219a721b 100644
--- a/src/api2/tape/mod.rs
+++ b/src/api2/tape/mod.rs
@@ -15,7 +15,7 @@ use proxmox::{
use crate::{
api2::types::TapeDeviceInfo,
tape::{
- linux_tape_device_list,
+ lto_tape_device_list,
linux_tape_changer_list,
},
};
@@ -41,7 +41,7 @@ pub mod restore;
/// Scan tape drives
pub fn scan_drives(_param: Value) -> Result<Vec<TapeDeviceInfo>, Error> {
- let list = linux_tape_device_list();
+ let list = lto_tape_device_list();
Ok(list)
}
diff --git a/src/api2/types/tape/drive.rs b/src/api2/types/tape/drive.rs
index 2fd480ac..058e544f 100644
--- a/src/api2/types/tape/drive.rs
+++ b/src/api2/types/tape/drive.rs
@@ -21,8 +21,8 @@ pub const DRIVE_NAME_SCHEMA: Schema = StringSchema::new("Drive Identifier.")
.max_length(32)
.schema();
-pub const LINUX_DRIVE_PATH_SCHEMA: Schema = StringSchema::new(
- "The path to a LINUX non-rewinding SCSI tape device (i.e. '/dev/nst0')")
+pub const LTO_DRIVE_PATH_SCHEMA: Schema = StringSchema::new(
+ "The path to a LTO SCSI-generic tape device (i.e. '/dev/sg0')")
.schema();
pub const CHANGER_DRIVENUM_SCHEMA: Schema = IntegerSchema::new(
@@ -57,7 +57,7 @@ pub struct VirtualTapeDrive {
schema: DRIVE_NAME_SCHEMA,
},
path: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
},
changer: {
schema: CHANGER_NAME_SCHEMA,
@@ -71,8 +71,8 @@ pub struct VirtualTapeDrive {
)]
#[derive(Serialize,Deserialize)]
#[serde(rename_all = "kebab-case")]
-/// Linux SCSI tape driver
-pub struct LinuxTapeDrive {
+/// Lto SCSI tape driver
+pub struct LtoTapeDrive {
pub name: String,
pub path: String,
#[serde(skip_serializing_if="Option::is_none")]
@@ -84,7 +84,7 @@ pub struct LinuxTapeDrive {
#[api(
properties: {
config: {
- type: LinuxTapeDrive,
+ type: LtoTapeDrive,
},
info: {
type: OptionalDeviceIdentification,
@@ -96,7 +96,7 @@ pub struct LinuxTapeDrive {
/// Drive list entry
pub struct DriveListEntry {
#[serde(flatten)]
- pub config: LinuxTapeDrive,
+ pub config: LtoTapeDrive,
#[serde(flatten)]
pub info: OptionalDeviceIdentification,
/// the state of the drive if locked
@@ -169,11 +169,11 @@ impl TryFrom<u8> for TapeDensity {
)]
#[derive(Serialize,Deserialize)]
#[serde(rename_all = "kebab-case")]
-/// Drive/Media status for Linux SCSI drives.
+/// Drive/Media status for Lto SCSI drives.
///
/// Media related data is optional - only set if there is a medium
/// loaded.
-pub struct LinuxDriveAndMediaStatus {
+pub struct LtoDriveAndMediaStatus {
/// Block size (0 is variable size)
pub blocksize: u32,
/// Tape density
@@ -181,17 +181,17 @@ pub struct LinuxDriveAndMediaStatus {
pub density: Option<TapeDensity>,
/// Status flags
pub status: String,
- /// Linux Driver Options
+ /// Lto Driver Options
pub options: String,
/// Tape Alert Flags
#[serde(skip_serializing_if="Option::is_none")]
pub alert_flags: Option<String>,
/// Current file number
#[serde(skip_serializing_if="Option::is_none")]
- pub file_number: Option<u32>,
+ pub file_number: Option<u64>,
/// Current block number
#[serde(skip_serializing_if="Option::is_none")]
- pub block_number: Option<u32>,
+ pub block_number: Option<u64>,
/// Medium Manufacture Date (epoch)
#[serde(skip_serializing_if="Option::is_none")]
pub manufactured: Option<i64>,
diff --git a/src/bin/pmt.rs b/src/bin/pmt.rs
index a097df2c..df3ad9ec 100644
--- a/src/bin/pmt.rs
+++ b/src/bin/pmt.rs
@@ -1,18 +1,18 @@
/// Control magnetic tape drive operation
///
-/// This is a Rust implementation, meant to replace the 'mt' command
-/// line tool.
+/// This is a Rust implementation, using the Proxmox userspace tape
+/// driver. This is meant as replacement fot the 'mt' command line
+/// tool.
///
/// Features:
///
/// - written in Rust
+/// - use Proxmox userspace driver (using SG_IO)
/// - optional json output format
/// - support tape alert flags
/// - support volume statistics
/// - read cartridge memory
-use std::collections::HashMap;
-
use anyhow::{bail, Error};
use serde_json::Value;
@@ -43,7 +43,7 @@ pub const RECORD_COUNT_SCHEMA: Schema =
.schema();
pub const DRIVE_OPTION_SCHEMA: Schema = StringSchema::new(
- "Linux Tape Driver Option, either numeric value or option name.")
+ "Lto Tape Driver Option, either numeric value or option name.")
.schema();
pub const DRIVE_OPTION_LIST_SCHEMA: Schema =
@@ -57,103 +57,60 @@ use proxmox_backup::{
drive::complete_drive_name,
},
api2::types::{
- LINUX_DRIVE_PATH_SCHEMA,
+ LTO_DRIVE_PATH_SCHEMA,
DRIVE_NAME_SCHEMA,
- LinuxTapeDrive,
+ LtoTapeDrive,
},
tape::{
complete_drive_path,
- linux_tape_device_list,
+ lto_tape_device_list,
drive::{
- linux_mtio::{MTCmd, SetDrvBufferOptions},
TapeDriver,
- LinuxTapeHandle,
- open_linux_tape_device,
+ LtoTapeHandle,
+ open_lto_tape_device,
},
},
};
-lazy_static::lazy_static!{
-
- static ref DRIVE_OPTIONS: HashMap<String, SetDrvBufferOptions> = {
- let mut map = HashMap::new();
-
- for i in 0..31 {
- let bit: i32 = 1 << i;
- let flag = SetDrvBufferOptions::from_bits_truncate(bit);
- if flag.bits() == 0 { continue; }
- let name = format!("{:?}", flag)
- .to_lowercase()
- .replace("_", "-");
-
- map.insert(name, flag);
- }
- map
- };
-
-}
-
-fn parse_drive_options(options: Vec<String>) -> Result<SetDrvBufferOptions, Error> {
-
- let mut value = SetDrvBufferOptions::empty();
-
- for option in options.iter() {
- if let Ok::<i32,_>(v) = option.parse() {
- value |= SetDrvBufferOptions::from_bits_truncate(v);
- } else if let Some(v) = DRIVE_OPTIONS.get(option) {
- value |= *v;
- } else {
- let option = option.to_lowercase().replace("_", "-");
- if let Some(v) = DRIVE_OPTIONS.get(&option) {
- value |= *v;
- } else {
- bail!("unknown drive option {}", option);
- }
- }
- }
-
- Ok(value)
-}
-
-fn get_tape_handle(param: &Value) -> Result<LinuxTapeHandle, Error> {
+fn get_tape_handle(param: &Value) -> Result<LtoTapeHandle, Error> {
if let Some(name) = param["drive"].as_str() {
let (config, _digest) = config::drive::config()?;
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
eprintln!("using device {}", drive.path);
- return Ok(LinuxTapeHandle::new(open_linux_tape_device(&drive.path)?))
+ return LtoTapeHandle::new(open_lto_tape_device(&drive.path)?);
}
if let Some(device) = param["device"].as_str() {
eprintln!("using device {}", device);
- return Ok(LinuxTapeHandle::new(open_linux_tape_device(&device)?))
+ return LtoTapeHandle::new(open_lto_tape_device(&device)?);
}
if let Ok(name) = std::env::var("PROXMOX_TAPE_DRIVE") {
let (config, _digest) = config::drive::config()?;
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
eprintln!("using device {}", drive.path);
- return Ok(LinuxTapeHandle::new(open_linux_tape_device(&drive.path)?))
+ return LtoTapeHandle::new(open_lto_tape_device(&drive.path)?);
}
if let Ok(device) = std::env::var("TAPE") {
eprintln!("using device {}", device);
- return Ok(LinuxTapeHandle::new(open_linux_tape_device(&device)?))
+ return LtoTapeHandle::new(open_lto_tape_device(&device)?);
}
let (config, _digest) = config::drive::config()?;
let mut drive_names = Vec::new();
for (name, (section_type, _)) in config.sections.iter() {
- if section_type != "linux" { continue; }
+ if section_type != "lto" { continue; }
drive_names.push(name);
}
if drive_names.len() == 1 {
let name = drive_names[0];
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
eprintln!("using device {}", drive.path);
- return Ok(LinuxTapeHandle::new(open_linux_tape_device(&drive.path)?))
+ return LtoTapeHandle::new(open_lto_tape_device(&drive.path)?);
}
bail!("no drive/device specified");
@@ -167,7 +124,7 @@ fn get_tape_handle(param: &Value) -> Result<LinuxTapeHandle, Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -200,7 +157,7 @@ fn asf(count: usize, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -230,7 +187,7 @@ fn bsf(count: usize, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -243,11 +200,12 @@ fn bsf(count: usize, param: Value) -> Result<(), Error> {
///
/// This leaves the tape positioned at the first block of the file
/// that is count - 1 files before the current file.
-fn bsfm(count: i32, param: Value) -> Result<(), Error> {
+fn bsfm(count: usize, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTBSFM, count, "bsfm")?;
+ handle.backward_space_count_files(count)?;
+ handle.forward_space_count_files(1)?;
Ok(())
}
@@ -261,7 +219,7 @@ fn bsfm(count: i32, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -275,7 +233,9 @@ fn bsr(count: i32, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTBSR, count, "backward space records")?;
+ unimplemented!();
+
+ // fixme: handle.mtop(MTCmd::MTBSR, count, "backward space records")?;
Ok(())
}
@@ -289,7 +249,7 @@ fn bsr(count: i32, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
"output-format": {
@@ -340,7 +300,7 @@ fn cartridge_memory(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
"output-format": {
@@ -389,7 +349,7 @@ fn tape_alert_flags(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
},
@@ -413,7 +373,7 @@ fn eject(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
},
@@ -437,7 +397,7 @@ fn eod(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
fast: {
@@ -466,7 +426,7 @@ fn erase(fast: Option<bool>, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -495,7 +455,7 @@ fn fsf(count: usize, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -508,11 +468,12 @@ fn fsf(count: usize, param: Value) -> Result<(), Error> {
///
/// This leaves the tape positioned at the last block of the file that
/// is count - 1 files past the current file.
-fn fsfm(count: i32, param: Value) -> Result<(), Error> {
+fn fsfm(count: usize, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTFSFM, count, "fsfm")?;
+ handle.forward_space_count_files(count)?;
+ handle.backward_space_count_files(1)?;
Ok(())
}
@@ -526,7 +487,7 @@ fn fsfm(count: i32, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -540,7 +501,8 @@ fn fsr(count: i32, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTFSR, count, "forward space records")?;
+ unimplemented!();
+ // fixme: handle.mtop(MTCmd::MTFSR, count, "forward space records")?;
Ok(())
}
@@ -554,7 +516,7 @@ fn fsr(count: i32, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
},
@@ -564,7 +526,7 @@ fn fsr(count: i32, param: Value) -> Result<(), Error> {
fn load(param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtload()?;
+ handle.load()?;
Ok(())
}
@@ -578,7 +540,7 @@ fn load(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
},
@@ -589,7 +551,8 @@ fn lock(param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTLOCK, 1, "lock tape drive door")?;
+ unimplemented!();
+ // fixme: handle.mtop(MTCmd::MTLOCK, 1, "lock tape drive door")?;
Ok(())
}
@@ -603,7 +566,7 @@ fn lock(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
},
@@ -634,7 +597,7 @@ fn scan(param: Value) -> Result<(), Error> {
let output_format = get_output_format(¶m);
- let list = linux_tape_device_list();
+ let list = lto_tape_device_list();
if output_format == "json-pretty" {
println!("{}", serde_json::to_string_pretty(&list)?);
@@ -657,36 +620,6 @@ fn scan(param: Value) -> Result<(), Error> {
Ok(())
}
-
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- size: {
- description: "Block size in bytes.",
- minimum: 0,
- },
- },
- },
-)]
-/// Set the block size of the drive
-fn setblk(size: i32, param: Value) -> Result<(), Error> {
-
- let mut handle = get_tape_handle(¶m)?;
-
- handle.mtop(MTCmd::MTSETBLK, size, "set block size")?;
-
- Ok(())
-}
-
-
#[api(
input: {
properties: {
@@ -695,7 +628,7 @@ fn setblk(size: i32, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
"output-format": {
@@ -737,122 +670,6 @@ fn status(param: Value) -> Result<(), Error> {
}
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- options: {
- schema: DRIVE_OPTION_LIST_SCHEMA,
- optional: true,
- },
- defaults: {
- description: "Set default options (buffer-writes async-writes read-ahead can-bsr).",
- type: bool,
- optional: true,
- },
- },
- },
-)]
-/// Set device driver options (root only)
-fn st_options(
- options: Option<Vec<String>>,
- defaults: Option<bool>,
- param: Value) -> Result<(), Error> {
-
- let handle = get_tape_handle(¶m)?;
-
- let options = match defaults {
- Some(true) => {
- if options.is_some() {
- bail!("option --defaults conflicts with specified options");
- }
- let mut list = Vec::new();
- list.push(String::from("buffer-writes"));
- list.push(String::from("async-writes"));
- list.push(String::from("read-ahead"));
- list.push(String::from("can-bsr"));
- list
- }
- Some(false) | None => {
- options.unwrap_or_else(|| Vec::new())
- }
- };
-
- let value = parse_drive_options(options)?;
-
- handle.set_drive_buffer_options(value)?;
-
- Ok(())
-}
-
-
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- options: {
- schema: DRIVE_OPTION_LIST_SCHEMA,
- },
- },
- },
-)]
-/// Set selected device driver options bits (root only)
-fn st_set_options(options: Vec<String>, param: Value) -> Result<(), Error> {
-
- let handle = get_tape_handle(¶m)?;
-
- let value = parse_drive_options(options)?;
-
- handle.drive_buffer_set_options(value)?;
-
- Ok(())
-}
-
-
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- options: {
- schema: DRIVE_OPTION_LIST_SCHEMA,
- },
- },
- },
-)]
-/// Clear selected device driver options bits (root only)
-fn st_clear_options(options: Vec<String>, param: Value) -> Result<(), Error> {
-
- let handle = get_tape_handle(¶m)?;
-
- let value = parse_drive_options(options)?;
-
- handle.drive_buffer_clear_options(value)?;
-
- Ok(())
-}
-
-
#[api(
input: {
properties: {
@@ -861,7 +678,7 @@ fn st_clear_options(options: Vec<String>, param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
},
@@ -872,7 +689,8 @@ fn unlock(param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTUNLOCK, 1, "unlock tape drive door")?;
+ unimplemented!();
+ //handle.mtop(MTCmd::MTUNLOCK, 1, "unlock tape drive door")?;
Ok(())
}
@@ -886,7 +704,7 @@ fn unlock(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
"output-format": {
@@ -935,7 +753,7 @@ fn volume_statistics(param: Value) -> Result<(), Error> {
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
count: {
@@ -946,10 +764,13 @@ fn volume_statistics(param: Value) -> Result<(), Error> {
},
)]
/// Write count (default 1) EOF marks at current position.
-fn weof(count: Option<i32>, param: Value) -> Result<(), Error> {
+fn weof(count: Option<usize>, param: Value) -> Result<(), Error> {
+
+ let count = count.unwrap_or(1);
let mut handle = get_tape_handle(¶m)?;
- handle.mtop(MTCmd::MTWEOF, count.unwrap_or(1), "write EOF mark")?;
+
+ handle.write_filemarks(count)?;
Ok(())
}
@@ -967,7 +788,6 @@ fn main() -> Result<(), Error> {
CliCommand::new(method)
.completion_cb("drive", complete_drive_name)
.completion_cb("device", complete_drive_path)
- .completion_cb("options", complete_option_name)
};
let cmd_def = CliCommandMap::new()
@@ -987,11 +807,7 @@ fn main() -> Result<(), Error> {
.insert("lock", std_cmd(&API_METHOD_LOCK))
.insert("rewind", std_cmd(&API_METHOD_REWIND))
.insert("scan", CliCommand::new(&API_METHOD_SCAN))
- .insert("setblk", CliCommand::new(&API_METHOD_SETBLK).arg_param(&["size"]))
.insert("status", std_cmd(&API_METHOD_STATUS))
- .insert("stoptions", std_cmd(&API_METHOD_ST_OPTIONS).arg_param(&["options"]))
- .insert("stsetoptions", std_cmd(&API_METHOD_ST_SET_OPTIONS).arg_param(&["options"]))
- .insert("stclearoptions", std_cmd(&API_METHOD_ST_CLEAR_OPTIONS).arg_param(&["options"]))
.insert("tape-alert-flags", std_cmd(&API_METHOD_TAPE_ALERT_FLAGS))
.insert("unlock", std_cmd(&API_METHOD_UNLOCK))
.insert("volume-statistics", std_cmd(&API_METHOD_VOLUME_STATISTICS))
@@ -1005,11 +821,3 @@ fn main() -> Result<(), Error> {
Ok(())
}
-
-// Completion helpers
-pub fn complete_option_name(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
- DRIVE_OPTIONS
- .keys()
- .map(String::from)
- .collect()
-}
diff --git a/src/bin/pmtx.rs b/src/bin/pmtx.rs
index 85114811..88074002 100644
--- a/src/bin/pmtx.rs
+++ b/src/bin/pmtx.rs
@@ -33,7 +33,7 @@ use proxmox_backup::{
SCSI_CHANGER_PATH_SCHEMA,
CHANGER_NAME_SCHEMA,
ScsiTapeChanger,
- LinuxTapeDrive,
+ LtoTapeDrive,
},
tape::{
linux_tape_changer_list,
@@ -67,7 +67,7 @@ fn get_changer_handle(param: &Value) -> Result<File, Error> {
if let Ok(name) = std::env::var("PROXMOX_TAPE_DRIVE") {
let (config, _digest) = config::drive::config()?;
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
if let Some(changer) = drive.changer {
let changer_config: ScsiTapeChanger = config.lookup("changer", &changer)?;
eprintln!("using device {}", changer_config.path);
diff --git a/src/bin/proxmox_tape/drive.rs b/src/bin/proxmox_tape/drive.rs
index 84bdb524..f8831aec 100644
--- a/src/bin/proxmox_tape/drive.rs
+++ b/src/bin/proxmox_tape/drive.rs
@@ -21,7 +21,7 @@ use proxmox_backup::{
config::drive::{
complete_drive_name,
complete_changer_name,
- complete_linux_drive_name,
+ complete_lto_drive_name,
},
};
@@ -33,13 +33,13 @@ pub fn drive_commands() -> CommandLineInterface {
.insert("config",
CliCommand::new(&API_METHOD_GET_CONFIG)
.arg_param(&["name"])
- .completion_cb("name", complete_linux_drive_name)
+ .completion_cb("name", complete_lto_drive_name)
)
.insert(
"remove",
CliCommand::new(&api2::config::drive::API_METHOD_DELETE_DRIVE)
.arg_param(&["name"])
- .completion_cb("name", complete_linux_drive_name)
+ .completion_cb("name", complete_lto_drive_name)
)
.insert(
"create",
@@ -53,7 +53,7 @@ pub fn drive_commands() -> CommandLineInterface {
"update",
CliCommand::new(&api2::config::drive::API_METHOD_UPDATE_DRIVE)
.arg_param(&["name"])
- .completion_cb("name", complete_linux_drive_name)
+ .completion_cb("name", complete_lto_drive_name)
.completion_cb("path", complete_drive_path)
.completion_cb("changer", complete_changer_name)
)
diff --git a/src/bin/sg-tape-cmd.rs b/src/bin/sg-tape-cmd.rs
index 86998972..a2f0283d 100644
--- a/src/bin/sg-tape-cmd.rs
+++ b/src/bin/sg-tape-cmd.rs
@@ -1,7 +1,5 @@
-/// Tape command implemented using scsi-generic raw commands
-///
-/// SCSI-generic command needs root privileges, so this binary need
-/// to be setuid root.
+/// Helper to run tape commands as root. Currently only required
+/// to read and set the encryption key.
///
/// This command can use STDIN as tape device handle.
@@ -24,41 +22,41 @@ use proxmox_backup::{
config,
backup::Fingerprint,
api2::types::{
- LINUX_DRIVE_PATH_SCHEMA,
+ LTO_DRIVE_PATH_SCHEMA,
DRIVE_NAME_SCHEMA,
TAPE_ENCRYPTION_KEY_FINGERPRINT_SCHEMA,
MEDIA_SET_UUID_SCHEMA,
- LinuxTapeDrive,
+ LtoTapeDrive,
},
tape::{
drive::{
TapeDriver,
- LinuxTapeHandle,
- open_linux_tape_device,
- check_tape_is_linux_tape_device,
+ LtoTapeHandle,
+ open_lto_tape_device,
+ check_tape_is_lto_tape_device,
},
},
};
-fn get_tape_handle(param: &Value) -> Result<LinuxTapeHandle, Error> {
+fn get_tape_handle(param: &Value) -> Result<LtoTapeHandle, Error> {
let handle = if let Some(name) = param["drive"].as_str() {
let (config, _digest) = config::drive::config()?;
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
eprintln!("using device {}", drive.path);
drive.open()?
} else if let Some(device) = param["device"].as_str() {
eprintln!("using device {}", device);
- LinuxTapeHandle::new(open_linux_tape_device(&device)?)
+ LtoTapeHandle::new(open_lto_tape_device(&device)?)?
} else if let Some(true) = param["stdin"].as_bool() {
eprintln!("using stdin");
let fd = std::io::stdin().as_raw_fd();
let file = unsafe { File::from_raw_fd(fd) };
- check_tape_is_linux_tape_device(&file)?;
- LinuxTapeHandle::new(file)
+ check_tape_is_lto_tape_device(&file)?;
+ LtoTapeHandle::new(file)?
} else if let Ok(name) = std::env::var("PROXMOX_TAPE_DRIVE") {
let (config, _digest) = config::drive::config()?;
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
eprintln!("using device {}", drive.path);
drive.open()?
} else {
@@ -66,13 +64,13 @@ fn get_tape_handle(param: &Value) -> Result<LinuxTapeHandle, Error> {
let mut drive_names = Vec::new();
for (name, (section_type, _)) in config.sections.iter() {
- if section_type != "linux" { continue; }
+ if section_type != "lto" { continue; }
drive_names.push(name);
}
if drive_names.len() == 1 {
let name = drive_names[0];
- let drive: LinuxTapeDrive = config.lookup("linux", &name)?;
+ let drive: LtoTapeDrive = config.lookup("lto", &name)?;
eprintln!("using device {}", drive.path);
drive.open()?
} else {
@@ -83,111 +81,6 @@ fn get_tape_handle(param: &Value) -> Result<LinuxTapeHandle, Error> {
Ok(handle)
}
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- stdin: {
- description: "Use standard input as device handle.",
- type: bool,
- optional: true,
- },
- },
- },
-)]
-/// Tape/Media Status
-fn status(
- param: Value,
-) -> Result<(), Error> {
-
- let result = proxmox::try_block!({
- let mut handle = get_tape_handle(¶m)?;
- handle.get_drive_and_media_status()
- }).map_err(|err: Error| err.to_string());
-
- println!("{}", serde_json::to_string_pretty(&result)?);
-
- Ok(())
-}
-
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- stdin: {
- description: "Use standard input as device handle.",
- type: bool,
- optional: true,
- },
- },
- },
-)]
-/// Read Cartridge Memory (Medium auxiliary memory attributes)
-fn cartridge_memory(
- param: Value,
-) -> Result<(), Error> {
-
- let result = proxmox::try_block!({
- let mut handle = get_tape_handle(¶m)?;
-
- handle.cartridge_memory()
- }).map_err(|err| err.to_string());
-
- println!("{}", serde_json::to_string_pretty(&result)?);
-
- Ok(())
-}
-
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- stdin: {
- description: "Use standard input as device handle.",
- type: bool,
- optional: true,
- },
- },
- },
-)]
-/// Read Tape Alert Flags
-fn tape_alert_flags(
- param: Value,
-) -> Result<(), Error> {
-
- let result = proxmox::try_block!({
- let mut handle = get_tape_handle(¶m)?;
-
- let flags = handle.tape_alert_flags()?;
- Ok(flags.bits())
- }).map_err(|err: Error| err.to_string());
-
- println!("{}", serde_json::to_string_pretty(&result)?);
-
- Ok(())
-}
-
#[api(
input: {
properties: {
@@ -204,7 +97,7 @@ fn tape_alert_flags(
optional: true,
},
device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
+ schema: LTO_DRIVE_PATH_SCHEMA,
optional: true,
},
stdin: {
@@ -245,40 +138,6 @@ fn set_encryption(
Ok(())
}
-#[api(
- input: {
- properties: {
- drive: {
- schema: DRIVE_NAME_SCHEMA,
- optional: true,
- },
- device: {
- schema: LINUX_DRIVE_PATH_SCHEMA,
- optional: true,
- },
- stdin: {
- description: "Use standard input as device handle.",
- type: bool,
- optional: true,
- },
- },
- },
-)]
-/// Read volume statistics
-fn volume_statistics(
- param: Value,
-) -> Result<(), Error> {
-
- let result = proxmox::try_block!({
- let mut handle = get_tape_handle(¶m)?;
- handle.volume_statistics()
- }).map_err(|err: Error| err.to_string());
-
- println!("{}", serde_json::to_string_pretty(&result)?);
-
- Ok(())
-}
-
fn main() -> Result<(), Error> {
// check if we are user root or backup
@@ -300,22 +159,6 @@ fn main() -> Result<(), Error> {
}
let cmd_def = CliCommandMap::new()
- .insert(
- "status",
- CliCommand::new(&API_METHOD_STATUS)
- )
- .insert(
- "cartridge-memory",
- CliCommand::new(&API_METHOD_CARTRIDGE_MEMORY)
- )
- .insert(
- "tape-alert-flags",
- CliCommand::new(&API_METHOD_TAPE_ALERT_FLAGS)
- )
- .insert(
- "volume-statistics",
- CliCommand::new(&API_METHOD_VOLUME_STATISTICS)
- )
.insert(
"encryption",
CliCommand::new(&API_METHOD_SET_ENCRYPTION)
diff --git a/src/config/drive.rs b/src/config/drive.rs
index 63839d0d..57f6911f 100644
--- a/src/config/drive.rs
+++ b/src/config/drive.rs
@@ -1,12 +1,12 @@
//! Tape drive/changer configuration
//!
//! This configuration module is based on [`SectionConfig`], and
-//! provides a type safe interface to store [`LinuxTapeDrive`],
+//! provides a type safe interface to store [`LtoTapeDrive`],
//! [`VirtualTapeDrive`] and [`ScsiTapeChanger`] configurations.
//!
//! Drive type [`VirtualTapeDrive`] is only useful for debugging.
//!
-//! [LinuxTapeDrive]: crate::api2::types::LinuxTapeDrive
+//! [LtoTapeDrive]: crate::api2::types::LtoTapeDrive
//! [VirtualTapeDrive]: crate::api2::types::VirtualTapeDrive
//! [ScsiTapeChanger]: crate::api2::types::ScsiTapeChanger
//! [SectionConfig]: proxmox::api::section_config::SectionConfig
@@ -36,7 +36,7 @@ use crate::{
api2::types::{
DRIVE_NAME_SCHEMA,
VirtualTapeDrive,
- LinuxTapeDrive,
+ LtoTapeDrive,
ScsiTapeChanger,
},
};
@@ -57,11 +57,11 @@ fn init() -> SectionConfig {
let plugin = SectionConfigPlugin::new("virtual".to_string(), Some("name".to_string()), obj_schema);
config.register_plugin(plugin);
- let obj_schema = match LinuxTapeDrive::API_SCHEMA {
+ let obj_schema = match LtoTapeDrive::API_SCHEMA {
Schema::Object(ref obj_schema) => obj_schema,
_ => unreachable!(),
};
- let plugin = SectionConfigPlugin::new("linux".to_string(), Some("name".to_string()), obj_schema);
+ let plugin = SectionConfigPlugin::new("lto".to_string(), Some("name".to_string()), obj_schema);
config.register_plugin(plugin);
let obj_schema = match ScsiTapeChanger::API_SCHEMA {
@@ -116,7 +116,7 @@ pub fn save_config(config: &SectionConfigData) -> Result<(), Error> {
pub fn check_drive_exists(config: &SectionConfigData, drive: &str) -> Result<(), Error> {
match config.sections.get(drive) {
Some((section_type, _)) => {
- if !(section_type == "linux" || section_type == "virtual") {
+ if !(section_type == "lto" || section_type == "virtual") {
bail!("Entry '{}' exists, but is not a tape drive", drive);
}
}
@@ -138,12 +138,12 @@ pub fn complete_drive_name(_arg: &str, _param: &HashMap<String, String>) -> Vec<
}
}
-/// List Linux tape drives
-pub fn complete_linux_drive_name(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
+/// List Lto tape drives
+pub fn complete_lto_drive_name(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
match config() {
Ok((data, _digest)) => data.sections.iter()
.filter(|(_id, (section_type, _))| {
- section_type == "linux"
+ section_type == "lto"
})
.map(|(id, _)| id.to_string())
.collect(),
diff --git a/src/tape/changer/mod.rs b/src/tape/changer/mod.rs
index a25df49b..1fc0d435 100644
--- a/src/tape/changer/mod.rs
+++ b/src/tape/changer/mod.rs
@@ -26,7 +26,7 @@ use proxmox::{
use crate::api2::types::{
SLOT_ARRAY_SCHEMA,
ScsiTapeChanger,
- LinuxTapeDrive,
+ LtoTapeDrive,
};
/// Changer element status.
@@ -523,7 +523,7 @@ pub struct MtxMediaChanger {
impl MtxMediaChanger {
- pub fn with_drive_config(drive_config: &LinuxTapeDrive) -> Result<Self, Error> {
+ pub fn with_drive_config(drive_config: &LtoTapeDrive) -> Result<Self, Error> {
let (config, _digest) = crate::config::drive::config()?;
let changer_config: ScsiTapeChanger = match drive_config.changer {
Some(ref changer) => config.lookup("changer", changer)?,
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
new file mode 100644
index 00000000..becbad50
--- /dev/null
+++ b/src/tape/drive/lto/mod.rs
@@ -0,0 +1,420 @@
+//! Driver for LTO SCSI tapes
+//!
+//! This is a userspace drive implementation using SG_IO.
+//!
+//! Why we do not use the Linux tape driver:
+//!
+//! - missing features (MAM, Encryption, ...)
+//!
+//! - strange permission handling - only root (or CAP_SYS_RAWIO) can
+//! do SG_IO (SYS_RAW_IO)
+//!
+//! - unability to detect EOT (you just get EIO)
+
+mod sg_tape;
+pub use sg_tape::*;
+
+use std::fs::{OpenOptions, File};
+use std::os::unix::fs::OpenOptionsExt;
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::convert::TryFrom;
+
+use anyhow::{bail, format_err, Error};
+use nix::fcntl::{fcntl, FcntlArg, OFlag};
+
+use proxmox::{
+ tools::Uuid,
+ sys::error::SysResult,
+};
+
+use crate::{
+ config,
+ tools::run_command,
+ backup::{
+ Fingerprint,
+ KeyConfig,
+ },
+ api2::types::{
+ MamAttribute,
+ LtoDriveAndMediaStatus,
+ LtoTapeDrive,
+ },
+ tape::{
+ TapeRead,
+ TapeWrite,
+ drive::{
+ TapeDriver,
+ TapeAlertFlags,
+ Lp17VolumeStatistics,
+ mam_extract_media_usage,
+ },
+ file_formats::{
+ PROXMOX_BACKUP_MEDIA_SET_LABEL_MAGIC_1_0,
+ MediaSetLabel,
+ MediaContentHeader,
+ },
+ },
+};
+
+impl LtoTapeDrive {
+
+ /// Open a tape device
+ ///
+ /// This does additional checks:
+ ///
+ /// - check if it is a non-rewinding tape device
+ /// - check if drive is ready (tape loaded)
+ /// - check block size
+ /// - for autoloader only, try to reload ejected tapes
+ pub fn open(&self) -> Result<LtoTapeHandle, Error> {
+
+ proxmox::try_block!({
+ let file = open_lto_tape_device(&self.path)?;
+
+ let mut handle = LtoTapeHandle::new(file)?;
+
+ if !handle.sg_tape.test_unit_ready().is_ok() {
+ // for autoloader only, try to reload ejected tapes
+ if self.changer.is_some() {
+ let _ = handle.sg_tape.load(); // just try, ignore error
+ }
+ }
+
+ handle.sg_tape.wait_until_ready()?;
+
+ // Only root can set driver options, so we cannot
+ // handle.set_default_options()?;
+
+ Ok(handle)
+ }).map_err(|err: Error| format_err!("open drive '{}' ({}) failed - {}", self.name, self.path, err))
+ }
+}
+
+/// Lto Tape device handle
+pub struct LtoTapeHandle {
+ sg_tape: SgTape,
+}
+
+impl LtoTapeHandle {
+
+ /// Creates a new instance
+ pub fn new(file: File) -> Result<Self, Error> {
+ let sg_tape = SgTape::new(file)?;
+ Ok(Self { sg_tape })
+ }
+
+ /// Set all options we need/want
+ pub fn set_default_options(&self) -> Result<(), Error> {
+ // fixme
+ Ok(())
+ }
+
+ /// Write a single EOF mark without flushing buffers
+ pub fn write_filemarks(&mut self, count: usize) -> Result<(), std::io::Error> {
+ self.sg_tape.write_filemarks(count, false)
+ }
+
+ /// Get Tape and Media status
+ pub fn get_drive_and_media_status(&mut self) -> Result<LtoDriveAndMediaStatus, Error> {
+
+ let (file_number, block_number) = match self.sg_tape.position() {
+ Ok(position) => (
+ Some(position.logical_file_id),
+ Some(position.logical_object_number),
+ ),
+ Err(_) => (None, None),
+ };
+
+ let options = String::from("FIXME");
+
+ let alert_flags = self.tape_alert_flags()
+ .map(|flags| format!("{:?}", flags))
+ .ok();
+
+ let mut status = LtoDriveAndMediaStatus {
+ blocksize: 0, // fixme: remove
+ density: None, // fixme
+ status: String::from("FIXME"),
+ options,
+ alert_flags,
+ file_number,
+ block_number,
+ manufactured: None,
+ bytes_read: None,
+ bytes_written: None,
+ medium_passes: None,
+ medium_wearout: None,
+ volume_mounts: None,
+ };
+
+ if self.sg_tape.test_unit_ready()? {
+
+ if let Ok(mam) = self.cartridge_memory() {
+
+ let usage = mam_extract_media_usage(&mam)?;
+
+ status.manufactured = Some(usage.manufactured);
+ status.bytes_read = Some(usage.bytes_read);
+ status.bytes_written = Some(usage.bytes_written);
+
+ if let Ok(volume_stats) = self.volume_statistics() {
+
+ let passes = std::cmp::max(
+ volume_stats.beginning_of_medium_passes,
+ volume_stats.middle_of_tape_passes,
+ );
+
+ // assume max. 16000 medium passes
+ // see: https://en.wikipedia.org/wiki/Linear_Tape-Open
+ let wearout: f64 = (passes as f64)/(16000.0 as f64);
+
+ status.medium_passes = Some(passes);
+ status.medium_wearout = Some(wearout);
+
+ status.volume_mounts = Some(volume_stats.volume_mounts);
+ }
+ }
+ }
+
+ Ok(status)
+ }
+
+ pub fn load(&mut self) -> Result<(), Error> {
+ self.sg_tape.load()
+ }
+
+ /// Read Cartridge Memory (MAM Attributes)
+ pub fn cartridge_memory(&mut self) -> Result<Vec<MamAttribute>, Error> {
+ self.sg_tape.cartridge_memory()
+ }
+
+ /// Read Volume Statistics
+ pub fn volume_statistics(&mut self) -> Result<Lp17VolumeStatistics, Error> {
+ self.sg_tape.volume_statistics()
+ }
+}
+
+
+impl TapeDriver for LtoTapeHandle {
+
+ fn sync(&mut self) -> Result<(), Error> {
+ self.sg_tape.sync()?;
+ Ok(())
+ }
+
+ /// Go to the end of the recorded media (for appending files).
+ fn move_to_eom(&mut self) -> Result<(), Error> {
+ self.sg_tape.move_to_eom()
+ }
+
+ fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
+ self.sg_tape.space_filemarks(isize::try_from(count)?)
+ }
+
+ fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
+ self.sg_tape.space_filemarks(-isize::try_from(count)?)
+ }
+
+ fn rewind(&mut self) -> Result<(), Error> {
+ self.sg_tape.rewind()
+ }
+
+ fn current_file_number(&mut self) -> Result<u64, Error> {
+ self.sg_tape.current_file_number()
+ }
+
+ fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
+ self.rewind()?; // important - erase from BOT
+ self.sg_tape.erase_media(fast)
+ }
+
+ fn read_next_file<'a>(&'a mut self) -> Result<Option<Box<dyn TapeRead + 'a>>, std::io::Error> {
+ let reader = self.sg_tape.open_reader()?;
+ let handle = match reader {
+ Some(reader) => {
+ let reader: Box<dyn TapeRead> = Box::new(reader);
+ Some(reader)
+ }
+ None => None,
+ };
+
+ Ok(handle)
+ }
+
+ fn write_file<'a>(&'a mut self) -> Result<Box<dyn TapeWrite + 'a>, std::io::Error> {
+ let handle = self.sg_tape.open_writer();
+ Ok(Box::new(handle))
+ }
+
+ fn write_media_set_label(
+ &mut self,
+ media_set_label: &MediaSetLabel,
+ key_config: Option<&KeyConfig>,
+ ) -> Result<(), Error> {
+
+ let file_number = self.current_file_number()?;
+ if file_number != 1 {
+ self.rewind()?;
+ self.forward_space_count_files(1)?; // skip label
+ }
+
+ let file_number = self.current_file_number()?;
+ if file_number != 1 {
+ bail!("write_media_set_label failed - got wrong file number ({} != 1)", file_number);
+ }
+
+ self.set_encryption(None)?;
+
+ { // limit handle scope
+ let mut handle = self.write_file()?;
+
+ let mut value = serde_json::to_value(media_set_label)?;
+ if media_set_label.encryption_key_fingerprint.is_some() {
+ match key_config {
+ Some(key_config) => {
+ value["key-config"] = serde_json::to_value(key_config)?;
+ }
+ None => {
+ bail!("missing encryption key config");
+ }
+ }
+ }
+
+ let raw = serde_json::to_string_pretty(&value)?;
+
+ let header = MediaContentHeader::new(PROXMOX_BACKUP_MEDIA_SET_LABEL_MAGIC_1_0, raw.len() as u32);
+ handle.write_header(&header, raw.as_bytes())?;
+ handle.finish(false)?;
+ }
+
+ self.sync()?; // sync data to tape
+
+ Ok(())
+ }
+
+ /// Rewind and put the drive off line (Eject media).
+ fn eject_media(&mut self) -> Result<(), Error> {
+ self.sg_tape.eject()
+ }
+
+ /// Read Tape Alert Flags
+ fn tape_alert_flags(&mut self) -> Result<TapeAlertFlags, Error> {
+ self.sg_tape.tape_alert_flags()
+ }
+
+ /// Set or clear encryption key
+ ///
+ /// Note: Only 'root' can read secret encryption keys, so we need
+ /// to spawn setuid binary 'sg-tape-cmd'.
+ fn set_encryption(
+ &mut self,
+ key_fingerprint: Option<(Fingerprint, Uuid)>,
+ ) -> Result<(), Error> {
+
+ if nix::unistd::Uid::effective().is_root() {
+
+ if let Some((ref key_fingerprint, ref uuid)) = key_fingerprint {
+
+ let (key_map, _digest) = config::tape_encryption_keys::load_keys()?;
+ match key_map.get(key_fingerprint) {
+ Some(item) => {
+
+ // derive specialized key for each media-set
+
+ let mut tape_key = [0u8; 32];
+
+ let uuid_bytes: [u8; 16] = uuid.as_bytes().clone();
+
+ openssl::pkcs5::pbkdf2_hmac(
+ &item.key,
+ &uuid_bytes,
+ 10,
+ openssl::hash::MessageDigest::sha256(),
+ &mut tape_key)?;
+
+ return self.sg_tape.set_encryption(Some(tape_key));
+ }
+ None => bail!("unknown tape encryption key '{}'", key_fingerprint),
+ }
+ } else {
+ return self.sg_tape.set_encryption(None);
+ }
+ }
+
+ let output = if let Some((fingerprint, uuid)) = key_fingerprint {
+ let fingerprint = crate::tools::format::as_fingerprint(fingerprint.bytes());
+ run_sg_tape_cmd("encryption", &[
+ "--fingerprint", &fingerprint,
+ "--uuid", &uuid.to_string(),
+ ], self.sg_tape.file_mut().as_raw_fd())?
+ } else {
+ run_sg_tape_cmd("encryption", &[], self.sg_tape.file_mut().as_raw_fd())?
+ };
+ let result: Result<(), String> = serde_json::from_str(&output)?;
+ result.map_err(|err| format_err!("{}", err))
+ }
+}
+
+/// Check for correct Major/Minor numbers
+pub fn check_tape_is_lto_tape_device(file: &File) -> Result<(), Error> {
+
+ let stat = nix::sys::stat::fstat(file.as_raw_fd())?;
+
+ let devnum = stat.st_rdev;
+
+ let major = unsafe { libc::major(devnum) };
+ let _minor = unsafe { libc::minor(devnum) };
+
+ if major == 9 {
+ bail!("not a scsi-generic tape device (cannot use linux tape devices)");
+ }
+
+ if major != 21 {
+ bail!("not a scsi-generic tape device");
+ }
+
+ Ok(())
+}
+
+/// Opens a Lto tape device
+///
+/// The open call use O_NONBLOCK, but that flag is cleard after open
+/// succeeded. This also checks if the device is a non-rewinding tape
+/// device.
+pub fn open_lto_tape_device(
+ path: &str,
+) -> Result<File, Error> {
+
+ let file = OpenOptions::new()
+ .read(true)
+ .write(true)
+ .custom_flags(libc::O_NONBLOCK)
+ .open(path)?;
+
+ // clear O_NONBLOCK from now on.
+
+ let flags = fcntl(file.as_raw_fd(), FcntlArg::F_GETFL)
+ .into_io_result()?;
+
+ let mut flags = OFlag::from_bits_truncate(flags);
+ flags.remove(OFlag::O_NONBLOCK);
+
+ fcntl(file.as_raw_fd(), FcntlArg::F_SETFL(flags))
+ .into_io_result()?;
+
+ check_tape_is_lto_tape_device(&file)
+ .map_err(|err| format_err!("device type check {:?} failed - {}", path, err))?;
+
+ Ok(file)
+}
+
+fn run_sg_tape_cmd(subcmd: &str, args: &[&str], fd: RawFd) -> Result<String, Error> {
+ let mut command = std::process::Command::new(
+ "/usr/lib/x86_64-linux-gnu/proxmox-backup/sg-tape-cmd");
+ command.args(&[subcmd]);
+ command.args(&["--stdin"]);
+ command.args(args);
+ let device_fd = nix::unistd::dup(fd)?;
+ command.stdin(unsafe { std::process::Stdio::from_raw_fd(device_fd)});
+ run_command(command, None)
+}
diff --git a/src/tape/drive/lto/sg_tape.rs b/src/tape/drive/lto/sg_tape.rs
new file mode 100644
index 00000000..802756fa
--- /dev/null
+++ b/src/tape/drive/lto/sg_tape.rs
@@ -0,0 +1,445 @@
+use std::time::SystemTime;
+use std::fs::{File, OpenOptions};
+use std::os::unix::fs::OpenOptionsExt;
+use std::os::unix::io::AsRawFd;
+use std::path::Path;
+
+use anyhow::{bail, format_err, Error};
+use endian_trait::Endian;
+use nix::fcntl::{fcntl, FcntlArg, OFlag};
+
+use proxmox::{
+ sys::error::SysResult,
+ tools::io::ReadExt,
+};
+
+use crate::{
+ api2::types::{
+ MamAttribute,
+ },
+ tape::{
+ BlockRead,
+ BlockReadStatus,
+ BlockWrite,
+ file_formats::{
+ BlockedWriter,
+ BlockedReader,
+ },
+ drive::{
+ TapeAlertFlags,
+ Lp17VolumeStatistics,
+ read_mam_attributes,
+ read_tape_alert_flags,
+ read_volume_statistics,
+ set_encryption,
+ },
+ },
+ tools::sgutils2::{
+ SgRaw,
+ SenseInfo,
+ ScsiError,
+ InquiryInfo,
+ scsi_inquiry,
+ },
+};
+
+#[repr(C, packed)]
+#[derive(Endian, Debug, Copy, Clone)]
+pub struct ReadPositionLongPage {
+ flags: u8,
+ reserved: [u8;3],
+ partition_number: u32,
+ pub logical_object_number: u64,
+ pub logical_file_id: u64,
+ obsolete: [u8;8],
+}
+
+pub struct SgTape {
+ file: File,
+}
+
+impl SgTape {
+
+ const SCSI_TAPE_DEFAULT_TIMEOUT: usize = 60*2; // 2 minutes
+
+ /// Create a new instance
+ ///
+ /// Uses scsi_inquiry to check the device type.
+ pub fn new(mut file: File) -> Result<Self, Error> {
+
+ let info = scsi_inquiry(&mut file)?;
+
+ if info.peripheral_type != 1 {
+ bail!("not a tape device (peripheral_type = {})", info.peripheral_type);
+ }
+ Ok(Self { file })
+ }
+
+ pub fn open<P: AsRef<Path>>(path: P) -> Result<SgTape, Error> {
+ // do not wait for media, use O_NONBLOCK
+ let file = OpenOptions::new()
+ .read(true)
+ .write(true)
+ .custom_flags(libc::O_NONBLOCK)
+ .open(path)?;
+
+ // then clear O_NONBLOCK
+ let flags = fcntl(file.as_raw_fd(), FcntlArg::F_GETFL)
+ .into_io_result()?;
+
+ let mut flags = OFlag::from_bits_truncate(flags);
+ flags.remove(OFlag::O_NONBLOCK);
+
+ fcntl(file.as_raw_fd(), FcntlArg::F_SETFL(flags))
+ .into_io_result()?;
+
+ Self::new(file)
+ }
+
+ pub fn inquiry(&mut self) -> Result<InquiryInfo, Error> {
+ scsi_inquiry(&mut self.file)
+ }
+
+ pub fn erase_media(&mut self, _fast: bool) -> Result<(), Error> {
+ // fixme:
+ unimplemented!();
+ }
+
+ pub fn rewind(&mut self) -> Result<(), Error> {
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x01, 0, 0, 0, 0, 0]); // REWIND
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("rewind failed - {}", err))?;
+
+ Ok(())
+ }
+
+ pub fn position(&mut self) -> Result<ReadPositionLongPage, Error> {
+
+ let expected_size = std::mem::size_of::<ReadPositionLongPage>();
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 32)?;
+ sg_raw.set_timeout(30); // use short timeout
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x34, 0x06, 0, 0, 0, 0, 0, 0, 0, 0]); // READ POSITION LONG FORM
+
+ let data = sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("read position failed - {}", err))?;
+
+ let page = proxmox::try_block!({
+ if data.len() != expected_size {
+ bail!("got unexpected data len ({} != {}", data.len(), expected_size);
+ }
+
+ let mut reader = &data[..];
+
+ let page: ReadPositionLongPage = unsafe { reader.read_be_value()? };
+
+ Ok(page)
+ }).map_err(|err: Error| format_err!("decode position page failed - {}", err))?;
+
+ if page.partition_number != 0 {
+ bail!("detecthed partitioned tape - not supported");
+ }
+
+ println!("DATA: {:?}", page);
+
+ Ok(page)
+ }
+
+ pub fn current_file_number(&mut self) -> Result<u64, Error> {
+ let position = self.position()?;
+ Ok(position.logical_file_id)
+ }
+
+ pub fn locate(&mut self) -> Result<(), Error> {
+ // fixme: impl LOCATE
+ unimplemented!();
+ }
+
+ pub fn move_to_eom(&mut self) -> Result<(), Error> {
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x11, 0x03, 0, 0, 0, 0]); // SPACE(6) move to EOD
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("move to EOD failed - {}", err))?;
+
+ Ok(())
+ }
+
+ pub fn space_filemarks(&mut self, count: isize) -> Result<(), Error> {
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+
+ // Use short command if possible (supported by all drives)
+ if (count <= 0x7fffff) && (count > -0x7fffff) {
+ cmd.extend(&[0x11, 0x01]); // SPACE(6) with filemarks
+ cmd.push(((count >> 16) & 0xff) as u8);
+ cmd.push(((count >> 8) & 0xff) as u8);
+ cmd.push((count & 0xff) as u8);
+ cmd.push(0); //control byte
+ } else {
+
+ cmd.extend(&[0x91, 0x01, 0, 0]); // SPACE(16) with filemarks
+ let count: i64 = count as i64;
+ cmd.extend(&count.to_be_bytes());
+ cmd.extend(&[0, 0, 0, 0]);
+ }
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("space filemarks failed - {}", err))?;
+
+ Ok(())
+ }
+
+ pub fn eject(&mut self) -> Result<(), Error> {
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x1B, 0, 0, 0, 0, 0]); // LODA/UNLOAD HOLD=0, LOAD=0
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("eject failed - {}", err))?;
+
+ Ok(())
+ }
+
+ pub fn load(&mut self) -> Result<(), Error> {
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x1B, 0, 0, 0, 0b0000_0001, 0]); // LODA/UNLOAD HOLD=0, LOAD=1
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("load media failed - {}", err))?;
+
+ Ok(())
+ }
+
+ pub fn write_filemarks(
+ &mut self,
+ count: usize,
+ immediate: bool,
+ ) -> Result<(), std::io::Error> {
+
+ if count > 255 {
+ proxmox::io_bail!("write_filemarks failed: got strange count '{}'", count);
+ }
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)
+ .map_err(|err| proxmox::io_format_err!("write_filemarks failed (alloc) - {}", err))?;
+
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.push(0x10);
+ if immediate {
+ cmd.push(1); // IMMED=1
+ } else {
+ cmd.push(0); // IMMED=0
+ }
+ cmd.extend(&[0, 0, count as u8]); // COUNT
+ cmd.push(0); // control byte
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| proxmox::io_format_err!("write filemark failed - {}", err))?;
+
+ Ok(())
+ }
+
+ // Flush tape buffers (WEOF with count 0 => flush)
+ pub fn sync(&mut self) -> Result<(), std::io::Error> {
+ self.write_filemarks(0, false)?;
+ Ok(())
+ }
+
+ pub fn test_unit_ready(&mut self) -> Result<bool, Error> {
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(30); // use short timeout
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x00, 0, 0, 0, 0, 0]); // TEST UNIT READY
+
+ // fixme: check sense
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("unit not ready - {}", err))?;
+
+ Ok(true)
+
+ }
+
+ pub fn wait_until_ready(&mut self) -> Result<(), Error> {
+
+ let start = SystemTime::now();
+ let max_wait = std::time::Duration::new(Self::SCSI_TAPE_DEFAULT_TIMEOUT as u64, 0);
+
+ loop {
+ match self.test_unit_ready() {
+ Ok(true) => return Ok(()),
+ _ => {
+ std::thread::sleep(std::time::Duration::new(1, 0));
+ if start.elapsed()? > max_wait {
+ bail!("wait_until_ready failed - got timeout");
+ }
+ }
+ }
+ }
+ }
+
+ /// Read Tape Alert Flags
+ pub fn tape_alert_flags(&mut self) -> Result<TapeAlertFlags, Error> {
+ read_tape_alert_flags(&mut self.file)
+ }
+
+ /// Read Cartridge Memory (MAM Attributes)
+ pub fn cartridge_memory(&mut self) -> Result<Vec<MamAttribute>, Error> {
+ read_mam_attributes(&mut self.file)
+ }
+
+ /// Read Volume Statistics
+ pub fn volume_statistics(&mut self) -> Result<Lp17VolumeStatistics, Error> {
+ return read_volume_statistics(&mut self.file);
+ }
+
+ pub fn set_encryption(
+ &mut self,
+ key: Option<[u8; 32]>,
+ ) -> Result<(), Error> {
+ set_encryption(&mut self.file, key)
+ }
+
+ // Note: use alloc_page_aligned_buffer to alloc data transfer buffer
+ //
+ // Returns true if the drive reached the Logical End Of Media (early warning)
+ fn write_block(&mut self, data: &[u8]) -> Result<bool, std::io::Error> {
+
+ let transfer_len = data.len();
+
+ if transfer_len > 0xFFFFFF {
+ proxmox::io_bail!("write failed - data too large");
+ }
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 0)
+ .unwrap(); // cannot fail with size 0
+
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.push(0x0A); // WRITE
+ cmd.push(0x00); // VARIABLE SIZED BLOCKS
+ cmd.push(((transfer_len >> 16) & 0xff) as u8);
+ cmd.push(((transfer_len >> 8) & 0xff) as u8);
+ cmd.push((transfer_len & 0xff) as u8);
+ cmd.push(0); // control byte
+
+ //println!("WRITE {:?}", cmd);
+ //println!("WRITE {:?}", data);
+
+ sg_raw.do_out_command(&cmd, data)
+ .map_err(|err| proxmox::io_format_err!("write failed - {}", err))?;
+
+ // fixme: LEOM?
+
+ Ok(false)
+ }
+
+ fn read_block(&mut self, buffer: &mut [u8]) -> Result<BlockReadStatus, std::io::Error> {
+ let transfer_len = buffer.len();
+
+ if transfer_len > 0xFFFFFF {
+ proxmox::io_bail!("read failed - buffer too large");
+ }
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 0)
+ .unwrap(); // cannot fail with size 0
+
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.push(0x08); // READ
+ cmd.push(0x02); // VARIABLE SIZED BLOCKS, SILI=1
+ //cmd.push(0x00); // VARIABLE SIZED BLOCKS, SILI=0
+ cmd.push(((transfer_len >> 16) & 0xff) as u8);
+ cmd.push(((transfer_len >> 8) & 0xff) as u8);
+ cmd.push((transfer_len & 0xff) as u8);
+ cmd.push(0); // control byte
+
+ let data = match sg_raw.do_in_command(&cmd, buffer) {
+ Ok(data) => data,
+ Err(ScsiError::Sense(SenseInfo { sense_key: 0, asc: 0, ascq: 1 })) => {
+ return Ok(BlockReadStatus::EndOfFile);
+ }
+ Err(ScsiError::Sense(SenseInfo { sense_key: 8, asc: 0, ascq: 5 })) => {
+ return Ok(BlockReadStatus::EndOfStream);
+ }
+ Err(err) => {
+ println!("READ ERR {:?}", err);
+ proxmox::io_bail!("read failed - {}", err);
+ }
+ };
+
+ if data.len() != transfer_len {
+ proxmox::io_bail!("read failed - unexpected block len ({} != {})", data.len(), buffer.len())
+ }
+
+ Ok(BlockReadStatus::Ok(transfer_len))
+ }
+
+ pub fn open_writer(&mut self) -> BlockedWriter<SgTapeWriter> {
+ let writer = SgTapeWriter::new(self);
+ BlockedWriter::new(writer)
+ }
+
+ pub fn open_reader(&mut self) -> Result<Option<BlockedReader<SgTapeReader>>, std::io::Error> {
+ let reader = SgTapeReader::new(self);
+ match BlockedReader::open(reader)? {
+ Some(reader) => Ok(Some(reader)),
+ None => Ok(None),
+ }
+ }
+}
+
+pub struct SgTapeReader<'a> {
+ sg_tape: &'a mut SgTape,
+}
+
+impl <'a> SgTapeReader<'a> {
+
+ pub fn new(sg_tape: &'a mut SgTape) -> Self {
+ Self { sg_tape }
+ }
+}
+
+impl <'a> BlockRead for SgTapeReader<'a> {
+
+ fn read_block(&mut self, buffer: &mut [u8]) -> Result<BlockReadStatus, std::io::Error> {
+ self.sg_tape.read_block(buffer)
+ }
+}
+
+pub struct SgTapeWriter<'a> {
+ sg_tape: &'a mut SgTape,
+ _leom_sent: bool,
+}
+
+impl <'a> SgTapeWriter<'a> {
+
+ pub fn new(sg_tape: &'a mut SgTape) -> Self {
+ Self { sg_tape, _leom_sent: false }
+ }
+}
+
+impl <'a> BlockWrite for SgTapeWriter<'a> {
+
+ fn write_block(&mut self, buffer: &[u8]) -> Result<bool, std::io::Error> {
+ self.sg_tape.write_block(buffer)
+ }
+
+ fn write_filemark(&mut self) -> Result<(), std::io::Error> {
+ self.sg_tape.write_filemarks(1, true)
+ }
+}
diff --git a/src/tape/drive/mod.rs b/src/tape/drive/mod.rs
index 5509728c..71f61642 100644
--- a/src/tape/drive/mod.rs
+++ b/src/tape/drive/mod.rs
@@ -13,8 +13,8 @@ pub use volume_statistics::*;
mod encryption;
pub use encryption::*;
-mod linux_tape;
-pub use linux_tape::*;
+mod lto;
+pub use lto::*;
mod mam;
pub use mam::*;
@@ -49,7 +49,7 @@ use crate::{
},
api2::types::{
VirtualTapeDrive,
- LinuxTapeDrive,
+ LtoTapeDrive,
},
server::{
send_load_media_email,
@@ -263,8 +263,8 @@ pub fn media_changer(
let tape = VirtualTapeDrive::deserialize(config)?;
Ok(Some((Box::new(tape), drive.to_string())))
}
- "linux" => {
- let drive_config = LinuxTapeDrive::deserialize(config)?;
+ "lto" => {
+ let drive_config = LtoTapeDrive::deserialize(config)?;
match drive_config.changer {
Some(ref changer_name) => {
let changer = MtxMediaChanger::with_drive_config(&drive_config)?;
@@ -317,8 +317,8 @@ pub fn open_drive(
let handle = tape.open()?;
Ok(Box::new(handle))
}
- "linux" => {
- let tape = LinuxTapeDrive::deserialize(config)?;
+ "lto" => {
+ let tape = LtoTapeDrive::deserialize(config)?;
let handle = tape.open()?;
Ok(Box::new(handle))
}
@@ -379,8 +379,8 @@ pub fn request_and_load_media(
Ok((handle, media_id))
}
- "linux" => {
- let drive_config = LinuxTapeDrive::deserialize(config)?;
+ "lto" => {
+ let drive_config = LtoTapeDrive::deserialize(config)?;
let label_text = label.label_text.clone();
@@ -546,8 +546,8 @@ fn tape_device_path(
"virtual" => {
VirtualTapeDrive::deserialize(config)?.path
}
- "linux" => {
- LinuxTapeDrive::deserialize(config)?.path
+ "lto" => {
+ LtoTapeDrive::deserialize(config)?.path
}
_ => bail!("unknown drive type '{}' - internal error"),
};
diff --git a/src/tape/linux_list_drives.rs b/src/tape/linux_list_drives.rs
index dacbda2c..78ee6e42 100644
--- a/src/tape/linux_list_drives.rs
+++ b/src/tape/linux_list_drives.rs
@@ -12,14 +12,14 @@ use crate::{
tools::fs::scan_subdir,
};
+lazy_static::lazy_static!{
+ static ref SCSI_GENERIC_NAME_REGEX: regex::Regex =
+ regex::Regex::new(r"^sg\d+$").unwrap();
+}
+
/// List linux tape changer devices
pub fn linux_tape_changer_list() -> Vec<TapeDeviceInfo> {
- lazy_static::lazy_static!{
- static ref SCSI_GENERIC_NAME_REGEX: regex::Regex =
- regex::Regex::new(r"^sg\d+$").unwrap();
- }
-
let mut list = Vec::new();
let dir_iter = match scan_subdir(
@@ -111,20 +111,15 @@ pub fn linux_tape_changer_list() -> Vec<TapeDeviceInfo> {
list
}
-/// List linux tape devices (non-rewinding)
-pub fn linux_tape_device_list() -> Vec<TapeDeviceInfo> {
-
- lazy_static::lazy_static!{
- static ref NST_TAPE_NAME_REGEX: regex::Regex =
- regex::Regex::new(r"^nst\d+$").unwrap();
- }
+/// List LTO drives
+pub fn lto_tape_device_list() -> Vec<TapeDeviceInfo> {
let mut list = Vec::new();
let dir_iter = match scan_subdir(
libc::AT_FDCWD,
- "/sys/class/scsi_tape",
- &NST_TAPE_NAME_REGEX)
+ "/sys/class/scsi_generic",
+ &SCSI_GENERIC_NAME_REGEX)
{
Err(_) => return list,
Ok(iter) => iter,
@@ -138,7 +133,7 @@ pub fn linux_tape_device_list() -> Vec<TapeDeviceInfo> {
let name = item.file_name().to_str().unwrap().to_string();
- let mut sys_path = PathBuf::from("/sys/class/scsi_tape");
+ let mut sys_path = PathBuf::from("/sys/class/scsi_generic");
sys_path.push(&name);
let device = match udev::Device::from_syspath(&sys_path) {
@@ -151,6 +146,24 @@ pub fn linux_tape_device_list() -> Vec<TapeDeviceInfo> {
Some(devnum) => devnum,
};
+ let parent = match device.parent() {
+ None => continue,
+ Some(parent) => parent,
+ };
+
+ match parent.attribute_value("type") {
+ Some(type_osstr) => {
+ if type_osstr != "1" {
+ continue;
+ }
+ }
+ _ => { continue; }
+ }
+
+ // let mut test_path = sys_path.clone();
+ // test_path.push("device/scsi_tape");
+ // if !test_path.exists() { continue; }
+
let _dev_path = match device.devnode().map(Path::to_owned) {
None => continue,
Some(dev_path) => dev_path,
@@ -174,7 +187,7 @@ pub fn linux_tape_device_list() -> Vec<TapeDeviceInfo> {
.and_then(|s| if let Ok(s) = s.into_string() { Some(s) } else { None })
.unwrap_or_else(|| String::from("unknown"));
- let dev_path = format!("/dev/tape/by-id/scsi-{}-nst", serial);
+ let dev_path = format!("/dev/tape/by-id/scsi-{}-sg", serial);
if PathBuf::from(&dev_path).exists() {
list.push(TapeDeviceInfo {
@@ -230,13 +243,13 @@ pub fn lookup_device_identification<'a>(
}
}
-/// Make sure path is a linux tape device
+/// Make sure path is a lto tape device
pub fn check_drive_path(
drives: &[TapeDeviceInfo],
path: &str,
) -> Result<(), Error> {
if lookup_device(drives, path).is_none() {
- bail!("path '{}' is not a linux (non-rewinding) tape device", path);
+ bail!("path '{}' is not a lto SCSI-generic tape device", path);
}
Ok(())
}
@@ -250,5 +263,5 @@ pub fn complete_changer_path(_arg: &str, _param: &HashMap<String, String>) -> Ve
/// List tape device paths
pub fn complete_drive_path(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
- linux_tape_device_list().iter().map(|v| v.path.clone()).collect()
+ lto_tape_device_list().iter().map(|v| v.path.clone()).collect()
}
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 04/11] tape: implement format/erase
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (2 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 03/11] tape: implement LTO userspace driver Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 05/11] tape: fix LEOM handling Dietmar Maurer
` (6 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/api2/tape/drive.rs | 28 ++++++++++-----------
src/bin/pmt.rs | 32 +++++++++++++++++++++++-
src/bin/proxmox-tape.rs | 10 ++++----
src/tape/drive/lto/mod.rs | 9 ++++---
src/tape/drive/lto/sg_tape.rs | 45 +++++++++++++++++++++++++++++++---
src/tape/drive/mod.rs | 6 ++---
src/tape/drive/virtual_tape.rs | 2 +-
www/Utils.js | 2 +-
www/tape/DriveStatus.js | 8 +++---
www/tape/window/Erase.js | 4 +--
10 files changed, 108 insertions(+), 38 deletions(-)
diff --git a/src/api2/tape/drive.rs b/src/api2/tape/drive.rs
index 80d17a27..e354f4c0 100644
--- a/src/api2/tape/drive.rs
+++ b/src/api2/tape/drive.rs
@@ -321,8 +321,8 @@ pub fn unload(
permission: &Permission::Privilege(&["tape", "device", "{drive}"], PRIV_TAPE_WRITE, false),
},
)]
-/// Erase media. Check for label-text if given (cancels if wrong media).
-pub fn erase_media(
+/// Format media. Check for label-text if given (cancels if wrong media).
+pub fn format_media(
drive: String,
fast: Option<bool>,
label_text: Option<String>,
@@ -331,7 +331,7 @@ pub fn erase_media(
let upid_str = run_drive_worker(
rpcenv,
drive.clone(),
- "erase-media",
+ "format-media",
Some(drive.clone()),
move |worker, config| {
if let Some(ref label) = label_text {
@@ -350,15 +350,15 @@ pub fn erase_media(
}
/* assume drive contains no or unrelated data */
task_log!(worker, "unable to read media label: {}", err);
- task_log!(worker, "erase anyways");
- handle.erase_media(fast.unwrap_or(true))?;
+ task_log!(worker, "format anyways");
+ handle.format_media(fast.unwrap_or(true))?;
}
Ok((None, _)) => {
if let Some(label) = label_text {
bail!("expected label '{}', found empty tape", label);
}
- task_log!(worker, "found empty media - erase anyways");
- handle.erase_media(fast.unwrap_or(true))?;
+ task_log!(worker, "found empty media - format anyways");
+ handle.format_media(fast.unwrap_or(true))?;
}
Ok((Some(media_id), _key_config)) => {
if let Some(label_text) = label_text {
@@ -391,7 +391,7 @@ pub fn erase_media(
inventory.remove_media(&media_id.label.uuid)?;
};
- handle.erase_media(fast.unwrap_or(true))?;
+ handle.format_media(fast.unwrap_or(true))?;
}
}
@@ -503,7 +503,7 @@ pub fn eject_media(
/// Write a new media label to the media in 'drive'. The media is
/// assigned to the specified 'pool', or else to the free media pool.
///
-/// Note: The media need to be empty (you may want to erase it first).
+/// Note: The media need to be empty (you may want to format it first).
pub fn label_media(
drive: String,
pool: Option<String>,
@@ -528,7 +528,7 @@ pub fn label_media(
drive.rewind()?;
match drive.read_next_file() {
- Ok(Some(_file)) => bail!("media is not empty (erase first)"),
+ Ok(Some(_file)) => bail!("media is not empty (format it first)"),
Ok(None) => { /* EOF mark at BOT, assume tape is empty */ },
Err(err) => {
println!("TEST {:?}", err);
@@ -1092,7 +1092,7 @@ fn barcode_label_media_worker(
match drive.read_next_file() {
Ok(Some(_file)) => {
- worker.log(format!("media '{}' is not empty (erase first)", label_text));
+ worker.log(format!("media '{}' is not empty (format it first)", label_text));
continue;
}
Ok(None) => { /* EOF mark at BOT, assume tape is empty */ },
@@ -1100,7 +1100,7 @@ fn barcode_label_media_worker(
if err.is_errno(nix::errno::Errno::ENOSPC) || err.is_errno(nix::errno::Errno::EIO) {
/* assume tape is empty */
} else {
- worker.warn(format!("media '{}' read error (maybe not empty - erase first)", label_text));
+ worker.warn(format!("media '{}' read error (maybe not empty - format it first)", label_text));
continue;
}
}
@@ -1430,9 +1430,9 @@ pub const SUBDIRS: SubdirMap = &sorted!([
.post(&API_METHOD_EJECT_MEDIA)
),
(
- "erase-media",
+ "format-media",
&Router::new()
- .post(&API_METHOD_ERASE_MEDIA)
+ .post(&API_METHOD_FORMAT_MEDIA)
),
(
"export-media",
diff --git a/src/bin/pmt.rs b/src/bin/pmt.rs
index df3ad9ec..da0d4fd9 100644
--- a/src/bin/pmt.rs
+++ b/src/bin/pmt.rs
@@ -409,7 +409,7 @@ fn eod(param: Value) -> Result<(), Error> {
},
},
)]
-/// Erase media
+/// Erase media (from current position)
fn erase(fast: Option<bool>, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
@@ -418,6 +418,35 @@ fn erase(fast: Option<bool>, param: Value) -> Result<(), Error> {
Ok(())
}
+#[api(
+ input: {
+ properties: {
+ drive: {
+ schema: DRIVE_NAME_SCHEMA,
+ optional: true,
+ },
+ device: {
+ schema: LTO_DRIVE_PATH_SCHEMA,
+ optional: true,
+ },
+ fast: {
+ description: "Use fast erase.",
+ type: bool,
+ optional: true,
+ default: true,
+ },
+ },
+ },
+)]
+/// Format media, single partition
+fn format(fast: Option<bool>, param: Value) -> Result<(), Error> {
+
+ let mut handle = get_tape_handle(¶m)?;
+ handle.format_media(fast.unwrap_or(true))?;
+
+ Ok(())
+}
+
#[api(
input: {
properties: {
@@ -800,6 +829,7 @@ fn main() -> Result<(), Error> {
.insert("eject", std_cmd(&API_METHOD_EJECT))
.insert("eod", std_cmd(&API_METHOD_EOD))
.insert("erase", std_cmd(&API_METHOD_ERASE))
+ .insert("format", std_cmd(&API_METHOD_FORMAT))
.insert("fsf", std_cmd(&API_METHOD_FSF).arg_param(&["count"]))
.insert("fsfm", std_cmd(&API_METHOD_FSFM).arg_param(&["count"]))
.insert("fsr", std_cmd(&API_METHOD_FSR).arg_param(&["count"]))
diff --git a/src/bin/proxmox-tape.rs b/src/bin/proxmox-tape.rs
index cddac1b4..2a784632 100644
--- a/src/bin/proxmox-tape.rs
+++ b/src/bin/proxmox-tape.rs
@@ -115,8 +115,8 @@ pub fn extract_drive_name(
},
},
)]
-/// Erase media
-async fn erase_media(mut param: Value) -> Result<(), Error> {
+/// Format media
+async fn format_media(mut param: Value) -> Result<(), Error> {
let output_format = get_output_format(¶m);
@@ -126,7 +126,7 @@ async fn erase_media(mut param: Value) -> Result<(), Error> {
let mut client = connect_to_localhost()?;
- let path = format!("api2/json/tape/drive/{}/erase-media", drive);
+ let path = format!("api2/json/tape/drive/{}/format-media", drive);
let result = client.post(&path, Some(param)).await?;
view_task_result(&mut client, result, &output_format).await?;
@@ -992,8 +992,8 @@ fn main() {
.completion_cb("drive", complete_drive_name)
)
.insert(
- "erase",
- CliCommand::new(&API_METHOD_ERASE_MEDIA)
+ "format",
+ CliCommand::new(&API_METHOD_FORMAT_MEDIA)
.completion_cb("drive", complete_drive_name)
)
.insert(
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
index becbad50..a4e0499e 100644
--- a/src/tape/drive/lto/mod.rs
+++ b/src/tape/drive/lto/mod.rs
@@ -179,6 +179,10 @@ impl LtoTapeHandle {
Ok(status)
}
+ pub fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
+ self.sg_tape.erase_media(fast)
+ }
+
pub fn load(&mut self) -> Result<(), Error> {
self.sg_tape.load()
}
@@ -223,9 +227,8 @@ impl TapeDriver for LtoTapeHandle {
self.sg_tape.current_file_number()
}
- fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
- self.rewind()?; // important - erase from BOT
- self.sg_tape.erase_media(fast)
+ fn format_media(&mut self, fast: bool) -> Result<(), Error> {
+ self.sg_tape.format_media(fast)
}
fn read_next_file<'a>(&'a mut self) -> Result<Option<Box<dyn TapeRead + 'a>>, std::io::Error> {
diff --git a/src/tape/drive/lto/sg_tape.rs b/src/tape/drive/lto/sg_tape.rs
index 802756fa..531acbee 100644
--- a/src/tape/drive/lto/sg_tape.rs
+++ b/src/tape/drive/lto/sg_tape.rs
@@ -100,9 +100,48 @@ impl SgTape {
scsi_inquiry(&mut self.file)
}
- pub fn erase_media(&mut self, _fast: bool) -> Result<(), Error> {
- // fixme:
- unimplemented!();
+ /// Erase medium.
+ ///
+ /// EOD is written at the current position, which marks it as end
+ /// of data. After the command is successfully completed, the
+ /// drive is positioned immediately before End Of Data (not End Of
+ /// Tape).
+ pub fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.push(0x19);
+ if fast {
+ cmd.push(0); // LONG=0
+ } else {
+ cmd.push(1); // LONG=1
+ }
+ cmd.extend(&[0, 0, 0, 0]);
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("erase failed - {}", err))?;
+
+ Ok(())
+ }
+
+ /// Format media, single partition
+ pub fn format_media(&mut self, fast: bool) -> Result<(), Error> {
+
+ self.rewind()?;
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x04, 0, 0, 0, 0, 0]);
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("erase failed - {}", err))?;
+
+ if !fast {
+ self.erase_media(false)?; // overwrite everything
+ }
+
+ Ok(())
}
pub fn rewind(&mut self) -> Result<(), Error> {
diff --git a/src/tape/drive/mod.rs b/src/tape/drive/mod.rs
index 71f61642..061c1cfc 100644
--- a/src/tape/drive/mod.rs
+++ b/src/tape/drive/mod.rs
@@ -111,7 +111,7 @@ pub trait TapeDriver {
fn current_file_number(&mut self) -> Result<u64, Error>;
/// Completely erase the media
- fn erase_media(&mut self, fast: bool) -> Result<(), Error>;
+ fn format_media(&mut self, fast: bool) -> Result<(), Error>;
/// Read/Open the next file
fn read_next_file<'a>(&'a mut self) -> Result<Option<Box<dyn TapeRead + 'a>>, std::io::Error>;
@@ -122,11 +122,9 @@ pub trait TapeDriver {
/// Write label to tape (erase tape content)
fn label_tape(&mut self, label: &MediaLabel) -> Result<(), Error> {
- self.rewind()?;
-
self.set_encryption(None)?;
- self.erase_media(true)?;
+ self.format_media(true)?; // this rewinds the tape
let raw = serde_json::to_string_pretty(&serde_json::to_value(&label)?)?;
diff --git a/src/tape/drive/virtual_tape.rs b/src/tape/drive/virtual_tape.rs
index 54e0887f..e4d09c2f 100644
--- a/src/tape/drive/virtual_tape.rs
+++ b/src/tape/drive/virtual_tape.rs
@@ -360,7 +360,7 @@ impl TapeDriver for VirtualTapeHandle {
}
}
- fn erase_media(&mut self, _fast: bool) -> Result<(), Error> {
+ fn format_media(&mut self, _fast: bool) -> Result<(), Error> {
let mut status = self.load_status()?;
match status.current_tape {
Some(VirtualTapeStatus { ref name, ref mut pos }) => {
diff --git a/www/Utils.js b/www/Utils.js
index dc7e539f..b9012374 100644
--- a/www/Utils.js
+++ b/www/Utils.js
@@ -374,7 +374,7 @@ Ext.define('PBS.Utils', {
dircreate: [gettext('Directory Storage'), gettext('Create')],
dirremove: [gettext('Directory'), gettext('Remove')],
'eject-media': [gettext('Drive'), gettext('Eject Media')],
- 'erase-media': [gettext('Drive'), gettext('Erase Media')],
+ "format-media": [gettext('Drive'), gettext('Format media')],
garbage_collection: ['Datastore', gettext('Garbage Collect')],
'inventory-update': [gettext('Drive'), gettext('Inventory Update')],
'label-media': [gettext('Drive'), gettext('Label Media')],
diff --git a/www/tape/DriveStatus.js b/www/tape/DriveStatus.js
index 65197285..2bf05f88 100644
--- a/www/tape/DriveStatus.js
+++ b/www/tape/DriveStatus.js
@@ -84,11 +84,11 @@ Ext.define('PBS.TapeManagement.DriveStatus', {
}).show();
},
- erase: function() {
+ format: function() {
let me = this;
let view = me.getView();
let driveid = view.drive;
- PBS.Utils.driveCommand(driveid, 'erase-media', {
+ PBS.Utils.driveCommand(driveid, 'format-media', {
waitMsgTarget: view,
method: 'POST',
success: function(response) {
@@ -212,9 +212,9 @@ Ext.define('PBS.TapeManagement.DriveStatus', {
},
},
{
- text: gettext('Erase'),
+ text: gettext('Format'),
xtype: 'proxmoxButton',
- handler: 'erase',
+ handler: 'format',
iconCls: 'fa fa-trash-o',
dangerous: true,
confirmMsg: gettext('Are you sure you want to erase the inserted tape?'),
diff --git a/www/tape/window/Erase.js b/www/tape/window/Erase.js
index 61bd2130..1177dfeb 100644
--- a/www/tape/window/Erase.js
+++ b/www/tape/window/Erase.js
@@ -11,13 +11,13 @@ Ext.define('PBS.TapeManagement.EraseWindow', {
return {};
},
- title: gettext('Erase'),
+ title: gettext('Format/Erase'),
url: `/api2/extjs/tape/drive`,
showProgress: true,
submitUrl: function(url, values) {
let drive = values.drive;
delete values.drive;
- return `${url}/${drive}/erase-media`;
+ return `${url}/${drive}/format-media`;
},
method: 'POST',
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 05/11] tape: fix LEOM handling
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (3 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 04/11] tape: implement format/erase Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 06/11] tape: make fsf/bsf driver specific Dietmar Maurer
` (5 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/tape/drive/lto/sg_tape.rs | 57 +++++++++++++++++++++++++++--------
src/tools/sgutils2.rs | 26 ++++++++--------
2 files changed, 57 insertions(+), 26 deletions(-)
diff --git a/src/tape/drive/lto/sg_tape.rs b/src/tape/drive/lto/sg_tape.rs
index 531acbee..fd1a067a 100644
--- a/src/tape/drive/lto/sg_tape.rs
+++ b/src/tape/drive/lto/sg_tape.rs
@@ -75,6 +75,11 @@ impl SgTape {
Ok(Self { file })
}
+ // fixme: remove - only for testing
+ pub fn file_mut(&mut self) -> &mut File {
+ &mut self.file
+ }
+
pub fn open<P: AsRef<Path>>(path: P) -> Result<SgTape, Error> {
// do not wait for media, use O_NONBLOCK
let file = OpenOptions::new()
@@ -195,9 +200,26 @@ impl SgTape {
Ok(position.logical_file_id)
}
- pub fn locate(&mut self) -> Result<(), Error> {
- // fixme: impl LOCATE
- unimplemented!();
+ // fixme: dont use - needs LTO5
+ pub fn locate_file(&mut self, position: u64) -> Result<(), Error> {
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x92, 0b000_01_000, 0, 0]); // LOCATE(16) filemarks
+ cmd.extend(&position.to_be_bytes());
+ cmd.extend(&[0, 0, 0, 0]);
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("locate file {} failed - {}", position, err))?;
+
+ // move to other side of filemark
+ cmd.truncate(0);
+ cmd.extend(&[0x11, 0x01, 0, 0, 1, 0]); // SPACE(6) one filemarks
+
+ sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("locate file {} (space) failed - {}", position, err))?;
+
+ Ok(())
}
pub fn move_to_eom(&mut self) -> Result<(), Error> {
@@ -286,8 +308,15 @@ impl SgTape {
cmd.extend(&[0, 0, count as u8]); // COUNT
cmd.push(0); // control byte
- sg_raw.do_command(&cmd)
- .map_err(|err| proxmox::io_format_err!("write filemark failed - {}", err))?;
+ match sg_raw.do_command(&cmd) {
+ Ok(_) => { /* OK */ }
+ Err(ScsiError::Sense(SenseInfo { sense_key: 0, asc: 0, ascq: 2 })) => {
+ /* LEOM - ignore */
+ }
+ Err(err) => {
+ proxmox::io_bail!("write filemark failed - {}", err);
+ }
+ }
Ok(())
}
@@ -360,7 +389,7 @@ impl SgTape {
let transfer_len = data.len();
- if transfer_len > 0xFFFFFF {
+ if transfer_len > 0x800000 {
proxmox::io_bail!("write failed - data too large");
}
@@ -379,12 +408,15 @@ impl SgTape {
//println!("WRITE {:?}", cmd);
//println!("WRITE {:?}", data);
- sg_raw.do_out_command(&cmd, data)
- .map_err(|err| proxmox::io_format_err!("write failed - {}", err))?;
-
- // fixme: LEOM?
-
- Ok(false)
+ match sg_raw.do_out_command(&cmd, data) {
+ Ok(()) => { return Ok(false) }
+ Err(ScsiError::Sense(SenseInfo { sense_key: 0, asc: 0, ascq: 2 })) => {
+ return Ok(true); // LEOM
+ }
+ Err(err) => {
+ proxmox::io_bail!("write failed - {}", err);
+ }
+ }
}
fn read_block(&mut self, buffer: &mut [u8]) -> Result<BlockReadStatus, std::io::Error> {
@@ -416,7 +448,6 @@ impl SgTape {
return Ok(BlockReadStatus::EndOfStream);
}
Err(err) => {
- println!("READ ERR {:?}", err);
proxmox::io_bail!("read failed - {}", err);
}
};
diff --git a/src/tools/sgutils2.rs b/src/tools/sgutils2.rs
index 987d5738..4edfd9d9 100644
--- a/src/tools/sgutils2.rs
+++ b/src/tools/sgutils2.rs
@@ -203,17 +203,17 @@ struct InquiryPage {
#[repr(C, packed)]
#[derive(Endian, Debug)]
-struct RequestSenseFixed {
- response_code: u8,
+pub struct RequestSenseFixed {
+ pub response_code: u8,
obsolete: u8,
- flags2: u8,
- information: [u8;4],
- additional_sense_len: u8,
- command_specific_information: [u8;4],
- additional_sense_code: u8,
- additional_sense_code_qualifier: u8,
- field_replacable_unit_code: u8,
- sense_key_specific: [u8; 3],
+ pub flags2: u8,
+ pub information: [u8;4],
+ pub additional_sense_len: u8,
+ pub command_specific_information: [u8;4],
+ pub additional_sense_code: u8,
+ pub additional_sense_code_qualifier: u8,
+ pub field_replacable_unit_code: u8,
+ pub sense_key_specific: [u8; 3],
}
#[repr(C, packed)]
@@ -575,15 +575,15 @@ impl <'a, F: AsRawFd> SgRaw<'a, F> {
/// Run dataout command
///
/// Note: use alloc_page_aligned_buffer to alloc data transfer buffer
- pub fn do_out_command(&mut self, cmd: &[u8], data: &[u8]) -> Result<(), Error> {
+ pub fn do_out_command(&mut self, cmd: &[u8], data: &[u8]) -> Result<(), ScsiError> {
if !unsafe { sg_is_scsi_cdb(cmd.as_ptr(), cmd.len() as c_int) } {
- bail!("no valid SCSI command");
+ return Err(format_err!("no valid SCSI command").into());
}
let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) } as usize;
if ((data.as_ptr() as usize) & (page_size -1)) != 0 {
- bail!("wrong transfer buffer alignment");
+ return Err(format_err!("wrong transfer buffer alignment").into());
}
let mut ptvp = self.create_scsi_pt_obj()?;
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 06/11] tape: make fsf/bsf driver specific
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (4 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 05/11] tape: fix LEOM handling Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 07/11] tape: make sure there is a filemark at the end of the tape Dietmar Maurer
` (4 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
Because the virtual tape driver behaves different than LTO drives.
---
src/tape/drive/lto/mod.rs | 31 ++++++++--
src/tape/drive/mod.rs | 19 +-----
src/tape/drive/virtual_tape.rs | 106 +++++++++++++++++++--------------
3 files changed, 89 insertions(+), 67 deletions(-)
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
index a4e0499e..25df897f 100644
--- a/src/tape/drive/lto/mod.rs
+++ b/src/tape/drive/lto/mod.rs
@@ -179,6 +179,14 @@ impl LtoTapeHandle {
Ok(status)
}
+ pub fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
+ self.sg_tape.space_filemarks(isize::try_from(count)?)
+ }
+
+ pub fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
+ self.sg_tape.space_filemarks(-isize::try_from(count)?)
+ }
+
pub fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
self.sg_tape.erase_media(fast)
}
@@ -211,12 +219,25 @@ impl TapeDriver for LtoTapeHandle {
self.sg_tape.move_to_eom()
}
- fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
- self.sg_tape.space_filemarks(isize::try_from(count)?)
- }
+ fn move_to_last_file(&mut self) -> Result<(), Error> {
- fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
- self.sg_tape.space_filemarks(-isize::try_from(count)?)
+ self.move_to_eom()?;
+
+ let pos = self.current_file_number()?;
+
+ if pos == 0 {
+ bail!("move_to_last_file failed - media contains no data");
+ }
+
+ if pos == 1 {
+ self.rewind()?;
+ return Ok(());
+ }
+
+ self.backward_space_count_files(2)?;
+ self.forward_space_count_files(1)?;
+
+ Ok(())
}
fn rewind(&mut self) -> Result<(), Error> {
diff --git a/src/tape/drive/mod.rs b/src/tape/drive/mod.rs
index 061c1cfc..28ff0a3a 100644
--- a/src/tape/drive/mod.rs
+++ b/src/tape/drive/mod.rs
@@ -88,24 +88,7 @@ pub trait TapeDriver {
fn move_to_eom(&mut self) -> Result<(), Error>;
/// Move to last file
- fn move_to_last_file(&mut self) -> Result<(), Error> {
-
- self.move_to_eom()?;
-
- if self.current_file_number()? == 0 {
- bail!("move_to_last_file failed - media contains no data");
- }
-
- self.backward_space_count_files(2)?;
-
- Ok(())
- }
-
- /// Forward space count files. The tape is positioned on the first block of the next file.
- fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error>;
-
- /// Backward space count files. The tape is positioned on the last block of the previous file.
- fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error>;
+ fn move_to_last_file(&mut self) -> Result<(), Error>;
/// Current file number
fn current_file_number(&mut self) -> Result<u64, Error>;
diff --git a/src/tape/drive/virtual_tape.rs b/src/tape/drive/virtual_tape.rs
index e4d09c2f..bb4b4e3c 100644
--- a/src/tape/drive/virtual_tape.rs
+++ b/src/tape/drive/virtual_tape.rs
@@ -181,6 +181,53 @@ impl VirtualTapeHandle {
Ok(list)
}
+ #[allow(dead_code)]
+ fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
+ let mut status = self.load_status()?;
+ match status.current_tape {
+ Some(VirtualTapeStatus { ref name, ref mut pos }) => {
+
+ let index = self.load_tape_index(name)
+ .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
+
+ let new_pos = *pos + count;
+ if new_pos <= index.files {
+ *pos = new_pos;
+ } else {
+ bail!("forward_space_count_files failed: move beyond EOT");
+ }
+
+ self.store_status(&status)
+ .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
+
+ Ok(())
+ }
+ None => bail!("drive is empty (no tape loaded)."),
+ }
+ }
+
+ // Note: behavior differs from LTO, because we always position at
+ // EOT side.
+ fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
+ let mut status = self.load_status()?;
+ match status.current_tape {
+ Some(VirtualTapeStatus { ref mut pos, .. }) => {
+
+ if count <= *pos {
+ *pos = *pos - count;
+ } else {
+ bail!("backward_space_count_files failed: move before BOT");
+ }
+
+ self.store_status(&status)
+ .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
+
+ Ok(())
+ }
+ None => bail!("drive is empty (no tape loaded)."),
+ }
+ }
+
}
impl TapeDriver for VirtualTapeHandle {
@@ -199,6 +246,21 @@ impl TapeDriver for VirtualTapeHandle {
}
}
+ /// Move to last file
+ fn move_to_last_file(&mut self) -> Result<(), Error> {
+
+ self.move_to_eom()?;
+
+ if self.current_file_number()? == 0 {
+ bail!("move_to_last_file failed - media contains no data");
+ }
+
+ self.backward_space_count_files(1)?;
+
+ Ok(())
+ }
+
+
fn read_next_file(&mut self) -> Result<Option<Box<dyn TapeRead>>, io::Error> {
let mut status = self.load_status()
.map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
@@ -304,50 +366,6 @@ impl TapeDriver for VirtualTapeHandle {
}
}
- fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
- let mut status = self.load_status()?;
- match status.current_tape {
- Some(VirtualTapeStatus { ref name, ref mut pos }) => {
-
- let index = self.load_tape_index(name)
- .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
-
- let new_pos = *pos + count;
- if new_pos <= index.files {
- *pos = new_pos;
- } else {
- bail!("forward_space_count_files failed: move beyond EOT");
- }
-
- self.store_status(&status)
- .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
-
- Ok(())
- }
- None => bail!("drive is empty (no tape loaded)."),
- }
- }
-
- fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
- let mut status = self.load_status()?;
- match status.current_tape {
- Some(VirtualTapeStatus { ref mut pos, .. }) => {
-
- if count <= *pos {
- *pos = *pos - count;
- } else {
- bail!("backward_space_count_files failed: move before BOT");
- }
-
- self.store_status(&status)
- .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
-
- Ok(())
- }
- None => bail!("drive is empty (no tape loaded)."),
- }
- }
-
fn rewind(&mut self) -> Result<(), Error> {
let mut status = self.load_status()?;
match status.current_tape {
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 07/11] tape: make sure there is a filemark at the end of the tape
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (5 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 06/11] tape: make fsf/bsf driver specific Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 08/11] sgutils2: add scsi_mode_sense helper Dietmar Maurer
` (3 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/bin/pmt.rs | 2 +-
src/bin/proxmox-tape.rs | 2 +-
src/tape/drive/lto/mod.rs | 8 ++--
src/tape/drive/lto/sg_tape.rs | 71 +++++++++++++++++++++++++++++-----
src/tape/drive/mod.rs | 6 ++-
src/tape/drive/virtual_tape.rs | 4 +-
src/tape/pool_writer/mod.rs | 2 +-
7 files changed, 75 insertions(+), 20 deletions(-)
diff --git a/src/bin/pmt.rs b/src/bin/pmt.rs
index da0d4fd9..854364c7 100644
--- a/src/bin/pmt.rs
+++ b/src/bin/pmt.rs
@@ -383,7 +383,7 @@ fn eject(param: Value) -> Result<(), Error> {
fn eod(param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- handle.move_to_eom()?;
+ handle.move_to_eom(false)?;
Ok(())
}
diff --git a/src/bin/proxmox-tape.rs b/src/bin/proxmox-tape.rs
index 2a784632..f1de6236 100644
--- a/src/bin/proxmox-tape.rs
+++ b/src/bin/proxmox-tape.rs
@@ -551,7 +551,7 @@ fn move_to_eom(mut param: Value) -> Result<(), Error> {
let mut drive = open_drive(&config, &drive)?;
- drive.move_to_eom()?;
+ drive.move_to_eom(false)?;
Ok(())
}
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
index 25df897f..7fcef8a0 100644
--- a/src/tape/drive/lto/mod.rs
+++ b/src/tape/drive/lto/mod.rs
@@ -215,13 +215,15 @@ impl TapeDriver for LtoTapeHandle {
}
/// Go to the end of the recorded media (for appending files).
- fn move_to_eom(&mut self) -> Result<(), Error> {
- self.sg_tape.move_to_eom()
+ fn move_to_eom(&mut self, write_missing_eof: bool) -> Result<(), Error> {
+ self.sg_tape.move_to_eom(write_missing_eof)
}
fn move_to_last_file(&mut self) -> Result<(), Error> {
- self.move_to_eom()?;
+ self.move_to_eom(false)?;
+
+ self.sg_tape.check_filemark()?;
let pos = self.current_file_number()?;
diff --git a/src/tape/drive/lto/sg_tape.rs b/src/tape/drive/lto/sg_tape.rs
index fd1a067a..9af0eae3 100644
--- a/src/tape/drive/lto/sg_tape.rs
+++ b/src/tape/drive/lto/sg_tape.rs
@@ -190,8 +190,6 @@ impl SgTape {
bail!("detecthed partitioned tape - not supported");
}
- println!("DATA: {:?}", page);
-
Ok(page)
}
@@ -222,7 +220,35 @@ impl SgTape {
Ok(())
}
- pub fn move_to_eom(&mut self) -> Result<(), Error> {
+ /// Check if we are positioned after a filemark (or BOT)
+ pub fn check_filemark(&mut self) -> Result<bool, Error> {
+
+ let pos = self.position()?;
+ if pos.logical_object_number == 0 {
+ // at BOT, Ok (no filemark required)
+ return Ok(true);
+ }
+
+ // Note: SPACE blocks returns Err at filemark
+ match self.space(-1, true) {
+ Ok(_) => {
+ self.space(1, true) // move back to end
+ .map_err(|err| format_err!("check_filemark failed (space forward) - {}", err))?;
+ Ok(false)
+ }
+ Err(ScsiError::Sense(SenseInfo { sense_key: 0, asc: 0, ascq: 1 })) => {
+ // Filemark detected - good
+ self.space(1, true) // move back to end
+ .map_err(|err| format_err!("check_filemark failed (space forward) - {}", err))?;
+ Ok(true)
+ }
+ Err(err) => {
+ bail!("check_filemark failed - {:?}", err);
+ }
+ }
+ }
+
+ pub fn move_to_eom(&mut self, write_missing_eof: bool) -> Result<(), Error> {
let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
let mut cmd = Vec::new();
@@ -231,35 +257,60 @@ impl SgTape {
sg_raw.do_command(&cmd)
.map_err(|err| format_err!("move to EOD failed - {}", err))?;
+ if write_missing_eof {
+ if !self.check_filemark()? {
+ self.write_filemarks(1, false)?;
+ }
+ }
+
Ok(())
}
- pub fn space_filemarks(&mut self, count: isize) -> Result<(), Error> {
+ fn space(&mut self, count: isize, blocks: bool) -> Result<(), ScsiError> {
let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
let mut cmd = Vec::new();
// Use short command if possible (supported by all drives)
if (count <= 0x7fffff) && (count > -0x7fffff) {
- cmd.extend(&[0x11, 0x01]); // SPACE(6) with filemarks
+ cmd.push(0x11); // SPACE(6)
+ if blocks {
+ cmd.push(0); // blocks
+ } else {
+ cmd.push(1); // filemarks
+ }
cmd.push(((count >> 16) & 0xff) as u8);
cmd.push(((count >> 8) & 0xff) as u8);
cmd.push((count & 0xff) as u8);
cmd.push(0); //control byte
} else {
-
- cmd.extend(&[0x91, 0x01, 0, 0]); // SPACE(16) with filemarks
+ cmd.push(0x91); // SPACE(16)
+ if blocks {
+ cmd.push(0); // blocks
+ } else {
+ cmd.push(1); // filemarks
+ }
+ cmd.extend(&[0, 0]); // reserved
let count: i64 = count as i64;
cmd.extend(&count.to_be_bytes());
- cmd.extend(&[0, 0, 0, 0]);
+ cmd.extend(&[0, 0, 0, 0]); // reserved
}
- sg_raw.do_command(&cmd)
- .map_err(|err| format_err!("space filemarks failed - {}", err))?;
+ sg_raw.do_command(&cmd)?;
Ok(())
}
+ pub fn space_filemarks(&mut self, count: isize) -> Result<(), Error> {
+ self.space(count, false)
+ .map_err(|err| format_err!("space filemarks failed - {}", err))
+ }
+
+ pub fn space_blocks(&mut self, count: isize) -> Result<(), Error> {
+ self.space(count, true)
+ .map_err(|err| format_err!("space blocks failed - {}", err))
+ }
+
pub fn eject(&mut self) -> Result<(), Error> {
let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
diff --git a/src/tape/drive/mod.rs b/src/tape/drive/mod.rs
index 28ff0a3a..cd02e16d 100644
--- a/src/tape/drive/mod.rs
+++ b/src/tape/drive/mod.rs
@@ -84,8 +84,10 @@ pub trait TapeDriver {
/// Move to end of recorded data
///
- /// We assume this flushes the tape write buffer.
- fn move_to_eom(&mut self) -> Result<(), Error>;
+ /// We assume this flushes the tape write buffer. if
+ /// write_missing_eof is true, we verify that there is a filemark
+ /// at the end. If not, we write one.
+ fn move_to_eom(&mut self, write_missing_eof: bool) -> Result<(), Error>;
/// Move to last file
fn move_to_last_file(&mut self) -> Result<(), Error>;
diff --git a/src/tape/drive/virtual_tape.rs b/src/tape/drive/virtual_tape.rs
index bb4b4e3c..a852056a 100644
--- a/src/tape/drive/virtual_tape.rs
+++ b/src/tape/drive/virtual_tape.rs
@@ -249,7 +249,7 @@ impl TapeDriver for VirtualTapeHandle {
/// Move to last file
fn move_to_last_file(&mut self) -> Result<(), Error> {
- self.move_to_eom()?;
+ self.move_to_eom(false)?;
if self.current_file_number()? == 0 {
bail!("move_to_last_file failed - media contains no data");
@@ -347,7 +347,7 @@ impl TapeDriver for VirtualTapeHandle {
}
}
- fn move_to_eom(&mut self) -> Result<(), Error> {
+ fn move_to_eom(&mut self, _write_missing_eof: bool) -> Result<(), Error> {
let mut status = self.load_status()?;
match status.current_tape {
Some(VirtualTapeStatus { ref name, ref mut pos }) => {
diff --git a/src/tape/pool_writer/mod.rs b/src/tape/pool_writer/mod.rs
index 05aa52a4..99fdb48c 100644
--- a/src/tape/pool_writer/mod.rs
+++ b/src/tape/pool_writer/mod.rs
@@ -297,7 +297,7 @@ impl PoolWriter {
if !status.at_eom {
worker.log(String::from("moving to end of media"));
- status.drive.move_to_eom()?;
+ status.drive.move_to_eom(true)?;
status.at_eom = true;
}
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 08/11] sgutils2: add scsi_mode_sense helper
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (6 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 07/11] tape: make sure there is a filemark at the end of the tape Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 09/11] tape: correctly set/display drive option Dietmar Maurer
` (2 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/tools/sgutils2.rs | 99 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 99 insertions(+)
diff --git a/src/tools/sgutils2.rs b/src/tools/sgutils2.rs
index 4edfd9d9..af6ab6de 100644
--- a/src/tools/sgutils2.rs
+++ b/src/tools/sgutils2.rs
@@ -242,6 +242,46 @@ pub struct InquiryInfo {
pub revision: String,
}
+#[repr(C, packed)]
+#[derive(Endian, Debug, Copy, Clone)]
+pub struct ModeParameterHeader {
+ pub mode_data_len: u16,
+ pub medium_type: u8,
+ pub flags3: u8,
+ reserved4: [u8;2],
+ pub block_descriptior_len: u16,
+}
+
+#[repr(C, packed)]
+#[derive(Endian, Debug, Copy, Clone)]
+/// SCSI ModeBlockDescriptor for Tape devices
+pub struct ModeBlockDescriptor {
+ pub density_code: u8,
+ pub number_of_blocks: [u8;3],
+ reserverd: u8,
+ pub block_length: [u8; 3],
+}
+
+impl ModeBlockDescriptor {
+
+ pub fn block_length(&self) -> u32 {
+ ((self.block_length[0] as u32) << 16) +
+ ((self.block_length[1] as u32) << 8) +
+ (self.block_length[2] as u32)
+
+ }
+
+ pub fn set_block_length(&mut self, length: u32) -> Result<(), Error> {
+ if length > 0x80_00_00 {
+ bail!("block length '{}' is too large", length);
+ }
+ self.block_length[0] = ((length & 0x00ff0000) >> 16) as u8;
+ self.block_length[1] = ((length & 0x0000ff00) >> 8) as u8;
+ self.block_length[2] = (length & 0x000000ff) as u8;
+ Ok(())
+ }
+}
+
pub const SCSI_PT_DO_START_OK:c_int = 0;
pub const SCSI_PT_DO_BAD_PARAMS:c_int = 1;
pub const SCSI_PT_DO_TIMEOUT:c_int = 2;
@@ -654,3 +694,62 @@ pub fn scsi_inquiry<F: AsRawFd>(
Ok(info)
}).map_err(|err: Error| format_err!("decode inquiry page failed - {}", err))
}
+
+/// Run SCSI Mode Sense
+///
+/// Warning: P needs to be repr(C, packed)]
+pub fn scsi_mode_sense<F: AsRawFd, P: Endian>(
+ file: &mut F,
+ disable_block_descriptor: bool,
+ page_code: u8,
+ sub_page_code: u8,
+) -> Result<(ModeParameterHeader, Option<ModeBlockDescriptor>, P), Error> {
+
+ let allocation_len: u16 = 4096;
+ let mut sg_raw = SgRaw::new(file, allocation_len as usize)?;
+
+ let mut cmd = Vec::new();
+ cmd.push(0x5A); // MODE SENSE(10)
+ if disable_block_descriptor {
+ cmd.push(8); // DBD=1 (Disable Block Descriptors)
+ } else {
+ cmd.push(0); // DBD=0 (Include Block Descriptors)
+ }
+ cmd.push(page_code & 63); // report current values for page_code
+ cmd.push(sub_page_code);
+
+ cmd.extend(&[0, 0, 0]); // reserved
+ cmd.extend(&allocation_len.to_be_bytes()); // allocation len
+ cmd.push(0); //control
+
+ let data = sg_raw.do_command(&cmd)
+ .map_err(|err| format_err!("mode sense failed - {}", err))?;
+
+ proxmox::try_block!({
+ let mut reader = &data[..];
+
+ let head: ModeParameterHeader = unsafe { reader.read_be_value()? };
+
+ if (head.mode_data_len as usize + 2) != data.len() {
+ bail!("wrong mode_data_len");
+ }
+
+ if disable_block_descriptor && head.block_descriptior_len != 0 {
+ bail!("wrong block_descriptior_len");
+ }
+
+ let mut block_descriptor: Option<ModeBlockDescriptor> = None;
+
+ if !disable_block_descriptor {
+ if head.block_descriptior_len != 8 {
+ bail!("wrong block_descriptior_len");
+ }
+
+ block_descriptor = Some(unsafe { reader.read_be_value()? });
+ }
+
+ let page: P = unsafe { reader.read_be_value()? };
+
+ Ok((head, block_descriptor, page))
+ }).map_err(|err: Error| format_err!("decode mode sense failed - {}", err))
+}
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 09/11] tape: correctly set/display drive option
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (7 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 08/11] sgutils2: add scsi_mode_sense helper Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 10/11] tape: pmt - re-implement fsr/bsr Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 11/11] tape: pmt - re-implement lock/unlock command Dietmar Maurer
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/api2/types/tape/drive.rs | 12 +--
src/bin/proxmox-tape.rs | 5 +-
src/tape/drive/lto/mod.rs | 48 ++++++-----
src/tape/drive/lto/sg_tape.rs | 153 ++++++++++++++++++++++++++++++++--
4 files changed, 182 insertions(+), 36 deletions(-)
diff --git a/src/api2/types/tape/drive.rs b/src/api2/types/tape/drive.rs
index 058e544f..2a0857fd 100644
--- a/src/api2/types/tape/drive.rs
+++ b/src/api2/types/tape/drive.rs
@@ -176,13 +176,15 @@ impl TryFrom<u8> for TapeDensity {
pub struct LtoDriveAndMediaStatus {
/// Block size (0 is variable size)
pub blocksize: u32,
+ /// Compression enabled
+ pub compression: bool,
+ /// Drive buffer mode
+ pub buffer_mode: u8,
/// Tape density
+ pub density: TapeDensity,
+ /// Media is write protected
#[serde(skip_serializing_if="Option::is_none")]
- pub density: Option<TapeDensity>,
- /// Status flags
- pub status: String,
- /// Lto Driver Options
- pub options: String,
+ pub write_protect: Option<bool>,
/// Tape Alert Flags
#[serde(skip_serializing_if="Option::is_none")]
pub alert_flags: Option<String>,
diff --git a/src/bin/proxmox-tape.rs b/src/bin/proxmox-tape.rs
index f1de6236..1d23b71c 100644
--- a/src/bin/proxmox-tape.rs
+++ b/src/bin/proxmox-tape.rs
@@ -741,8 +741,9 @@ async fn status(mut param: Value) -> Result<(), Error> {
let options = default_table_format_options()
.column(ColumnConfig::new("blocksize"))
.column(ColumnConfig::new("density"))
- .column(ColumnConfig::new("status"))
- .column(ColumnConfig::new("options"))
+ .column(ColumnConfig::new("compression"))
+ .column(ColumnConfig::new("buffer-mode"))
+ .column(ColumnConfig::new("write-protect"))
.column(ColumnConfig::new("alert-flags"))
.column(ColumnConfig::new("file-number"))
.column(ColumnConfig::new("block-number"))
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
index 7fcef8a0..c9f3bf93 100644
--- a/src/tape/drive/lto/mod.rs
+++ b/src/tape/drive/lto/mod.rs
@@ -38,6 +38,7 @@ use crate::{
MamAttribute,
LtoDriveAndMediaStatus,
LtoTapeDrive,
+ TapeDensity,
},
tape::{
TapeRead,
@@ -82,8 +83,7 @@ impl LtoTapeDrive {
handle.sg_tape.wait_until_ready()?;
- // Only root can set driver options, so we cannot
- // handle.set_default_options()?;
+ handle.set_default_options()?;
Ok(handle)
}).map_err(|err: Error| format_err!("open drive '{}' ({}) failed - {}", self.name, self.path, err))
@@ -104,8 +104,14 @@ impl LtoTapeHandle {
}
/// Set all options we need/want
- pub fn set_default_options(&self) -> Result<(), Error> {
- // fixme
+ pub fn set_default_options(&mut self) -> Result<(), Error> {
+
+ let compression = Some(true);
+ let block_length = Some(0); // variable length mode
+ let buffer_mode = Some(true); // Always use drive buffer
+
+ self.sg_tape.set_drive_options(compression, block_length, buffer_mode)?;
+
Ok(())
}
@@ -117,28 +123,21 @@ impl LtoTapeHandle {
/// Get Tape and Media status
pub fn get_drive_and_media_status(&mut self) -> Result<LtoDriveAndMediaStatus, Error> {
- let (file_number, block_number) = match self.sg_tape.position() {
- Ok(position) => (
- Some(position.logical_file_id),
- Some(position.logical_object_number),
- ),
- Err(_) => (None, None),
- };
-
- let options = String::from("FIXME");
+ let drive_status = self.sg_tape.read_drive_status()?;
let alert_flags = self.tape_alert_flags()
.map(|flags| format!("{:?}", flags))
.ok();
let mut status = LtoDriveAndMediaStatus {
- blocksize: 0, // fixme: remove
- density: None, // fixme
- status: String::from("FIXME"),
- options,
+ blocksize: drive_status.block_length,
+ compression: drive_status.compression,
+ buffer_mode: drive_status.buffer_mode,
+ density: TapeDensity::try_from(drive_status.density_code)?,
alert_flags,
- file_number,
- block_number,
+ write_protect: None,
+ file_number: None,
+ block_number: None,
manufactured: None,
bytes_read: None,
bytes_written: None,
@@ -147,7 +146,16 @@ impl LtoTapeHandle {
volume_mounts: None,
};
- if self.sg_tape.test_unit_ready()? {
+ if self.sg_tape.test_unit_ready().is_ok() {
+
+ if drive_status.write_protect {
+ status.write_protect = Some(drive_status.write_protect);
+ }
+
+ let position = self.sg_tape.position()?;
+
+ status.file_number = Some(position.logical_file_id);
+ status.block_number = Some(position.logical_object_number);
if let Ok(mam) = self.cartridge_memory() {
diff --git a/src/tape/drive/lto/sg_tape.rs b/src/tape/drive/lto/sg_tape.rs
index 9af0eae3..f3d71edd 100644
--- a/src/tape/drive/lto/sg_tape.rs
+++ b/src/tape/drive/lto/sg_tape.rs
@@ -10,7 +10,7 @@ use nix::fcntl::{fcntl, FcntlArg, OFlag};
use proxmox::{
sys::error::SysResult,
- tools::io::ReadExt,
+ tools::io::{ReadExt, WriteExt},
};
use crate::{
@@ -39,7 +39,11 @@ use crate::{
SenseInfo,
ScsiError,
InquiryInfo,
+ ModeParameterHeader,
+ ModeBlockDescriptor,
+ alloc_page_aligned_buffer,
scsi_inquiry,
+ scsi_mode_sense,
},
};
@@ -54,6 +58,42 @@ pub struct ReadPositionLongPage {
obsolete: [u8;8],
}
+#[repr(C, packed)]
+#[derive(Endian, Debug, Copy, Clone)]
+struct DataCompressionModePage {
+ page_code: u8, // 0x0f
+ page_length: u8, // 0x0e
+ flags2: u8,
+ flags3: u8,
+ compression_algorithm: u32,
+ decompression_algorithm: u32,
+ reserved: [u8;4],
+}
+
+impl DataCompressionModePage {
+
+ pub fn set_compression(&mut self, enable: bool) {
+ if enable {
+ self.flags2 |= 128;
+ } else {
+ self.flags2 = self.flags2 & 127;
+ }
+ }
+
+ pub fn compression_enabled(&self) -> bool {
+ (self.flags2 & 0b1000_0000) != 0
+ }
+}
+
+#[derive(Debug)]
+pub struct LtoTapeStatus {
+ pub block_length: u32,
+ pub density_code: u8,
+ pub buffer_mode: u8,
+ pub write_protect: bool,
+ pub compression: bool,
+}
+
pub struct SgTape {
file: File,
}
@@ -378,19 +418,19 @@ impl SgTape {
Ok(())
}
- pub fn test_unit_ready(&mut self) -> Result<bool, Error> {
+ pub fn test_unit_ready(&mut self) -> Result<(), Error> {
let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
sg_raw.set_timeout(30); // use short timeout
let mut cmd = Vec::new();
cmd.extend(&[0x00, 0, 0, 0, 0, 0]); // TEST UNIT READY
- // fixme: check sense
- sg_raw.do_command(&cmd)
- .map_err(|err| format_err!("unit not ready - {}", err))?;
-
- Ok(true)
-
+ match sg_raw.do_command(&cmd) {
+ Ok(_) => Ok(()),
+ Err(err) => {
+ bail!("test_unit_ready failed - {}", err);
+ }
+ }
}
pub fn wait_until_ready(&mut self) -> Result<(), Error> {
@@ -400,7 +440,7 @@ impl SgTape {
loop {
match self.test_unit_ready() {
- Ok(true) => return Ok(()),
+ Ok(()) => return Ok(()),
_ => {
std::thread::sleep(std::time::Duration::new(1, 0));
if start.elapsed()? > max_wait {
@@ -522,6 +562,101 @@ impl SgTape {
None => Ok(None),
}
}
+
+ /// Set important drive options
+ pub fn set_drive_options(
+ &mut self,
+ compression: Option<bool>,
+ block_length: Option<u32>,
+ buffer_mode: Option<bool>,
+ ) -> Result<(), Error> {
+
+ // Note: Read/Modify/Write
+
+ let (mut head, mut block_descriptor, mut page) = self.read_compression_page()?;
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 0)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+
+ head.mode_data_len = 0; // need to b e zero
+
+ if let Some(compression) = compression {
+ page.set_compression(compression);
+ }
+
+ if let Some(block_length) = block_length {
+ block_descriptor.set_block_length(block_length)?;
+ }
+
+ if let Some(buffer_mode) = buffer_mode {
+ let mut mode = head.flags3 & 0b1_000_1111;
+ if buffer_mode {
+ mode |= 0b0_001_0000;
+ }
+ head.flags3 = mode;
+ }
+
+ let mut data = Vec::new();
+ unsafe {
+ data.write_be_value(head)?;
+ data.write_be_value(block_descriptor)?;
+ data.write_be_value(page)?;
+ }
+
+ let mut cmd = Vec::new();
+ cmd.push(0x55); // MODE SELECT(10)
+ cmd.push(0b0001_0000); // PF=1
+ cmd.extend(&[0,0,0,0,0]); //reserved
+
+ let param_list_len: u16 = data.len() as u16;
+ cmd.extend(¶m_list_len.to_be_bytes());
+ cmd.push(0); // control
+
+ let mut buffer = alloc_page_aligned_buffer(4096)?;
+
+ buffer[..data.len()].copy_from_slice(&data[..]);
+
+ sg_raw.do_out_command(&cmd, &buffer[..data.len()])
+ .map_err(|err| format_err!("set drive options failed - {}", err))?;
+
+ Ok(())
+ }
+
+ fn read_compression_page(
+ &mut self,
+ ) -> Result<(ModeParameterHeader, ModeBlockDescriptor, DataCompressionModePage), Error> {
+
+ let (head, block_descriptor, page): (_,_, DataCompressionModePage)
+ = scsi_mode_sense(&mut self.file, false, 0x0f, 0)?;
+
+ if !(page.page_code == 0x0f && page.page_length == 0x0e) {
+ bail!("read_compression_page: got strange page code/length");
+ }
+
+ let block_descriptor = match block_descriptor {
+ Some(block_descriptor) => block_descriptor,
+ None => bail!("read_compression_page failed: missing block descriptor"),
+ };
+
+ Ok((head, block_descriptor, page))
+ }
+
+ /// Read drive options/status
+ ///
+ /// We read the drive compression page, including the
+ /// block_descriptor. This is all information we need for now.
+ pub fn read_drive_status(&mut self) -> Result<LtoTapeStatus, Error> {
+
+ let (head, block_descriptor, page) = self.read_compression_page()?;
+
+ Ok(LtoTapeStatus {
+ block_length: block_descriptor.block_length(),
+ write_protect: (head.flags3 & 0b1000_0000) != 0,
+ buffer_mode: (head.flags3 & 0b0111_0000) >> 4,
+ compression: page.compression_enabled(),
+ density_code: block_descriptor.density_code,
+ })
+ }
}
pub struct SgTapeReader<'a> {
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 10/11] tape: pmt - re-implement fsr/bsr
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (8 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 09/11] tape: correctly set/display drive option Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 11/11] tape: pmt - re-implement lock/unlock command Dietmar Maurer
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/bin/pmt.rs | 11 ++++-------
src/tape/drive/lto/mod.rs | 8 ++++++++
2 files changed, 12 insertions(+), 7 deletions(-)
diff --git a/src/bin/pmt.rs b/src/bin/pmt.rs
index 854364c7..7183dfe5 100644
--- a/src/bin/pmt.rs
+++ b/src/bin/pmt.rs
@@ -229,13 +229,11 @@ fn bsfm(count: usize, param: Value) -> Result<(), Error> {
},
)]
/// Backward space records.
-fn bsr(count: i32, param: Value) -> Result<(), Error> {
+fn bsr(count: usize, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- unimplemented!();
-
- // fixme: handle.mtop(MTCmd::MTBSR, count, "backward space records")?;
+ handle.backward_space_count_records(count)?;
Ok(())
}
@@ -526,12 +524,11 @@ fn fsfm(count: usize, param: Value) -> Result<(), Error> {
},
)]
/// Forward space records.
-fn fsr(count: i32, param: Value) -> Result<(), Error> {
+fn fsr(count: usize, param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- unimplemented!();
- // fixme: handle.mtop(MTCmd::MTFSR, count, "forward space records")?;
+ handle.forward_space_count_records(count)?;
Ok(())
}
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
index c9f3bf93..f33049ab 100644
--- a/src/tape/drive/lto/mod.rs
+++ b/src/tape/drive/lto/mod.rs
@@ -195,6 +195,14 @@ impl LtoTapeHandle {
self.sg_tape.space_filemarks(-isize::try_from(count)?)
}
+ pub fn forward_space_count_records(&mut self, count: usize) -> Result<(), Error> {
+ self.sg_tape.space_blocks(isize::try_from(count)?)
+ }
+
+ pub fn backward_space_count_records(&mut self, count: usize) -> Result<(), Error> {
+ self.sg_tape.space_blocks(-isize::try_from(count)?)
+ }
+
pub fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
self.sg_tape.erase_media(fast)
}
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* [pbs-devel] [PATCH 11/11] tape: pmt - re-implement lock/unlock command
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
` (9 preceding siblings ...)
2021-04-07 10:23 ` [pbs-devel] [PATCH 10/11] tape: pmt - re-implement fsr/bsr Dietmar Maurer
@ 2021-04-07 10:23 ` Dietmar Maurer
10 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 10:23 UTC (permalink / raw)
To: pbs-devel
---
src/bin/pmt.rs | 6 ++----
src/tape/drive/lto/mod.rs | 12 ++++++++++++
src/tape/drive/lto/sg_tape.rs | 19 +++++++++++++++++++
3 files changed, 33 insertions(+), 4 deletions(-)
diff --git a/src/bin/pmt.rs b/src/bin/pmt.rs
index 7183dfe5..15fa591d 100644
--- a/src/bin/pmt.rs
+++ b/src/bin/pmt.rs
@@ -577,8 +577,7 @@ fn lock(param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- unimplemented!();
- // fixme: handle.mtop(MTCmd::MTLOCK, 1, "lock tape drive door")?;
+ handle.lock()?;
Ok(())
}
@@ -715,8 +714,7 @@ fn unlock(param: Value) -> Result<(), Error> {
let mut handle = get_tape_handle(¶m)?;
- unimplemented!();
- //handle.mtop(MTCmd::MTUNLOCK, 1, "unlock tape drive door")?;
+ handle.unlock()?;
Ok(())
}
diff --git a/src/tape/drive/lto/mod.rs b/src/tape/drive/lto/mod.rs
index f33049ab..de997cde 100644
--- a/src/tape/drive/lto/mod.rs
+++ b/src/tape/drive/lto/mod.rs
@@ -220,6 +220,18 @@ impl LtoTapeHandle {
pub fn volume_statistics(&mut self) -> Result<Lp17VolumeStatistics, Error> {
self.sg_tape.volume_statistics()
}
+
+ /// Lock the drive door
+ pub fn lock(&mut self) -> Result<(), Error> {
+ self.sg_tape.set_medium_removal(false)
+ .map_err(|err| format_err!("lock door failed - {}", err))
+ }
+
+ /// Unlock the drive door
+ pub fn unlock(&mut self) -> Result<(), Error> {
+ self.sg_tape.set_medium_removal(true)
+ .map_err(|err| format_err!("unlock door failed - {}", err))
+ }
}
diff --git a/src/tape/drive/lto/sg_tape.rs b/src/tape/drive/lto/sg_tape.rs
index f3d71edd..638ba330 100644
--- a/src/tape/drive/lto/sg_tape.rs
+++ b/src/tape/drive/lto/sg_tape.rs
@@ -189,6 +189,25 @@ impl SgTape {
Ok(())
}
+ /// Lock/Unlock drive door
+ pub fn set_medium_removal(&mut self, allow: bool) -> Result<(), ScsiError> {
+
+ let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
+ sg_raw.set_timeout(Self::SCSI_TAPE_DEFAULT_TIMEOUT);
+ let mut cmd = Vec::new();
+ cmd.extend(&[0x1E, 0, 0, 0]);
+ if allow {
+ cmd.push(0);
+ } else {
+ cmd.push(1);
+ }
+ cmd.push(0); // control
+
+ sg_raw.do_command(&cmd)?;
+
+ Ok(())
+ }
+
pub fn rewind(&mut self) -> Result<(), Error> {
let mut sg_raw = SgRaw::new(&mut self.file, 16)?;
--
2.20.1
^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [pbs-devel] [PATCH 00/11] Userspace tape driver
@ 2021-04-07 11:26 Dietmar Maurer
0 siblings, 0 replies; 13+ messages in thread
From: Dietmar Maurer @ 2021-04-07 11:26 UTC (permalink / raw)
To: pbs-devel
I forgot to mention that this series include new udev rules. You need
to activate them using:
# udevadm control --reload-rules && udevadm trigger
(or reboot)
You also need to adopt your current drive configuration to use the new
devices ...
> On 04/07/2021 12:22 PM Dietmar Maurer <dietmar@proxmox.com> wrote:
>
>
> This is a userspace drive implementation using SG_IO.
^ permalink raw reply [flat|nested] 13+ messages in thread
end of thread, other threads:[~2021-04-07 11:27 UTC | newest]
Thread overview: 13+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-04-07 10:22 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 01/11] tape: introduce trait BlockRead Dietmar Maurer
2021-04-07 10:22 ` [pbs-devel] [PATCH 02/11] tape: introduce trait BlockWrite Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 03/11] tape: implement LTO userspace driver Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 04/11] tape: implement format/erase Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 05/11] tape: fix LEOM handling Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 06/11] tape: make fsf/bsf driver specific Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 07/11] tape: make sure there is a filemark at the end of the tape Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 08/11] sgutils2: add scsi_mode_sense helper Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 09/11] tape: correctly set/display drive option Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 10/11] tape: pmt - re-implement fsr/bsr Dietmar Maurer
2021-04-07 10:23 ` [pbs-devel] [PATCH 11/11] tape: pmt - re-implement lock/unlock command Dietmar Maurer
2021-04-07 11:26 [pbs-devel] [PATCH 00/11] Userspace tape driver Dietmar Maurer
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox