src/backup/fixed_index.rs

   1 use failure::*;
   2
   3 use crate::tools;
   4 use super::IndexFile;
   5 use super::chunk_stat::*;
   6 use super::chunk_store::*;
   7
   8 use std::sync::Arc;
   9 use std::io::{Read, Write};
  10 use std::fs::File;
  11 use std::path::{Path, PathBuf};
  12 use std::os::unix::io::AsRawFd;
  13 use uuid::Uuid;
  14 use chrono::{Local, TimeZone};
  15 use super::ChunkInfo;
  16
  17 /// Header format definition for fixed index files (`.fidx`)
  18 #[repr(C)]
  19 pub struct FixedIndexHeader {
  20     /// The string `PROXMOX-FIDX`
  21     pub magic: [u8; 12],
  22     pub version: u32,
  23     pub uuid: [u8; 16],
  24     pub ctime: u64,
  25     pub size: u64,
  26     pub chunk_size: u64,
  27     reserved: [u8; 4040], // overall size is one page (4096 bytes)
  28 }
  29
  30 // split image into fixed size chunks
  31
  32 pub struct FixedIndexReader {
  33     store: Arc<ChunkStore>,
  34     _file: File,
  35     filename: PathBuf,
  36     pub chunk_size: usize,
  37     pub size: usize,
  38     index_length: usize,
  39     index: *mut u8,
  40     pub uuid: [u8; 16],
  41     pub ctime: u64,
  42 }
  43
  44 // `index` is mmap()ed which cannot be thread-local so should be sendable
  45 unsafe impl Send for FixedIndexReader {}
  46
  47 impl Drop for FixedIndexReader {
  48
  49     fn drop(&mut self) {
  50         if let Err(err) = self.unmap() {
  51             eprintln!("Unable to unmap file {:?} - {}", self.filename, err);
  52         }
  53     }
  54 }
  55
  56 impl FixedIndexReader {
  57
  58     pub fn open(store: Arc<ChunkStore>, path: &Path) -> Result<Self, Error> {
  59
  60         let full_path = store.relative_path(path);
  61
  62         let mut file = File::open(&full_path)?;
  63
  64         if let Err(err) = nix::fcntl::flock(file.as_raw_fd(), nix::fcntl::FlockArg::LockSharedNonblock) {
  65             bail!("unable to get shared lock on {:?} - {}", full_path, err);
  66         }
  67
  68         let header_size = std::mem::size_of::<FixedIndexHeader>();
  69
  70         // todo: use static assertion when available in rust
  71         if header_size != 4096 { bail!("got unexpected header size for {:?}", path); }
  72
  73         let mut buffer = vec![0u8; header_size];
  74         file.read_exact(&mut buffer)?;
  75
  76         let header = unsafe { &mut * (buffer.as_ptr() as *mut FixedIndexHeader) };
  77
  78         if header.magic != *b"PROXMOX-FIDX" {
  79             bail!("got unknown magic number for {:?}", path);
  80         }
  81
  82         let version = u32::from_le(header.version);
  83         if  version != 1 {
  84             bail!("got unsupported version number ({})", version);
  85         }
  86
  87         let size = u64::from_le(header.size) as usize;
  88         let ctime = u64::from_le(header.ctime);
  89         let chunk_size = u64::from_le(header.chunk_size) as usize;
  90
  91         let index_length = (size + chunk_size - 1)/chunk_size;
  92         let index_size = index_length*32;
  93
  94         let rawfd = file.as_raw_fd();
  95
  96         let stat = match nix::sys::stat::fstat(rawfd) {
  97             Ok(stat) => stat,
  98             Err(err) => bail!("fstat {:?} failed - {}", path, err),
  99         };
 100
 101         let expected_index_size = (stat.st_size as usize) - header_size;
 102         if index_size != expected_index_size {
 103             bail!("got unexpected file size for {:?} ({} != {})",
 104                   path, index_size, expected_index_size);
 105         }
 106
 107         let data = unsafe { nix::sys::mman::mmap(
 108             std::ptr::null_mut(),
 109             index_size,
 110             nix::sys::mman::ProtFlags::PROT_READ,
 111             nix::sys::mman::MapFlags::MAP_PRIVATE,
 112             file.as_raw_fd(),
 113             header_size as i64) }? as *mut u8;
 114
 115         Ok(Self {
 116             store,
 117             filename: full_path,
 118             _file: file,
 119             chunk_size,
 120             size,
 121             index_length,
 122             index: data,
 123             ctime,
 124             uuid: header.uuid,
 125         })
 126     }
 127
 128     fn unmap(&mut self) -> Result<(), Error> {
 129
 130         if self.index == std::ptr::null_mut() { return Ok(()); }
 131
 132         let index_size = self.index_length*32;
 133
 134         if let Err(err) = unsafe { nix::sys::mman::munmap(self.index as *mut std::ffi::c_void, index_size) } {
 135             bail!("unmap file {:?} failed - {}", self.filename, err);
 136         }
 137
 138         self.index = std::ptr::null_mut();
 139
 140         Ok(())
 141     }
 142
 143     pub fn mark_used_chunks(&self, status: &mut GarbageCollectionStatus) -> Result<(), Error> {
 144
 145         if self.index == std::ptr::null_mut() { bail!("detected closed index file."); }
 146
 147         status.used_bytes += self.index_length * self.chunk_size;
 148         status.used_chunks += self.index_length;
 149
 150         for pos in 0..self.index_length {
 151
 152             tools::fail_on_shutdown()?;
 153
 154             let digest = self.index_digest(pos).unwrap();
 155             if let Err(err) = self.store.touch_chunk(digest) {
 156                 bail!("unable to access chunk {}, required by {:?} - {}",
 157                       tools::digest_to_hex(digest), self.filename, err);
 158             }
 159         }
 160
 161         Ok(())
 162     }
 163
 164     pub fn print_info(&self) {
 165         println!("Filename: {:?}", self.filename);
 166         println!("Size: {}", self.size);
 167         println!("ChunkSize: {}", self.chunk_size);
 168         println!("CTime: {}", Local.timestamp(self.ctime as i64, 0).format("%c"));
 169         println!("UUID: {:?}", self.uuid);
 170     }
 171 }
 172
 173 impl IndexFile for FixedIndexReader {
 174     fn index_count(&self) -> usize {
 175         self.index_length
 176     }
 177
 178     fn index_digest(&self, pos: usize) -> Option<&[u8; 32]> {
 179         if pos >= self.index_length {
 180             None
 181         } else {
 182             Some(unsafe { std::mem::transmute(self.index.add(pos*32)) })
 183         }
 184     }
 185 }
 186
 187 pub struct FixedIndexWriter {
 188     store: Arc<ChunkStore>,
 189     _lock: tools::ProcessLockSharedGuard,
 190     filename: PathBuf,
 191     tmp_filename: PathBuf,
 192     chunk_size: usize,
 193     size: usize,
 194     index_length: usize,
 195     index: *mut u8,
 196     pub uuid: [u8; 16],
 197     pub ctime: u64,
 198 }
 199
 200 // `index` is mmap()ed which cannot be thread-local so should be sendable
 201 unsafe impl Send for FixedIndexWriter {}
 202
 203 impl Drop for FixedIndexWriter {
 204
 205     fn drop(&mut self) {
 206         let _ = std::fs::remove_file(&self.tmp_filename); // ignore errors
 207         if let Err(err) = self.unmap() {
 208             eprintln!("Unable to unmap file {:?} - {}", self.tmp_filename, err);
 209         }
 210     }
 211 }
 212
 213 impl FixedIndexWriter {
 214
 215     pub fn create(store: Arc<ChunkStore>, path: &Path, size: usize, chunk_size: usize) -> Result<Self, Error> {
 216
 217         let shared_lock = store.try_shared_lock()?;
 218
 219         let full_path = store.relative_path(path);
 220         let mut tmp_path = full_path.clone();
 221         tmp_path.set_extension("tmp_fidx");
 222
 223         let mut file = std::fs::OpenOptions::new()
 224             .create(true).truncate(true)
 225             .read(true)
 226             .write(true)
 227             .open(&tmp_path)?;
 228
 229         let header_size = std::mem::size_of::<FixedIndexHeader>();
 230
 231         // todo: use static assertion when available in rust
 232         if header_size != 4096 { panic!("got unexpected header size"); }
 233
 234         let ctime = std::time::SystemTime::now().duration_since(
 235             std::time::SystemTime::UNIX_EPOCH)?.as_secs();
 236
 237         let uuid = Uuid::new_v4();
 238
 239         let buffer = vec![0u8; header_size];
 240         let header = unsafe { &mut * (buffer.as_ptr() as *mut FixedIndexHeader) };
 241
 242         header.magic = *b"PROXMOX-FIDX";
 243         header.version = u32::to_le(1);
 244         header.ctime = u64::to_le(ctime);
 245         header.size = u64::to_le(size as u64);
 246         header.chunk_size = u64::to_le(chunk_size as u64);
 247         header.uuid = *uuid.as_bytes();
 248
 249         file.write_all(&buffer)?;
 250
 251         let index_length = (size + chunk_size - 1)/chunk_size;
 252         let index_size = index_length*32;
 253         nix::unistd::ftruncate(file.as_raw_fd(), (header_size + index_size) as i64)?;
 254
 255         let data = unsafe { nix::sys::mman::mmap(
 256             std::ptr::null_mut(),
 257             index_size,
 258             nix::sys::mman::ProtFlags::PROT_READ | nix::sys::mman::ProtFlags::PROT_WRITE,
 259             nix::sys::mman::MapFlags::MAP_SHARED,
 260             file.as_raw_fd(),
 261             header_size as i64) }? as *mut u8;
 262
 263
 264         Ok(Self {
 265             store,
 266             _lock: shared_lock,
 267             filename: full_path,
 268             tmp_filename: tmp_path,
 269             chunk_size,
 270             size,
 271             index_length,
 272             index: data,
 273             ctime,
 274             uuid: *uuid.as_bytes(),
 275         })
 276     }
 277
 278     pub fn index_length(&self) -> usize {
 279         self.index_length
 280     }
 281
 282     fn unmap(&mut self) -> Result<(), Error> {
 283
 284         if self.index == std::ptr::null_mut() { return Ok(()); }
 285
 286         let index_size = self.index_length*32;
 287
 288         if let Err(err) = unsafe { nix::sys::mman::munmap(self.index as *mut std::ffi::c_void, index_size) } {
 289             bail!("unmap file {:?} failed - {}", self.tmp_filename, err);
 290         }
 291
 292         self.index = std::ptr::null_mut();
 293
 294         Ok(())
 295     }
 296
 297     pub fn close(&mut self)  -> Result<(), Error> {
 298
 299         if self.index == std::ptr::null_mut() { bail!("cannot close already closed index file."); }
 300
 301         self.unmap()?;
 302
 303         if let Err(err) = std::fs::rename(&self.tmp_filename, &self.filename) {
 304             bail!("Atomic rename file {:?} failed - {}", self.filename, err);
 305         }
 306
 307         Ok(())
 308     }
 309
 310     // Note: We want to add data out of order, so do not assume any order here.
 311     pub fn add_chunk(&mut self, chunk_info: &ChunkInfo, stat: &mut ChunkStat) -> Result<(), Error> {
 312
 313         let chunk_len = chunk_info.chunk_len as usize;
 314         let end = chunk_info.offset as usize;
 315
 316         if end < chunk_len {
 317             bail!("got chunk with small offset ({} < {}", end, chunk_len);
 318         }
 319
 320         let pos = end - chunk_len;
 321
 322         if end > self.size {
 323             bail!("write chunk data exceeds size ({} >= {})", end, self.size);
 324         }
 325
 326         // last chunk can be smaller
 327         if ((end != self.size) && (chunk_len != self.chunk_size)) ||
 328             (chunk_len > self.chunk_size) || (chunk_len == 0) {
 329                 bail!("got chunk with wrong length ({} != {}", chunk_len, self.chunk_size);
 330             }
 331
 332         if pos & (self.chunk_size-1) != 0 { bail!("add unaligned chunk (pos = {})", pos); }
 333
 334         if (end as u64) != chunk_info.offset {
 335             bail!("got chunk with wrong offset ({} != {}", end, chunk_info.offset);
 336         }
 337
 338         let (is_duplicate, compressed_size) = self.store.insert_chunk(&chunk_info.chunk)?;
 339
 340         stat.chunk_count += 1;
 341         stat.compressed_size += compressed_size;
 342
 343         let digest = chunk_info.chunk.digest();
 344
 345         println!("ADD CHUNK {} {} {}% {} {}", pos, chunk_len,
 346                  (compressed_size*100)/(chunk_len as u64), is_duplicate, tools::digest_to_hex(digest));
 347
 348         if is_duplicate {
 349             stat.duplicate_chunks += 1;
 350         } else {
 351             stat.disk_size += compressed_size;
 352         }
 353
 354         self.add_digest(pos / self.chunk_size, digest)
 355     }
 356
 357     pub fn add_digest(&mut self, index: usize, digest: &[u8; 32]) -> Result<(), Error> {
 358
 359         if index >= self.index_length {
 360             bail!("add digest failed - index out of range ({} >= {})", index, self.index_length);
 361         }
 362
 363         if self.index == std::ptr::null_mut() { bail!("cannot write to closed index file."); }
 364
 365         let index_pos = index*32;
 366         unsafe {
 367             let dst = self.index.add(index_pos);
 368             dst.copy_from_nonoverlapping(digest.as_ptr(), 32);
 369         }
 370
 371         Ok(())
 372     }
 373 }