]>
Commit | Line | Data |
---|---|---|
606ce64b DM |
1 | use failure::*; |
2 | ||
3 | use super::chunk_store::*; | |
4 | ||
4818c8b6 | 5 | use std::io::{Read, Write}; |
606ce64b DM |
6 | use std::path::{Path, PathBuf}; |
7 | use std::os::unix::io::AsRawFd; | |
d13e3745 | 8 | use uuid::Uuid; |
4818c8b6 | 9 | use chrono::{Local, TimeZone}; |
606ce64b | 10 | |
d13e3745 DM |
11 | #[repr(C)] |
12 | pub struct ImageIndexHeader { | |
13 | pub magic: [u8; 12], | |
14 | pub version: u32, | |
15 | pub uuid: [u8; 16], | |
5e5b7f1c | 16 | pub ctime: u64, |
d13e3745 | 17 | pub size: u64, |
4818c8b6 | 18 | pub chunk_size: u64, |
44b3f62b | 19 | reserved: [u8; 4040], // overall size is one page (4096 bytes) |
d13e3745 | 20 | } |
606ce64b DM |
21 | |
22 | // split image into fixed size chunks | |
23 | ||
4818c8b6 | 24 | pub struct ImageIndexReader<'a> { |
03e4753d | 25 | store: &'a ChunkStore, |
4818c8b6 DM |
26 | filename: PathBuf, |
27 | chunk_size: usize, | |
28 | size: usize, | |
29 | index: *mut u8, | |
30 | uuid: [u8; 16], | |
31 | ctime: u64, | |
32 | } | |
33 | ||
34 | impl <'a> Drop for ImageIndexReader<'a> { | |
35 | ||
36 | fn drop(&mut self) { | |
37 | if let Err(err) = self.unmap() { | |
38 | eprintln!("Unable to unmap file {:?} - {}", self.filename, err); | |
39 | } | |
40 | } | |
41 | } | |
42 | ||
43 | impl <'a> ImageIndexReader<'a> { | |
44 | ||
03e4753d | 45 | pub fn open(store: &'a ChunkStore, path: &Path) -> Result<Self, Error> { |
4818c8b6 DM |
46 | |
47 | let full_path = store.relative_path(path); | |
48 | ||
49 | let mut file = std::fs::File::open(&full_path)?; | |
50 | ||
51 | let header_size = std::mem::size_of::<ImageIndexHeader>(); | |
52 | ||
53 | // todo: use static assertion when available in rust | |
a360f6fa | 54 | if header_size != 4096 { bail!("got unexpected header size for {:?}", path); } |
4818c8b6 DM |
55 | |
56 | let mut buffer = vec![0u8; header_size]; | |
57 | file.read_exact(&mut buffer)?; | |
58 | ||
59 | let header = unsafe { &mut * (buffer.as_ptr() as *mut ImageIndexHeader) }; | |
60 | ||
a360f6fa DM |
61 | if header.magic != *b"PROXMOX-IIDX" { |
62 | bail!("got unknown magic number for {:?}", path); | |
63 | } | |
64 | ||
48d0d356 | 65 | let version = u32::from_le(header.version); |
a360f6fa DM |
66 | if version != 1 { |
67 | bail!("got unsupported version number ({})", version); | |
68 | } | |
69 | ||
48d0d356 DM |
70 | let size = u64::from_le(header.size) as usize; |
71 | let ctime = u64::from_le(header.ctime); | |
72 | let chunk_size = u64::from_le(header.chunk_size) as usize; | |
4818c8b6 DM |
73 | |
74 | let index_size = ((size + chunk_size - 1)/chunk_size)*32; | |
75 | ||
0b8e75ed DM |
76 | let rawfd = file.as_raw_fd(); |
77 | ||
78 | let stat = match nix::sys::stat::fstat(rawfd) { | |
79 | Ok(stat) => stat, | |
80 | Err(err) => bail!("fstat {:?} failed - {}", path, err), | |
81 | }; | |
82 | ||
ddbdf80d | 83 | let expected_index_size = (stat.st_size as usize) - header_size; |
0b8e75ed DM |
84 | if index_size != expected_index_size { |
85 | bail!("got unexpected file size for {:?} ({} != {})", | |
86 | path, index_size, expected_index_size); | |
87 | } | |
4818c8b6 DM |
88 | |
89 | let data = unsafe { nix::sys::mman::mmap( | |
90 | std::ptr::null_mut(), | |
91 | index_size, | |
92 | nix::sys::mman::ProtFlags::PROT_READ, | |
93 | nix::sys::mman::MapFlags::MAP_PRIVATE, | |
94 | file.as_raw_fd(), | |
95 | header_size as i64) }? as *mut u8; | |
96 | ||
97 | Ok(Self { | |
98 | store, | |
99 | filename: full_path, | |
100 | chunk_size, | |
101 | size, | |
102 | index: data, | |
103 | ctime, | |
104 | uuid: header.uuid, | |
105 | }) | |
106 | } | |
107 | ||
108 | fn unmap(&mut self) -> Result<(), Error> { | |
109 | ||
110 | if self.index == std::ptr::null_mut() { return Ok(()); } | |
111 | ||
112 | let index_size = ((self.size + self.chunk_size - 1)/self.chunk_size)*32; | |
113 | ||
114 | if let Err(err) = unsafe { nix::sys::mman::munmap(self.index as *mut std::ffi::c_void, index_size) } { | |
115 | bail!("unmap file {:?} failed - {}", self.filename, err); | |
116 | } | |
117 | ||
118 | self.index = std::ptr::null_mut(); | |
119 | ||
120 | Ok(()) | |
121 | } | |
122 | ||
64e53b28 | 123 | pub fn mark_used_chunks(&self, status: &mut GarbageCollectionStatus) -> Result<(), Error> { |
3d5c11e5 DM |
124 | |
125 | if self.index == std::ptr::null_mut() { bail!("detected closed index file."); } | |
126 | ||
127 | let index_count = (self.size + self.chunk_size - 1)/self.chunk_size; | |
128 | ||
64e53b28 DM |
129 | status.used_bytes += index_count * self.chunk_size; |
130 | status.used_chunks += index_count; | |
131 | ||
3d5c11e5 DM |
132 | for pos in 0..index_count { |
133 | ||
134 | let digest = unsafe { std::slice::from_raw_parts_mut(self.index.add(pos*32), 32) }; | |
135 | if let Err(err) = self.store.touch_chunk(digest) { | |
136 | bail!("unable to access chunk {}, required by {:?} - {}", | |
08481a0b | 137 | digest_to_hex(digest), self.filename, err); |
3d5c11e5 DM |
138 | } |
139 | } | |
140 | ||
141 | Ok(()) | |
142 | } | |
143 | ||
4818c8b6 DM |
144 | pub fn print_info(&self) { |
145 | println!("Filename: {:?}", self.filename); | |
146 | println!("Size: {}", self.size); | |
147 | println!("ChunkSize: {}", self.chunk_size); | |
148 | println!("CTime: {}", Local.timestamp(self.ctime as i64, 0).format("%c")); | |
149 | println!("UUID: {:?}", self.uuid); | |
150 | } | |
151 | } | |
152 | ||
798881a6 | 153 | pub struct ImageIndexWriter<'a> { |
bcd879cf | 154 | store: &'a ChunkStore, |
4fbb72a8 DM |
155 | filename: PathBuf, |
156 | tmp_filename: PathBuf, | |
606ce64b | 157 | chunk_size: usize, |
580dc84b | 158 | duplicate_chunks: usize, |
606ce64b DM |
159 | size: usize, |
160 | index: *mut u8, | |
d13e3745 | 161 | uuid: [u8; 16], |
5e5b7f1c | 162 | ctime: u64, |
606ce64b DM |
163 | } |
164 | ||
4fbb72a8 DM |
165 | impl <'a> Drop for ImageIndexWriter<'a> { |
166 | ||
167 | fn drop(&mut self) { | |
168 | let _ = std::fs::remove_file(&self.tmp_filename); // ignore errors | |
169 | if let Err(err) = self.unmap() { | |
0cd9d420 | 170 | eprintln!("Unable to unmap file {:?} - {}", self.tmp_filename, err); |
4fbb72a8 DM |
171 | } |
172 | } | |
173 | } | |
174 | ||
798881a6 | 175 | impl <'a> ImageIndexWriter<'a> { |
606ce64b | 176 | |
bcd879cf | 177 | pub fn create(store: &'a ChunkStore, path: &Path, size: usize, chunk_size: usize) -> Result<Self, Error> { |
606ce64b DM |
178 | |
179 | let full_path = store.relative_path(path); | |
4fbb72a8 DM |
180 | let mut tmp_path = full_path.clone(); |
181 | tmp_path.set_extension("tmp_iidx"); | |
606ce64b DM |
182 | |
183 | let mut file = std::fs::OpenOptions::new() | |
d13e3745 | 184 | .create(true).truncate(true) |
606ce64b DM |
185 | .read(true) |
186 | .write(true) | |
4fbb72a8 | 187 | .open(&tmp_path)?; |
606ce64b | 188 | |
d13e3745 DM |
189 | let header_size = std::mem::size_of::<ImageIndexHeader>(); |
190 | ||
191 | // todo: use static assertion when available in rust | |
192 | if header_size != 4096 { panic!("got unexpected header size"); } | |
193 | ||
194 | let ctime = std::time::SystemTime::now().duration_since( | |
5e5b7f1c | 195 | std::time::SystemTime::UNIX_EPOCH)?.as_secs(); |
d13e3745 DM |
196 | |
197 | let uuid = Uuid::new_v4(); | |
198 | ||
0cd9d420 | 199 | let buffer = vec![0u8; header_size]; |
d13e3745 DM |
200 | let header = unsafe { &mut * (buffer.as_ptr() as *mut ImageIndexHeader) }; |
201 | ||
5e5b7f1c | 202 | header.magic = *b"PROXMOX-IIDX"; |
48d0d356 DM |
203 | header.version = u32::to_le(1); |
204 | header.ctime = u64::to_le(ctime); | |
205 | header.size = u64::to_le(size as u64); | |
206 | header.chunk_size = u64::to_le(chunk_size as u64); | |
d13e3745 DM |
207 | header.uuid = *uuid.as_bytes(); |
208 | ||
5e5b7f1c | 209 | file.write_all(&buffer)?; |
d13e3745 | 210 | |
606ce64b | 211 | let index_size = ((size + chunk_size - 1)/chunk_size)*32; |
d13e3745 DM |
212 | nix::unistd::ftruncate(file.as_raw_fd(), (header_size + index_size) as i64)?; |
213 | ||
606ce64b DM |
214 | let data = unsafe { nix::sys::mman::mmap( |
215 | std::ptr::null_mut(), | |
216 | index_size, | |
217 | nix::sys::mman::ProtFlags::PROT_READ | nix::sys::mman::ProtFlags::PROT_WRITE, | |
218 | nix::sys::mman::MapFlags::MAP_SHARED, | |
219 | file.as_raw_fd(), | |
d13e3745 DM |
220 | header_size as i64) }? as *mut u8; |
221 | ||
606ce64b DM |
222 | |
223 | Ok(Self { | |
224 | store, | |
4fbb72a8 DM |
225 | filename: full_path, |
226 | tmp_filename: tmp_path, | |
606ce64b | 227 | chunk_size, |
580dc84b | 228 | duplicate_chunks: 0, |
606ce64b DM |
229 | size, |
230 | index: data, | |
d13e3745 DM |
231 | ctime, |
232 | uuid: *uuid.as_bytes(), | |
606ce64b DM |
233 | }) |
234 | } | |
235 | ||
4fbb72a8 DM |
236 | fn unmap(&mut self) -> Result<(), Error> { |
237 | ||
238 | if self.index == std::ptr::null_mut() { return Ok(()); } | |
239 | ||
240 | let index_size = ((self.size + self.chunk_size - 1)/self.chunk_size)*32; | |
241 | ||
242 | if let Err(err) = unsafe { nix::sys::mman::munmap(self.index as *mut std::ffi::c_void, index_size) } { | |
0cd9d420 | 243 | bail!("unmap file {:?} failed - {}", self.tmp_filename, err); |
4fbb72a8 DM |
244 | } |
245 | ||
246 | self.index = std::ptr::null_mut(); | |
247 | ||
580dc84b DM |
248 | println!("Original size: {} Compressed size: {} Deduplicated size: {}", |
249 | self.size, self.size, self.size - (self.duplicate_chunks*self.chunk_size)); | |
250 | ||
4fbb72a8 DM |
251 | Ok(()) |
252 | } | |
253 | ||
254 | pub fn close(&mut self) -> Result<(), Error> { | |
255 | ||
256 | if self.index == std::ptr::null_mut() { bail!("cannot close already closed index file."); } | |
257 | ||
258 | self.unmap()?; | |
259 | ||
260 | if let Err(err) = std::fs::rename(&self.tmp_filename, &self.filename) { | |
261 | bail!("Atomic rename file {:?} failed - {}", self.filename, err); | |
262 | } | |
263 | ||
264 | Ok(()) | |
265 | } | |
266 | ||
606ce64b DM |
267 | // Note: We want to add data out of order, so do not assume and order here. |
268 | pub fn add_chunk(&mut self, pos: usize, chunk: &[u8]) -> Result<(), Error> { | |
269 | ||
4fbb72a8 DM |
270 | if self.index == std::ptr::null_mut() { bail!("cannot write to closed index file."); } |
271 | ||
606ce64b DM |
272 | let end = pos + chunk.len(); |
273 | ||
274 | if end > self.size { | |
275 | bail!("write chunk data exceeds size ({} >= {})", end, self.size); | |
276 | } | |
277 | ||
278 | // last chunk can be smaller | |
279 | if ((end != self.size) && (chunk.len() != self.chunk_size)) || | |
280 | (chunk.len() > self.chunk_size) || (chunk.len() == 0) { | |
281 | bail!("got chunk with wrong length ({} != {}", chunk.len(), self.chunk_size); | |
282 | } | |
283 | ||
284 | if pos >= self.size { bail!("add chunk after end ({} >= {})", pos, self.size); } | |
285 | ||
286 | if pos & (self.chunk_size-1) != 0 { bail!("add unaligned chunk (pos = {})", pos); } | |
287 | ||
288 | ||
289 | let (is_duplicate, digest) = self.store.insert_chunk(chunk)?; | |
290 | ||
08481a0b | 291 | println!("ADD CHUNK {} {} {} {}", pos, chunk.len(), is_duplicate, digest_to_hex(&digest)); |
606ce64b | 292 | |
580dc84b DM |
293 | if is_duplicate { self.duplicate_chunks += 1; } |
294 | ||
606ce64b DM |
295 | let index_pos = (pos/self.chunk_size)*32; |
296 | unsafe { | |
297 | let dst = self.index.add(index_pos); | |
298 | dst.copy_from_nonoverlapping(digest.as_ptr(), 32); | |
299 | } | |
300 | ||
301 | Ok(()) | |
302 | } | |
303 | } |