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

cleanup: remove unused linux tape driver code

Browse Source
This commit is contained in:
Dietmar Maurer 2021-04-08 10:15:52 +02:00
parent e5a13382b2
commit 973e985d73
3 changed files with 0 additions and 1012 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/tape/drive/linux_mtio.rs
View File

@ -1,153 +0,0 @@
//! Linux Magnetic Tape Driver ioctl definitions
//!
//! from: /usr/include/x86_64-linux-gnu/sys/mtio.h
//!
//! also see: man 4 st
#[repr(C)]
pub struct mtop {
pub mt_op: MTCmd, /* Operations defined below. */
pub mt_count: libc::c_int, /* How many of them. */
}
#[repr(i16)]
#[allow(dead_code)] // do not warn about unused command
pub enum MTCmd {
MTRESET = 0, /* +reset drive in case of problems */
MTFSF = 1, /* forward space over FileMark,
* position at first record of next file
*/
MTBSF = 2, /* backward space FileMark (position before FM) */
MTFSR = 3, /* forward space record */
MTBSR = 4, /* backward space record */
MTWEOF = 5, /* write an end-of-file record (mark) */
MTREW = 6, /* rewind */
MTOFFL = 7, /* rewind and put the drive offline (eject?) */
MTNOP = 8, /* no op, set status only (read with MTIOCGET) */
MTRETEN = 9, /* retension tape */
MTBSFM = 10, /* +backward space FileMark, position at FM */
MTFSFM = 11, /* +forward space FileMark, position at FM */
MTEOM = 12, /* goto end of recorded media (for appending files).
* MTEOM positions after the last FM, ready for
* appending another file.
*/
MTERASE = 13, /* erase tape -- be careful! */
MTRAS1 = 14, /* run self test 1 (nondestructive) */
MTRAS2 = 15, /* run self test 2 (destructive) */
MTRAS3 = 16, /* reserved for self test 3 */
MTSETBLK = 20, /* set block length (SCSI) */
MTSETDENSITY = 21, /* set tape density (SCSI) */
MTSEEK = 22, /* seek to block (Tandberg, etc.) */
MTTELL = 23, /* tell block (Tandberg, etc.) */
MTSETDRVBUFFER = 24,/* set the drive buffering according to SCSI-2 */
/* ordinary buffered operation with code 1 */
MTFSS = 25, /* space forward over setmarks */
MTBSS = 26, /* space backward over setmarks */
MTWSM = 27, /* write setmarks */
MTLOCK = 28, /* lock the drive door */
MTUNLOCK = 29, /* unlock the drive door */
MTLOAD = 30, /* execute the SCSI load command */
MTUNLOAD = 31, /* execute the SCSI unload command */
MTCOMPRESSION = 32, /* control compression with SCSI mode page 15 */
MTSETPART = 33, /* Change the active tape partition */
MTMKPART = 34, /* Format the tape with one or two partitions */
MTWEOFI = 35, /* write an end-of-file record (mark) in immediate mode */
}
//#define MTIOCTOP _IOW('m', 1, struct mtop) /* Do a mag tape op. */
nix::ioctl_write_ptr!(mtioctop, b'm', 1, mtop);
// from: /usr/include/x86_64-linux-gnu/sys/mtio.h
#[derive(Default, Debug)]
#[repr(C)]
pub struct mtget {
pub mt_type: libc::c_long, /* Type of magtape device. */
pub mt_resid: libc::c_long, /* Residual count: (not sure)
number of bytes ignored, or
number of files not skipped, or
number of records not skipped. */
/* The following registers are device dependent. */
pub mt_dsreg: libc::c_long, /* Status register. */
pub mt_gstat: libc::c_long, /* Generic (device independent) status. */
pub mt_erreg: libc::c_long, /* Error register. */
/* The next two fields are not always used. */
pub mt_fileno: i32 , /* Number of current file on tape. */
pub mt_blkno: i32, /* Current block number. */
}
//#define MTIOCGET _IOR('m', 2, struct mtget) /* Get tape status. */
nix::ioctl_read!(mtiocget, b'm', 2, mtget);
#[repr(C)]
#[allow(dead_code)]
pub struct mtpos {
pub mt_blkno: libc::c_long, /* current block number */
}
//#define MTIOCPOS _IOR('m', 3, struct mtpos) /* Get tape position.*/
nix::ioctl_read!(mtiocpos, b'm', 3, mtpos);
pub const MT_ST_BLKSIZE_MASK: libc::c_long = 0x0ffffff;
pub const MT_ST_BLKSIZE_SHIFT: usize = 0;
pub const MT_ST_DENSITY_MASK: libc::c_long = 0xff000000;
pub const MT_ST_DENSITY_SHIFT: usize = 24;
pub const MT_TYPE_ISSCSI1: libc::c_long = 0x71; /* Generic ANSI SCSI-1 tape unit. */
pub const MT_TYPE_ISSCSI2: libc::c_long = 0x72; /* Generic ANSI SCSI-2 tape unit. */
// Generic Mag Tape (device independent) status macros for examining mt_gstat -- HP-UX compatible
// from: /usr/include/x86_64-linux-gnu/sys/mtio.h
bitflags::bitflags!{
pub struct GMTStatusFlags: libc::c_long {
const EOF = 0x80000000;
const BOT = 0x40000000;
const EOT = 0x20000000;
const SM = 0x10000000; /* DDS setmark */
const EOD = 0x08000000; /* DDS EOD */
const WR_PROT = 0x04000000;
const ONLINE = 0x01000000;
const D_6250 = 0x00800000;
const D_1600 = 0x00400000;
const D_800 = 0x00200000;
const DRIVE_OPEN = 0x00040000; /* Door open (no tape). */
const IM_REP_EN = 0x00010000; /* Immediate report mode.*/
const END_OF_STREAM = 0b00000001;
}
}
#[repr(i32)]
#[allow(non_camel_case_types, dead_code)]
pub enum SetDrvBufferCmd {
MT_ST_BOOLEANS = 0x10000000,
MT_ST_SETBOOLEANS = 0x30000000,
MT_ST_CLEARBOOLEANS = 0x40000000,
MT_ST_WRITE_THRESHOLD = 0x20000000,
MT_ST_DEF_BLKSIZE = 0x50000000,
MT_ST_DEF_OPTIONS = 0x60000000,
MT_ST_SET_TIMEOUT = 0x70000000,
MT_ST_SET_LONG_TIMEOUT = 0x70100000,
MT_ST_SET_CLN = 0x80000000u32 as i32,
}
bitflags::bitflags!{
pub struct SetDrvBufferOptions: i32 {
const BUFFER_WRITES = 0x1;
const ASYNC_WRITES = 0x2;
const READ_AHEAD = 0x4;
const DEBUGGING = 0x8;
const TWO_FM = 0x10;
const FAST_MTEOM = 0x20;
const AUTO_LOCK = 0x40;
const DEF_WRITES = 0x80;
const CAN_BSR = 0x100;
const NO_BLKLIMS = 0x200;
const CAN_PARTITIONS = 0x400;
const SCSI2LOGICAL = 0x800;
const SYSV = 0x1000;
const NOWAIT = 0x2000;
const SILI = 0x4000;
}
}

