proxmox-backup/src/backup/fixed_index.rs

354 lines
10 KiB
Rust
Raw Normal View History

use failure::*;
use crate::tools;
use super::IndexFile;
use super::chunk_stat::*;
use super::chunk_store::*;
use std::sync::Arc;
2018-12-16 13:44:44 +00:00
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::os::unix::io::AsRawFd;
2018-12-15 16:05:49 +00:00
use uuid::Uuid;
2018-12-16 13:44:44 +00:00
use chrono::{Local, TimeZone};
/// Header format definition for fixed index files (`.fidx`)
2018-12-15 16:05:49 +00:00
#[repr(C)]
pub struct FixedIndexHeader {
/// The string `PROXMOX-FIDX`
2018-12-15 16:05:49 +00:00
pub magic: [u8; 12],
pub version: u32,
pub uuid: [u8; 16],
2018-12-16 10:48:03 +00:00
pub ctime: u64,
2018-12-15 16:05:49 +00:00
pub size: u64,
2018-12-16 13:44:44 +00:00
pub chunk_size: u64,
2019-01-02 11:56:04 +00:00
reserved: [u8; 4040], // overall size is one page (4096 bytes)
2018-12-15 16:05:49 +00:00
}
// split image into fixed size chunks
pub struct FixedIndexReader {
store: Arc<ChunkStore>,
2018-12-16 13:44:44 +00:00
filename: PathBuf,
chunk_size: usize,
2019-01-30 17:25:37 +00:00
pub size: usize,
2018-12-16 13:44:44 +00:00
index: *mut u8,
2019-01-30 17:25:37 +00:00
pub uuid: [u8; 16],
pub ctime: u64,
2018-12-16 13:44:44 +00:00
}
// `index` is mmap()ed which cannot be thread-local so should be sendable
unsafe impl Send for FixedIndexReader {}
impl Drop for FixedIndexReader {
2018-12-16 13:44:44 +00:00
fn drop(&mut self) {
if let Err(err) = self.unmap() {
eprintln!("Unable to unmap file {:?} - {}", self.filename, err);
}
}
}
impl FixedIndexReader {
2018-12-16 13:44:44 +00:00
pub fn open(store: Arc<ChunkStore>, path: &Path) -> Result<Self, Error> {
2018-12-16 13:44:44 +00:00
let full_path = store.relative_path(path);
let mut file = std::fs::File::open(&full_path)?;
let header_size = std::mem::size_of::<FixedIndexHeader>();
2018-12-16 13:44:44 +00:00
// todo: use static assertion when available in rust
if header_size != 4096 { bail!("got unexpected header size for {:?}", path); }
2018-12-16 13:44:44 +00:00
let mut buffer = vec![0u8; header_size];
file.read_exact(&mut buffer)?;
let header = unsafe { &mut * (buffer.as_ptr() as *mut FixedIndexHeader) };
2018-12-16 13:44:44 +00:00
if header.magic != *b"PROXMOX-FIDX" {
bail!("got unknown magic number for {:?}", path);
}
let version = u32::from_le(header.version);
if version != 1 {
bail!("got unsupported version number ({})", version);
}
let size = u64::from_le(header.size) as usize;
let ctime = u64::from_le(header.ctime);
let chunk_size = u64::from_le(header.chunk_size) as usize;
2018-12-16 13:44:44 +00:00
let index_size = ((size + chunk_size - 1)/chunk_size)*32;
2019-01-02 17:14:02 +00:00
let rawfd = file.as_raw_fd();
let stat = match nix::sys::stat::fstat(rawfd) {
Ok(stat) => stat,
Err(err) => bail!("fstat {:?} failed - {}", path, err),
};
2019-01-11 07:41:33 +00:00
let expected_index_size = (stat.st_size as usize) - header_size;
2019-01-02 17:14:02 +00:00
if index_size != expected_index_size {
bail!("got unexpected file size for {:?} ({} != {})",
path, index_size, expected_index_size);
}
2018-12-16 13:44:44 +00:00
let data = unsafe { nix::sys::mman::mmap(
std::ptr::null_mut(),
index_size,
nix::sys::mman::ProtFlags::PROT_READ,
nix::sys::mman::MapFlags::MAP_PRIVATE,
file.as_raw_fd(),
header_size as i64) }? as *mut u8;
Ok(Self {
store,
filename: full_path,
chunk_size,
size,
index: data,
ctime,
uuid: header.uuid,
})
}
fn unmap(&mut self) -> Result<(), Error> {
if self.index == std::ptr::null_mut() { return Ok(()); }
let index_size = ((self.size + self.chunk_size - 1)/self.chunk_size)*32;
if let Err(err) = unsafe { nix::sys::mman::munmap(self.index as *mut std::ffi::c_void, index_size) } {
bail!("unmap file {:?} failed - {}", self.filename, err);
}
self.index = std::ptr::null_mut();
Ok(())
}
pub fn mark_used_chunks(&self, status: &mut GarbageCollectionStatus) -> Result<(), Error> {
2018-12-18 10:06:03 +00:00
if self.index == std::ptr::null_mut() { bail!("detected closed index file."); }
let index_count = self.index_count();
2018-12-18 10:06:03 +00:00
status.used_bytes += index_count * self.chunk_size;
status.used_chunks += index_count;
2018-12-18 10:06:03 +00:00
for pos in 0..index_count {
let digest = self.index_digest(pos).unwrap();
2018-12-18 10:06:03 +00:00
if let Err(err) = self.store.touch_chunk(digest) {
bail!("unable to access chunk {}, required by {:?} - {}",
tools::digest_to_hex(digest), self.filename, err);
2018-12-18 10:06:03 +00:00
}
}
Ok(())
}
2018-12-16 13:44:44 +00:00
pub fn print_info(&self) {
println!("Filename: {:?}", self.filename);
println!("Size: {}", self.size);
println!("ChunkSize: {}", self.chunk_size);
println!("CTime: {}", Local.timestamp(self.ctime as i64, 0).format("%c"));
println!("UUID: {:?}", self.uuid);
}
}
impl IndexFile for FixedIndexReader {
fn index_count(&self) -> usize {
(self.size + self.chunk_size - 1)/self.chunk_size
}
fn index_digest(&self, pos: usize) -> Option<&[u8; 32]> {
if pos >= self.index_count() {
None
} else {
Some(unsafe { std::mem::transmute(self.index.add(pos*32)) })
}
}
}
pub struct FixedIndexWriter {
store: Arc<ChunkStore>,
_lock: tools::ProcessLockSharedGuard,
filename: PathBuf,
tmp_filename: PathBuf,
chunk_size: usize,
stat: ChunkStat,
size: usize,
index: *mut u8,
2019-01-30 17:25:37 +00:00
pub uuid: [u8; 16],
pub ctime: u64,
}
// `index` is mmap()ed which cannot be thread-local so should be sendable
unsafe impl Send for FixedIndexWriter {}
impl Drop for FixedIndexWriter {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.tmp_filename); // ignore errors
if let Err(err) = self.unmap() {
2018-12-16 12:43:19 +00:00
eprintln!("Unable to unmap file {:?} - {}", self.tmp_filename, err);
}
}
}
impl FixedIndexWriter {
pub fn create(store: Arc<ChunkStore>, path: &Path, size: usize, chunk_size: usize) -> Result<Self, Error> {
let shared_lock = store.try_shared_lock()?;
let full_path = store.relative_path(path);
let mut tmp_path = full_path.clone();
tmp_path.set_extension("tmp_fidx");
let mut file = std::fs::OpenOptions::new()
2018-12-15 16:05:49 +00:00
.create(true).truncate(true)
.read(true)
.write(true)
.open(&tmp_path)?;
let header_size = std::mem::size_of::<FixedIndexHeader>();
2018-12-15 16:05:49 +00:00
// todo: use static assertion when available in rust
if header_size != 4096 { panic!("got unexpected header size"); }
let ctime = std::time::SystemTime::now().duration_since(
2018-12-16 10:48:03 +00:00
std::time::SystemTime::UNIX_EPOCH)?.as_secs();
2018-12-15 16:05:49 +00:00
let uuid = Uuid::new_v4();
2018-12-16 12:43:19 +00:00
let buffer = vec![0u8; header_size];
let header = unsafe { &mut * (buffer.as_ptr() as *mut FixedIndexHeader) };
2018-12-15 16:05:49 +00:00
header.magic = *b"PROXMOX-FIDX";
header.version = u32::to_le(1);
header.ctime = u64::to_le(ctime);
header.size = u64::to_le(size as u64);
header.chunk_size = u64::to_le(chunk_size as u64);
2018-12-15 16:05:49 +00:00
header.uuid = *uuid.as_bytes();
2018-12-16 10:48:03 +00:00
file.write_all(&buffer)?;
2018-12-15 16:05:49 +00:00
let index_size = ((size + chunk_size - 1)/chunk_size)*32;
2018-12-15 16:05:49 +00:00
nix::unistd::ftruncate(file.as_raw_fd(), (header_size + index_size) as i64)?;
let data = unsafe { nix::sys::mman::mmap(
std::ptr::null_mut(),
index_size,
nix::sys::mman::ProtFlags::PROT_READ | nix::sys::mman::ProtFlags::PROT_WRITE,
nix::sys::mman::MapFlags::MAP_SHARED,
file.as_raw_fd(),
2018-12-15 16:05:49 +00:00
header_size as i64) }? as *mut u8;
Ok(Self {
store,
_lock: shared_lock,
filename: full_path,
tmp_filename: tmp_path,
chunk_size,
size,
stat: ChunkStat::new(size as u64),
index: data,
2018-12-15 16:05:49 +00:00
ctime,
uuid: *uuid.as_bytes(),
})
}
fn unmap(&mut self) -> Result<(), Error> {
if self.index == std::ptr::null_mut() { return Ok(()); }
let index_size = ((self.size + self.chunk_size - 1)/self.chunk_size)*32;
if let Err(err) = unsafe { nix::sys::mman::munmap(self.index as *mut std::ffi::c_void, index_size) } {
2018-12-16 12:43:19 +00:00
bail!("unmap file {:?} failed - {}", self.tmp_filename, err);
}
self.index = std::ptr::null_mut();
self.stat.disk_size += index_size as u64;
println!("STAT: {:?}", self.stat);
2019-01-02 11:53:49 +00:00
Ok(())
}
pub fn close(&mut self) -> Result<(), Error> {
if self.index == std::ptr::null_mut() { bail!("cannot close already closed index file."); }
self.unmap()?;
if let Err(err) = std::fs::rename(&self.tmp_filename, &self.filename) {
bail!("Atomic rename file {:?} failed - {}", self.filename, err);
}
Ok(())
}
pub fn stat(&self) -> &ChunkStat {
&self.stat
}
// Note: We want to add data out of order, so do not assume and order here.
pub fn add_chunk(&mut self, pos: usize, chunk: &[u8]) -> Result<(), Error> {
if self.index == std::ptr::null_mut() { bail!("cannot write to closed index file."); }
let end = pos + chunk.len();
if end > self.size {
bail!("write chunk data exceeds size ({} >= {})", end, self.size);
}
// last chunk can be smaller
if ((end != self.size) && (chunk.len() != self.chunk_size)) ||
(chunk.len() > self.chunk_size) || (chunk.len() == 0) {
bail!("got chunk with wrong length ({} != {}", chunk.len(), self.chunk_size);
}
if pos >= self.size { bail!("add chunk after end ({} >= {})", pos, self.size); }
if pos & (self.chunk_size-1) != 0 { bail!("add unaligned chunk (pos = {})", pos); }
let (is_duplicate, digest, compressed_size) = self.store.insert_chunk(chunk)?;
self.stat.chunk_count += 1;
self.stat.compressed_size += compressed_size;
println!("ADD CHUNK {} {} {}% {} {}", pos, chunk.len(),
(compressed_size*100)/(chunk.len() as u64), is_duplicate, tools::digest_to_hex(&digest));
if is_duplicate {
self.stat.duplicate_chunks += 1;
} else {
self.stat.disk_size += compressed_size;
}
self.add_digest(pos / self.chunk_size, &digest)
}
pub fn add_digest(&mut self, index: usize, digest: &[u8; 32]) -> Result<(), Error> {
let index_pos = index*32;
unsafe {
let dst = self.index.add(index_pos);
dst.copy_from_nonoverlapping(digest.as_ptr(), 32);
}
Ok(())
}
}