2018-12-15 13:51:05 +00:00
|
|
|
use failure::*;
|
|
|
|
|
|
|
|
use super::chunk_store::*;
|
|
|
|
|
2018-12-16 13:44:44 +00:00
|
|
|
use std::io::{Read, Write};
|
2018-12-15 13:51:05 +00:00
|
|
|
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};
|
2018-12-15 13:51:05 +00:00
|
|
|
|
2018-12-15 16:05:49 +00:00
|
|
|
#[repr(C)]
|
|
|
|
pub struct ImageIndexHeader {
|
|
|
|
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,
|
|
|
|
reserved: [u8; 4040], // oversall size is one page (4096 bytes)
|
2018-12-15 16:05:49 +00:00
|
|
|
}
|
2018-12-15 13:51:05 +00:00
|
|
|
|
|
|
|
// split image into fixed size chunks
|
|
|
|
|
2018-12-16 13:44:44 +00:00
|
|
|
pub struct ImageIndexReader<'a> {
|
2018-12-21 11:15:26 +00:00
|
|
|
store: &'a ChunkStore,
|
2018-12-16 13:44:44 +00:00
|
|
|
filename: PathBuf,
|
|
|
|
chunk_size: usize,
|
|
|
|
size: usize,
|
|
|
|
index: *mut u8,
|
|
|
|
uuid: [u8; 16],
|
|
|
|
ctime: u64,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl <'a> Drop for ImageIndexReader<'a> {
|
|
|
|
|
|
|
|
fn drop(&mut self) {
|
|
|
|
if let Err(err) = self.unmap() {
|
|
|
|
eprintln!("Unable to unmap file {:?} - {}", self.filename, err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl <'a> ImageIndexReader<'a> {
|
|
|
|
|
2018-12-21 11:15:26 +00:00
|
|
|
pub fn open(store: &'a 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::<ImageIndexHeader>();
|
|
|
|
|
|
|
|
// todo: use static assertion when available in rust
|
|
|
|
if header_size != 4096 { panic!("got unexpected header size"); }
|
|
|
|
|
|
|
|
let mut buffer = vec![0u8; header_size];
|
|
|
|
file.read_exact(&mut buffer)?;
|
|
|
|
|
|
|
|
let header = unsafe { &mut * (buffer.as_ptr() as *mut ImageIndexHeader) };
|
|
|
|
|
|
|
|
let size = u64::from_be(header.size) as usize;
|
|
|
|
let ctime = u64::from_be(header.ctime);
|
|
|
|
let chunk_size = u64::from_be(header.chunk_size) as usize;
|
|
|
|
|
|
|
|
let index_size = ((size + chunk_size - 1)/chunk_size)*32;
|
|
|
|
|
|
|
|
// fixme: verify file size ?
|
|
|
|
|
|
|
|
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(())
|
|
|
|
}
|
|
|
|
|
2018-12-22 15:58:16 +00:00
|
|
|
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.size + self.chunk_size - 1)/self.chunk_size;
|
|
|
|
|
2018-12-22 15:58:16 +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 = unsafe { std::slice::from_raw_parts_mut(self.index.add(pos*32), 32) };
|
|
|
|
if let Err(err) = self.store.touch_chunk(digest) {
|
|
|
|
bail!("unable to access chunk {}, required by {:?} - {}",
|
2018-12-19 08:51:33 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-16 10:51:16 +00:00
|
|
|
pub struct ImageIndexWriter<'a> {
|
2018-12-27 09:11:11 +00:00
|
|
|
store: &'a ChunkStore,
|
2018-12-16 12:39:21 +00:00
|
|
|
filename: PathBuf,
|
|
|
|
tmp_filename: PathBuf,
|
2018-12-15 13:51:05 +00:00
|
|
|
chunk_size: usize,
|
|
|
|
size: usize,
|
|
|
|
index: *mut u8,
|
2018-12-15 16:05:49 +00:00
|
|
|
uuid: [u8; 16],
|
2018-12-16 10:48:03 +00:00
|
|
|
ctime: u64,
|
2018-12-15 13:51:05 +00:00
|
|
|
}
|
|
|
|
|
2018-12-16 12:39:21 +00:00
|
|
|
impl <'a> Drop for ImageIndexWriter<'a> {
|
|
|
|
|
|
|
|
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);
|
2018-12-16 12:39:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-16 10:51:16 +00:00
|
|
|
impl <'a> ImageIndexWriter<'a> {
|
2018-12-15 13:51:05 +00:00
|
|
|
|
2018-12-27 09:11:11 +00:00
|
|
|
pub fn create(store: &'a ChunkStore, path: &Path, size: usize, chunk_size: usize) -> Result<Self, Error> {
|
2018-12-15 13:51:05 +00:00
|
|
|
|
|
|
|
let full_path = store.relative_path(path);
|
2018-12-16 12:39:21 +00:00
|
|
|
let mut tmp_path = full_path.clone();
|
|
|
|
tmp_path.set_extension("tmp_iidx");
|
2018-12-15 13:51:05 +00:00
|
|
|
|
|
|
|
let mut file = std::fs::OpenOptions::new()
|
2018-12-15 16:05:49 +00:00
|
|
|
.create(true).truncate(true)
|
2018-12-15 13:51:05 +00:00
|
|
|
.read(true)
|
|
|
|
.write(true)
|
2018-12-16 12:39:21 +00:00
|
|
|
.open(&tmp_path)?;
|
2018-12-15 13:51:05 +00:00
|
|
|
|
2018-12-15 16:05:49 +00:00
|
|
|
let header_size = std::mem::size_of::<ImageIndexHeader>();
|
|
|
|
|
|
|
|
// 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];
|
2018-12-15 16:05:49 +00:00
|
|
|
let header = unsafe { &mut * (buffer.as_ptr() as *mut ImageIndexHeader) };
|
|
|
|
|
2018-12-16 10:48:03 +00:00
|
|
|
header.magic = *b"PROXMOX-IIDX";
|
2018-12-15 16:05:49 +00:00
|
|
|
header.version = u32::to_be(1);
|
2018-12-16 10:48:03 +00:00
|
|
|
header.ctime = u64::to_be(ctime);
|
2018-12-15 16:05:49 +00:00
|
|
|
header.size = u64::to_be(size as u64);
|
2018-12-16 13:44:44 +00:00
|
|
|
header.chunk_size = u64::to_be(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
|
|
|
|
2018-12-15 13:51:05 +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)?;
|
|
|
|
|
2018-12-15 13:51:05 +00:00
|
|
|
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;
|
|
|
|
|
2018-12-15 13:51:05 +00:00
|
|
|
|
|
|
|
Ok(Self {
|
|
|
|
store,
|
2018-12-16 12:39:21 +00:00
|
|
|
filename: full_path,
|
|
|
|
tmp_filename: tmp_path,
|
2018-12-15 13:51:05 +00:00
|
|
|
chunk_size,
|
|
|
|
size,
|
|
|
|
index: data,
|
2018-12-15 16:05:49 +00:00
|
|
|
ctime,
|
|
|
|
uuid: *uuid.as_bytes(),
|
2018-12-15 13:51:05 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2018-12-16 12:39:21 +00:00
|
|
|
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);
|
2018-12-16 12:39:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
self.index = std::ptr::null_mut();
|
|
|
|
|
|
|
|
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(())
|
|
|
|
}
|
|
|
|
|
2018-12-15 13:51:05 +00:00
|
|
|
// 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> {
|
|
|
|
|
2018-12-16 12:39:21 +00:00
|
|
|
if self.index == std::ptr::null_mut() { bail!("cannot write to closed index file."); }
|
|
|
|
|
2018-12-15 13:51:05 +00:00
|
|
|
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) = self.store.insert_chunk(chunk)?;
|
|
|
|
|
2018-12-19 08:51:33 +00:00
|
|
|
println!("ADD CHUNK {} {} {} {}", pos, chunk.len(), is_duplicate, digest_to_hex(&digest));
|
2018-12-15 13:51:05 +00:00
|
|
|
|
|
|
|
let index_pos = (pos/self.chunk_size)*32;
|
|
|
|
unsafe {
|
|
|
|
let dst = self.index.add(index_pos);
|
|
|
|
dst.copy_from_nonoverlapping(digest.as_ptr(), 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|