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

tape: correctly lock the tape device

This commit is contained in:
Dietmar Maurer 2021-02-05 10:50:21 +01:00
parent b5c6088130
commit 25aa55b5f5
5 changed files with 141 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/api2/tape/backup.rs
View File

@ -15,10 +15,7 @@ use proxmox::{
use crate::{
task_log,
config::{
self,
drive::check_drive_exists,
},
config,
backup::{
DataStore,
BackupDir,
@ -40,7 +37,10 @@ use crate::{
PoolWriter,
MediaPool,
SnapshotReader,
drive::media_changer,
drive::{
media_changer,
lock_tape_device,
},
changer::update_changer_online_status,
},
};
@ -91,8 +91,9 @@ pub fn backup(
let pool_config: MediaPoolConfig = config.lookup("pool", &pool)?;
let (drive_config, _digest) = config::drive::config()?;
// early check before starting worker
check_drive_exists(&drive_config, &drive)?;
// early check/lock before starting worker
let drive_lock = lock_tape_device(&drive_config, &drive)?;
let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
@ -105,6 +106,7 @@ pub fn backup(
auth_id,
to_stdout,
move |worker| {
let _drive_lock = drive_lock; // keep lock guard
backup_worker(&worker, datastore, &drive, &pool_config, eject_media, export_media_set)?;
Ok(())
}

75
src/api2/tape/drive.rs
View File

@ -12,6 +12,7 @@ use proxmox::{
sys::error::SysError,
api::{
api,
section_config::SectionConfigData,
RpcEnvironment,
RpcEnvironmentType,
Router,
@ -20,10 +21,7 @@ use proxmox::{
};
use crate::{
config::{
self,
drive::check_drive_exists,
},
config,
api2::{
types::{
UPID_SCHEMA,
@ -62,6 +60,7 @@ use crate::{
media_changer,
required_media_changer,
open_drive,
lock_tape_device,
},
changer::update_changer_online_status,
},
@ -205,7 +204,8 @@ pub fn erase_media(
let (config, _digest) = config::drive::config()?;
check_drive_exists(&config, &drive)?; // early check before starting worker
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -217,6 +217,8 @@ pub fn erase_media(
auth_id,
to_stdout,
move |_worker| {
let _lock_guard = lock_guard; // keep lock guard
let mut drive = open_drive(&config, &drive)?;
drive.erase_media(fast.unwrap_or(true))?;
Ok(())
@ -246,7 +248,8 @@ pub fn rewind(
let (config, _digest) = config::drive::config()?;
check_drive_exists(&config, &drive)?; // early check before starting worker
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -258,6 +261,7 @@ pub fn rewind(
auth_id,
to_stdout,
move |_worker| {
let _lock_guard = lock_guard; // keep lock guard
let mut drive = open_drive(&config, &drive)?;
drive.rewind()?;
Ok(())
@ -287,7 +291,8 @@ pub fn eject_media(
let (config, _digest) = config::drive::config()?;
check_drive_exists(&config, &drive)?; // early check before starting worker
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -299,6 +304,8 @@ pub fn eject_media(
auth_id,
to_stdout,
move |_worker| {
let _lock_guard = lock_guard; // keep lock guard
if let Some((mut changer, _)) = media_changer(&config, &drive)? {
changer.unload_media(None)?;
} else {
@ -355,6 +362,9 @@ pub fn label_media(
let (config, _digest) = config::drive::config()?;
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
let upid_str = WorkerTask::new_thread(
@ -363,6 +373,7 @@ pub fn label_media(
auth_id,
to_stdout,
move |worker| {
let _lock_guard = lock_guard; // keep lock guard
let mut drive = open_drive(&config, &drive)?;
@ -479,7 +490,12 @@ pub async fn restore_key(
let (config, _digest) = config::drive::config()?;
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
tokio::task::spawn_blocking(move || {
let _lock_guard = lock_guard; // keep lock guard
let mut drive = open_drive(&config, &drive)?;
let (_media_id, key_config) = drive.read_label()?;
@ -520,7 +536,12 @@ pub async fn read_label(
let (config, _digest) = config::drive::config()?;
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
tokio::task::spawn_blocking(move || {
let _lock_guard = lock_guard; // keep lock guard
let mut drive = open_drive(&config, &drive)?;
let (media_id, _key_config) = drive.read_label()?;
@ -593,7 +614,8 @@ pub fn clean_drive(
let (config, _digest) = config::drive::config()?;
check_drive_exists(&config, &drive)?; // early check before starting worker
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -605,6 +627,7 @@ pub fn clean_drive(
auth_id,
to_stdout,
move |worker| {
let _lock_guard = lock_guard; // keep lock guard
let (mut changer, _changer_name) = required_media_changer(&config, &drive)?;
@ -649,7 +672,12 @@ pub async fn inventory(
let (config, _digest) = config::drive::config()?;
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
tokio::task::spawn_blocking(move || {
let _lock_guard = lock_guard; // keep lock guard
let (mut changer, changer_name) = required_media_changer(&config, &drive)?;
let label_text_list = changer.online_media_label_texts()?;
@ -720,7 +748,8 @@ pub fn update_inventory(
let (config, _digest) = config::drive::config()?;
check_drive_exists(&config, &drive)?; // early check before starting worker
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -732,6 +761,7 @@ pub fn update_inventory(
auth_id,
to_stdout,
move |worker| {
let _lock_guard = lock_guard; // keep lock guard
let (mut changer, changer_name) = required_media_changer(&config, &drive)?;
@ -822,6 +852,11 @@ pub fn barcode_label_media(
}
}
let (drive_config, _digest) = config::drive::config()?;
// early check/lock before starting worker
let lock_guard = lock_tape_device(&drive_config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
@ -832,7 +867,8 @@ pub fn barcode_label_media(
auth_id,
to_stdout,
move |worker| {
barcode_label_media_worker(worker, drive, pool)
let _lock_guard = lock_guard; // keep lock guard
barcode_label_media_worker(worker, drive, &drive_config, pool)
}
)?;
@ -842,12 +878,11 @@ pub fn barcode_label_media(
fn barcode_label_media_worker(
worker: Arc<WorkerTask>,
drive: String,
drive_config: &SectionConfigData,
pool: Option<String>,
) -> Result<(), Error> {
let (config, _digest) = config::drive::config()?;
let (mut changer, changer_name) = required_media_changer(&config, &drive)?;
let (mut changer, changer_name) = required_media_changer(drive_config, &drive)?;
let label_text_list = changer.online_media_label_texts()?;
@ -855,7 +890,7 @@ fn barcode_label_media_worker(
let mut inventory = Inventory::load(state_path)?;
update_changer_online_status(&config, &mut inventory, &changer_name, &label_text_list)?;
update_changer_online_status(drive_config, &mut inventory, &changer_name, &label_text_list)?;
if label_text_list.is_empty() {
bail!("changer device does not list any media labels");
@ -877,7 +912,7 @@ fn barcode_label_media_worker(
continue;
}
let mut drive = open_drive(&config, &drive)?;
let mut drive = open_drive(drive_config, &drive)?;
drive.rewind()?;
match drive.read_next_file() {
@ -930,6 +965,8 @@ pub fn cartridge_memory(drive: String) -> Result<Vec<MamAttribute>, Error> {
let (config, _digest) = config::drive::config()?;
let _lock_guard = lock_tape_device(&config, &drive)?;
let drive_config: LinuxTapeDrive = config.lookup("linux", &drive)?;
let mut handle = drive_config.open()?;
@ -953,6 +990,8 @@ pub fn volume_statistics(drive: String) -> Result<Lp17VolumeStatistics, Error> {
let (config, _digest) = config::drive::config()?;
let _lock_guard = lock_tape_device(&config, &drive)?;
let drive_config: LinuxTapeDrive = config.lookup("linux", &drive)?;
let mut handle = drive_config.open()?;
@ -976,6 +1015,8 @@ pub fn status(drive: String) -> Result<LinuxDriveAndMediaStatus, Error> {
let (config, _digest) = config::drive::config()?;
let _lock_guard = lock_tape_device(&config, &drive)?;
let drive_config: LinuxTapeDrive = config.lookup("linux", &drive)?;
// Note: use open_linux_tape_device, because this also works if no medium loaded
@ -1021,7 +1062,8 @@ pub fn catalog_media(
let (config, _digest) = config::drive::config()?;
check_drive_exists(&config, &drive)?; // early check before starting worker
// early check/lock before starting worker
let lock_guard = lock_tape_device(&config, &drive)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -1033,6 +1075,7 @@ pub fn catalog_media(
auth_id,
to_stdout,
move |worker| {
let _lock_guard = lock_guard; // keep lock guard
let mut drive = open_drive(&config, &drive)?;

14
src/api2/tape/restore.rs
View File

@ -34,10 +34,7 @@ use crate::{
Authid,
MediaPoolConfig,
},
config::{
self,
drive::check_drive_exists,
},
config,
backup::{
archive_type,
MANIFEST_BLOB_NAME,
@ -71,7 +68,8 @@ use crate::{
drive::{
TapeDriver,
request_and_load_media,
}
lock_tape_device,
},
},
};
@ -122,8 +120,9 @@ pub fn restore(
let _pool_config: MediaPoolConfig = config.lookup("pool", &pool)?;
let (drive_config, _digest) = config::drive::config()?;
// early check before starting worker
check_drive_exists(&drive_config, &drive)?;
// early check/lock before starting worker
let drive_lock = lock_tape_device(&drive_config, &drive)?;
let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
@ -133,6 +132,7 @@ pub fn restore(
auth_id.clone(),
to_stdout,
move |worker| {
let _drive_lock = drive_lock; // keep lock guard
let _lock = MediaPool::lock(status_path, &pool)?;

11
src/bin/proxmox-tape.rs
View File

@ -40,7 +40,10 @@ use proxmox_backup::{
media_pool::complete_pool_name,
},
tape::{
drive::open_drive,
drive::{
open_drive,
lock_tape_device,
},
complete_media_label_text,
complete_media_set_uuid,
file_formats::{
@ -518,6 +521,9 @@ fn move_to_eom(param: Value) -> Result<(), Error> {
let (config, _digest) = config::drive::config()?;
let drive = lookup_drive_name(&param, &config)?;
let _lock = lock_tape_device(&config, &drive)?;
let mut drive = open_drive(&config, &drive)?;
drive.move_to_eom()?;
@ -544,6 +550,9 @@ fn debug_scan(param: Value) -> Result<(), Error> {
let (config, _digest) = config::drive::config()?;
let drive = lookup_drive_name(&param, &config)?;
let _lock = lock_tape_device(&config, &drive)?;
let mut drive = open_drive(&config, &drive)?;
println!("rewinding tape");

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

@ -19,6 +19,8 @@ pub use linux_tape::*;
mod mam;
pub use mam::*;
use std::os::unix::io::AsRawFd;
use anyhow::{bail, format_err, Error};
use ::serde::{Deserialize};
use serde_json::Value;
@ -27,6 +29,7 @@ use proxmox::{
tools::{
Uuid,
io::ReadExt,
fs::fchown,
},
api::section_config::SectionConfigData,
};
@ -442,3 +445,54 @@ pub fn request_and_load_media(
}
}
}
/// Aquires an exclusive lock for the tape device
///
/// Basically calls lock_device_path() using the configured drive path.
pub fn lock_tape_device(
config: &SectionConfigData,
drive: &str,
) -> Result<DeviceLockGuard, Error> {
match config.sections.get(drive) {
Some((section_type_name, config)) => {
let path = match section_type_name.as_ref() {
"virtual" => {
VirtualTapeDrive::deserialize(config)?.path
}
"linux" => {
LinuxTapeDrive::deserialize(config)?.path
}
_ => bail!("unknown drive type '{}' - internal error"),
};
lock_device_path(&path)
.map_err(|err| format_err!("unable to lock drive '{}' - {}", drive, err))
}
None => {
bail!("no such drive '{}'", drive);
}
}
}
pub struct DeviceLockGuard(std::fs::File);
// Aquires an exclusive lock on `device_path`
//
// Uses systemd escape_unit to compute a file name from `device_path`, the try
// to lock `/var/lock/<name>`.
fn lock_device_path(device_path: &str) -> Result<DeviceLockGuard, Error> {
let lock_name = crate::tools::systemd::escape_unit(device_path, true);
let mut path = std::path::PathBuf::from("/var/lock");
path.push(lock_name);
let timeout = std::time::Duration::new(10, 0);
let mut file = std::fs::OpenOptions::new().create(true).append(true).open(path)?;
proxmox::tools::fs::lock_file(&mut file, true, Some(timeout))?;
let backup_user = crate::backup::backup_user()?;
fchown(file.as_raw_fd(), Some(backup_user.uid), Some(backup_user.gid))?;
Ok(DeviceLockGuard(file))
}