1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
use std::io::{Read, Seek, SeekFrom, Write};
pub use self::file::{FileNvm, FileNvmBuilder};
pub use self::memory::MemoryNvm;
pub use self::shared_memory::SharedMemoryNvm;
use block::{AlignedBytes, BlockSize};
use {ErrorKind, Result};
mod file;
mod memory;
mod shared_memory;
pub trait NonVolatileMemory: Sized + Read + Write + Seek {
fn sync(&mut self) -> Result<()>;
fn position(&self) -> u64;
fn capacity(&self) -> u64;
fn block_size(&self) -> BlockSize;
fn split(self, position: u64) -> Result<(Self, Self)>;
fn convert_to_offset(&self, pos: SeekFrom) -> Result<u64> {
match pos {
SeekFrom::Start(offset) => {
track_assert!(offset <= self.capacity(), ErrorKind::InvalidInput);
Ok(offset)
}
SeekFrom::End(delta) => {
let offset = self.capacity() as i64 + delta;
track_assert!(0 <= offset, ErrorKind::InvalidInput);
Ok(offset as u64)
}
SeekFrom::Current(delta) => {
let offset = self.position() as i64 + delta;
track_assert!(0 <= offset, ErrorKind::InvalidInput);
Ok(offset as u64)
}
}
}
fn aligned_write_all<F>(&mut self, f: F) -> Result<()>
where
F: FnOnce(&mut Vec<u8>) -> Result<()>,
{
let mut buf = Vec::new();
track!(f(&mut buf))?;
let mut aligned_bytes = AlignedBytes::from_bytes(&buf, self.block_size());
aligned_bytes.align();
track_io!(self.write_all(&aligned_bytes))?;
Ok(())
}
fn aligned_read_bytes(&mut self, size: usize) -> Result<AlignedBytes> {
let mut buf = AlignedBytes::new(size, self.block_size());
buf.align();
track_io!(self.read_exact(&mut buf))?;
buf.truncate(size);
Ok(buf)
}
}