857
src/tape/drive/linux_tape.rs
View File

@ -1,857 +0,0 @@
//! Driver for Linux SCSI tapes
use std::fs::{OpenOptions, File};
use std::io::{Read, Write};
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::{SysError, SysResult},
};
use crate::{
config,
backup::{
Fingerprint,
KeyConfig,
},
tools::run_command,
api2::types::{
TapeDensity,
MamAttribute,
LinuxDriveAndMediaStatus,
},
tape::{
BlockWrite,
BlockRead,
BlockReadStatus,
TapeRead,
TapeWrite,
drive::{
linux_mtio::*,
LinuxTapeDrive,
TapeDriver,
TapeAlertFlags,
Lp17VolumeStatistics,
read_mam_attributes,
mam_extract_media_usage,
read_tape_alert_flags,
read_volume_statistics,
set_encryption,
},
file_formats::{
PROXMOX_TAPE_BLOCK_SIZE,
PROXMOX_BACKUP_MEDIA_SET_LABEL_MAGIC_1_0,
MediaSetLabel,
MediaContentHeader,
BlockedReader,
BlockedWriter,
},
},
};
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)
}
/// Linux tape drive status
#[derive(Debug)]
pub struct LinuxDriveStatus {
/// Size 0 is variable block size mode (default)
pub blocksize: u32,
/// Drive status flags
pub status: GMTStatusFlags,
/// Tape densitiy code (if drive media loaded)
pub density: Option<TapeDensity>,
/// Current file position if known (or -1)
pub file_number: Option<u32>,
/// Current block number if known (or -1)
pub block_number: Option<u32>,
}
impl LinuxDriveStatus {
pub fn tape_is_ready(&self) -> bool {
self.status.contains(GMTStatusFlags::ONLINE) &&
!self.status.contains(GMTStatusFlags::DRIVE_OPEN)
}
}
impl LinuxTapeDrive {
/// 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<LinuxTapeHandle, Error> {
proxmox::try_block!({
let file = open_linux_tape_device(&self.path)?;
let mut handle = LinuxTapeHandle::new(file);
let mut drive_status = handle.get_drive_status()?;
if !drive_status.tape_is_ready() {
// for autoloader only, try to reload ejected tapes
if self.changer.is_some() {
let _ = handle.mtload(); // just try, ignore error
drive_status = handle.get_drive_status()?;
}
}
if !drive_status.tape_is_ready() {
bail!("tape not ready (no tape loaded)");
}
if drive_status.blocksize == 0 {
// device is variable block size - OK
} else if drive_status.blocksize != PROXMOX_TAPE_BLOCK_SIZE as u32 {
eprintln!("device is in fixed block size mode with wrong size ({} bytes)", drive_status.blocksize);
eprintln!("trying to set variable block size mode...");
if handle.set_block_size(0).is_err() {
bail!("set variable block size mod failed - device uses wrong blocksize.");
}
} else {
// device is in fixed block size mode with correct block size
}
// Only root can set driver options, so we cannot
// handle.set_default_options()?;
Ok(handle)
}).map_err(|err| format_err!("open drive '{}' ({}) failed - {}", self.name, self.path, err))
}
}
/// Linux Tape device handle
pub struct LinuxTapeHandle {
file: File,
//_lock: File,
}
impl LinuxTapeHandle {
/// Creates a new instance
pub fn new(file: File) -> Self {
Self { file }
}
/// Set all options we need/want
pub fn set_default_options(&self) -> Result<(), Error> {
let mut opts = SetDrvBufferOptions::empty();
// fixme: ? man st(4) claims we need to clear this for reliable multivolume
opts.set(SetDrvBufferOptions::BUFFER_WRITES, true);
// fixme: ?man st(4) claims we need to clear this for reliable multivolume
opts.set(SetDrvBufferOptions::ASYNC_WRITES, true);
opts.set(SetDrvBufferOptions::READ_AHEAD, true);
self.set_drive_buffer_options(opts)
}
/// call MTSETDRVBUFFER to set boolean options
///
/// Note: this uses MT_ST_BOOLEANS, so missing options are cleared!
pub fn set_drive_buffer_options(&self, opts: SetDrvBufferOptions) -> Result<(), Error> {
let cmd = mtop {
mt_op: MTCmd::MTSETDRVBUFFER,
mt_count: (SetDrvBufferCmd::MT_ST_BOOLEANS as i32) | opts.bits(),
};
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTSETDRVBUFFER options failed - {}", err))?;
Ok(())
}
/// call MTSETDRVBUFFER to set boolean options
///
/// Note: this uses MT_ST_SETBOOLEANS
pub fn drive_buffer_set_options(&self, opts: SetDrvBufferOptions) -> Result<(), Error> {
let cmd = mtop {
mt_op: MTCmd::MTSETDRVBUFFER,
mt_count: (SetDrvBufferCmd::MT_ST_SETBOOLEANS as i32) | opts.bits(),
};
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTSETDRVBUFFER options failed - {}", err))?;
Ok(())
}
/// call MTSETDRVBUFFER to clear boolean options
pub fn drive_buffer_clear_options(&self, opts: SetDrvBufferOptions) -> Result<(), Error> {
let cmd = mtop {
mt_op: MTCmd::MTSETDRVBUFFER,
mt_count: (SetDrvBufferCmd::MT_ST_CLEARBOOLEANS as i32) | opts.bits(),
};
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTSETDRVBUFFER options failed - {}", err))?;
Ok(())
}
/// This flushes the driver's buffer as a side effect. Should be
/// used before reading status with MTIOCGET.
fn mtnop(&self) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTNOP, mt_count: 1, };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTNOP failed - {}", err))?;
Ok(())
}
pub fn mtop(&mut self, mt_op: MTCmd, mt_count: i32, msg: &str) -> Result<(), Error> {
let cmd = mtop { mt_op, mt_count };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("{} failed (count {}) - {}", msg, mt_count, err))?;
Ok(())
}
pub fn mtload(&mut self) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTLOAD, mt_count: 1, };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTLOAD failed - {}", err))?;
Ok(())
}
/// Set tape compression feature
pub fn set_compression(&self, on: bool) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTCOMPRESSION, mt_count: if on { 1 } else { 0 } };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("set compression to {} failed - {}", on, err))?;
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.
///
/// A block length of zero sets the drive to variable block
/// size mode.
pub fn set_block_size(&self, block_length: usize) -> Result<(), Error> {
if block_length > 256*1024*1024 {
bail!("block_length too large (> max linux scsii block length)");
}
let cmd = mtop { mt_op: MTCmd::MTSETBLK, mt_count: block_length as i32 };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTSETBLK failed - {}", err))?;
Ok(())
}
/// Get Tape and Media status
pub fn get_drive_and_media_status(&mut self) -> Result<LinuxDriveAndMediaStatus, Error> {
let drive_status = self.get_drive_status()?;
let options = read_tapedev_options(&self.file)?;
let alert_flags = self.tape_alert_flags()
.map(|flags| format!("{:?}", flags))
.ok();
let mut status = LinuxDriveAndMediaStatus {
blocksize: drive_status.blocksize,
density: drive_status.density,
status: format!("{:?}", drive_status.status),
options: format!("{:?}", options),
alert_flags,
file_number: drive_status.file_number,
block_number: drive_status.block_number,
manufactured: None,
bytes_read: None,
bytes_written: None,
medium_passes: None,
medium_wearout: None,
volume_mounts: None,
};
if drive_status.tape_is_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)
}
/// Get Tape status/configuration with MTIOCGET ioctl
pub fn get_drive_status(&mut self) -> Result<LinuxDriveStatus, Error> {
let _ = self.mtnop(); // ignore errors (i.e. no tape loaded)
let mut status = mtget::default();
if let Err(err) = unsafe { mtiocget(self.file.as_raw_fd(), &mut status) } {
bail!("MTIOCGET failed - {}", err);
}
let gmt = GMTStatusFlags::from_bits_truncate(status.mt_gstat);
let blocksize;
if status.mt_type == MT_TYPE_ISSCSI1 || status.mt_type == MT_TYPE_ISSCSI2 {
blocksize = ((status.mt_dsreg & MT_ST_BLKSIZE_MASK) >> MT_ST_BLKSIZE_SHIFT) as u32;
} else {
bail!("got unsupported tape type {}", status.mt_type);
}
let density = ((status.mt_dsreg & MT_ST_DENSITY_MASK) >> MT_ST_DENSITY_SHIFT) as u8;
Ok(LinuxDriveStatus {
blocksize,
status: gmt,
density: if density != 0 {
Some(TapeDensity::try_from(density)?)
} else {
None
},
file_number: if status.mt_fileno > 0 {
Some(status.mt_fileno as u32)
} else {
None
},
block_number: if status.mt_blkno > 0 {
Some(status.mt_blkno as u32)
} else {
None
},
})
}
/// Read Cartridge Memory (MAM Attributes)
///
/// Note: Only 'root' user may run RAW SG commands, so we need to
/// spawn setuid binary 'sg-tape-cmd'.
pub fn cartridge_memory(&mut self) -> Result<Vec<MamAttribute>, Error> {
if nix::unistd::Uid::effective().is_root() {
return read_mam_attributes(&mut self.file);
}
let output = run_sg_tape_cmd("cartridge-memory", &[], self.file.as_raw_fd())?;
let result: Result<Vec<MamAttribute>, String> = serde_json::from_str(&output)?;
result.map_err(|err| format_err!("{}", err))
}
/// Read Volume Statistics
///
/// Note: Only 'root' user may run RAW SG commands, so we need to
/// spawn setuid binary 'sg-tape-cmd'.
pub fn volume_statistics(&mut self) -> Result<Lp17VolumeStatistics, Error> {
if nix::unistd::Uid::effective().is_root() {
return read_volume_statistics(&mut self.file);
}
let output = run_sg_tape_cmd("volume-statistics", &[], self.file.as_raw_fd())?;
let result: Result<Lp17VolumeStatistics, String> = serde_json::from_str(&output)?;
result.map_err(|err| format_err!("{}", err))
}
}
impl TapeDriver for LinuxTapeHandle {
fn sync(&mut self) -> Result<(), Error> {
// MTWEOF with count 0 => flush
let cmd = mtop { mt_op: MTCmd::MTWEOF, mt_count: 0 };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| proxmox::io_format_err!("MT sync failed - {}", err))?;
Ok(())
}
/// Go to the end of the recorded media (for appending files).
fn move_to_eom(&mut self) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTEOM, mt_count: 1, };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTEOM failed - {}", err))?;
Ok(())
}
fn forward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTFSF, mt_count: i32::try_from(count)? };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| {
format_err!("forward space {} files failed - {}", count, err)
})?;
Ok(())
}
fn backward_space_count_files(&mut self, count: usize) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTBSF, mt_count: i32::try_from(count)? };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| {
format_err!("backward space {} files failed - {}", count, err)
})?;
Ok(())
}
fn rewind(&mut self) -> Result<(), Error> {
let cmd = mtop { mt_op: MTCmd::MTREW, mt_count: 1, };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("tape rewind failed - {}", err))?;
Ok(())
}
fn current_file_number(&mut self) -> Result<u64, Error> {
let mut status = mtget::default();
self.mtnop()?;
if let Err(err) = unsafe { mtiocget(self.file.as_raw_fd(), &mut status) } {
bail!("current_file_number MTIOCGET failed - {}", err);
}
if status.mt_fileno < 0 {
bail!("current_file_number failed (got {})", status.mt_fileno);
}
Ok(status.mt_fileno as u64)
}
fn erase_media(&mut self, fast: bool) -> Result<(), Error> {
self.rewind()?; // important - erase from BOT
let cmd = mtop { mt_op: MTCmd::MTERASE, mt_count: if fast { 0 } else { 1 } };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTERASE failed - {}", err))?;
Ok(())
}
fn read_next_file<'a>(&'a mut self) -> Result<Option<Box<dyn TapeRead + 'a>>, std::io::Error> {
let reader = LinuxTapeReader::new(&mut self.file);
match BlockedReader::open(reader)? {
Some(reader) => Ok(Some(Box::new(reader))),
None => Ok(None),
}
}
fn write_file<'a>(&'a mut self) -> Result<Box<dyn TapeWrite + 'a>, std::io::Error> {
let writer = LinuxTapeWriter::new(&mut self.file);
let handle = BlockedWriter::new(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> {
let cmd = mtop { mt_op: MTCmd::MTOFFL, mt_count: 1 };
unsafe {
mtioctop(self.file.as_raw_fd(), &cmd)
}.map_err(|err| format_err!("MTOFFL failed - {}", err))?;
Ok(())
}
/// Read Tape Alert Flags
///
/// Note: Only 'root' user may run RAW SG commands, so we need to
/// spawn setuid binary 'sg-tape-cmd'.
fn tape_alert_flags(&mut self) -> Result<TapeAlertFlags, Error> {
if nix::unistd::Uid::effective().is_root() {
return read_tape_alert_flags(&mut self.file);
}
let output = run_sg_tape_cmd("tape-alert-flags", &[], self.file.as_raw_fd())?;
let result: Result<u64, String> = serde_json::from_str(&output)?;
result
.map_err(|err| format_err!("{}", err))
.map(TapeAlertFlags::from_bits_truncate)
}
/// Set or clear encryption key
///
/// Note: Only 'root' user may run RAW SG commands, so we need to
/// spawn setuid binary 'sg-tape-cmd'. Also, encryption key file
/// is only readable by root.
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 set_encryption(&mut self.file, Some(tape_key));
}
None => bail!("unknown tape encryption key '{}'", key_fingerprint),
}
} else {
return set_encryption(&mut self.file, 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.file.as_raw_fd())?
} else {
run_sg_tape_cmd("encryption", &[], self.file.as_raw_fd())?
};
let result: Result<(), String> = serde_json::from_str(&output)?;
result.map_err(|err| format_err!("{}", err))
}
}
/// Write a single EOF mark without flushing buffers
fn tape_write_eof_mark(file: &mut File) -> Result<(), std::io::Error> {
let cmd = mtop { mt_op: MTCmd::MTWEOFI, mt_count: 1 };
unsafe {
mtioctop(file.as_raw_fd(), &cmd)
}.map_err(|err| proxmox::io_format_err!("MTWEOFI failed - {}", err))?;
Ok(())
}
/// Check for correct Major/Minor numbers
pub fn check_tape_is_linux_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 tape device");
}
if (minor & 128) == 0 {
bail!("Detected rewinding tape. Please use non-rewinding tape devices (/dev/nstX).");
}
Ok(())
}
/// Opens a Linux 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_linux_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_linux_tape_device(&file)
.map_err(|err| format_err!("device type check {:?} failed - {}", path, err))?;
Ok(file)
}
/// Read Linux tape device options from /sys
pub fn read_tapedev_options(file: &File) -> Result<SetDrvBufferOptions, 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) };
let path = format!("/sys/dev/char/{}:{}/options", major, minor);
let options = proxmox::tools::fs::file_read_firstline(&path)?;
let options = options.trim();
let options = match options.strip_prefix("0x") {
Some(rest) => rest,
None => bail!("unable to parse '{}'", path),
};
let options = i32::from_str_radix(&options, 16)?;
Ok(SetDrvBufferOptions::from_bits_truncate(options))
}
struct LinuxTapeWriter<'a> {
/// Assumes that 'file' is a linux tape device.
file: &'a mut File,
}
impl <'a> LinuxTapeWriter<'a> {
pub fn new(file: &'a mut File) -> Self {
Self { file }
}
}
impl <'a> BlockWrite for LinuxTapeWriter<'a> {
/// 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 write_filemark(&mut self) -> Result<(), std::io::Error> {
tape_write_eof_mark(&mut self.file)
}
}
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),
}
}
}
}

2
src/tape/drive/mod.rs
View File

@ -2,8 +2,6 @@
mod virtual_tape; mod virtual_tape;
pub mod linux_mtio;
mod tape_alert_flags; mod tape_alert_flags;
pub use tape_alert_flags::*; pub use tape_alert_flags::*;