From ce162aae909243ca1b2dab86dee8562d67d3d41a Mon Sep 17 00:00:00 2001 From: Szymon Walter Date: Tue, 20 Mar 2018 12:49:44 +0100 Subject: [PATCH] rename `buffer` to `volume` to better reflect its purpose --- src/fs.rs | 50 +++++++------- src/lib.rs | 2 +- src/sys/block_group.rs | 18 ++--- src/sys/inode.rs | 8 +-- src/sys/superblock.rs | 16 ++--- src/{buffer => volume}/length.rs | 0 src/{buffer => volume}/mod.rs | 114 +++++++++++++++---------------- 7 files changed, 104 insertions(+), 104 deletions(-) rename src/{buffer => volume}/length.rs (100%) rename src/{buffer => volume}/mod.rs (73%) diff --git a/src/fs.rs b/src/fs.rs index f4a7d2a..0e3f567 100644 --- a/src/fs.rs +++ b/src/fs.rs @@ -5,7 +5,7 @@ use alloc::Vec; use error::Error; use sector::{Address, Size}; -use buffer::{Buffer, BufferSlice}; +use volume::{Volume, VolumeSlice}; use sys::superblock::Superblock; use sys::block_group::BlockGroupDescriptor; use sys::inode::Inode; @@ -23,18 +23,18 @@ impl From<(T, Address)> for Struct { } /// Safe wrapper for raw sys structs -pub struct Ext2>> { - buffer: B, +pub struct Ext2>> { + volume: V, superblock: Struct, block_groups: Struct, S>, } -impl>> Ext2 +impl>> Ext2 where - Error: From, + Error: From, { - pub fn new(buffer: B) -> Result, Error> { - let superblock = unsafe { Struct::from(Superblock::find(&buffer)?) }; + pub fn new(volume: V) -> Result, Error> { + let superblock = unsafe { Struct::from(Superblock::find(&volume)?) }; let block_groups_offset = Address::with_block_size( superblock.inner.first_data_block as usize + 1, 0, @@ -47,14 +47,14 @@ where .map_err(|(a, b)| Error::BadBlockGroupCount(a, b))?; let block_groups = unsafe { BlockGroupDescriptor::find_descriptor_table( - &buffer, + &volume, block_groups_offset, block_groups_count, )? }; let block_groups = Struct::from(block_groups); Ok(Ext2 { - buffer, + volume, superblock, block_groups, }) @@ -64,20 +64,20 @@ where fn update_global(&mut self) -> Result<(), Error> { // superblock { - let slice = BufferSlice::from_cast( + let slice = VolumeSlice::from_cast( &self.superblock.inner, self.superblock.offset, ); let commit = slice.commit(); - self.buffer.commit(commit).map_err(|err| Error::from(err))?; + self.volume.commit(commit).map_err(|err| Error::from(err))?; } // block group descriptors let mut offset = self.block_groups.offset; for descr in &self.block_groups.inner { - let slice = BufferSlice::from_cast(descr, offset); + let slice = VolumeSlice::from_cast(descr, offset); let commit = slice.commit(); - self.buffer.commit(commit).map_err(|err| Error::from(err))?; + self.volume.commit(commit).map_err(|err| Error::from(err))?; offset = offset + Address::from(mem::size_of::()); } @@ -90,9 +90,9 @@ where &mut self, &(ref inode, offset): &(Inode, Address), ) -> Result<(), Error> { - let slice = BufferSlice::from_cast(inode, offset); + let slice = VolumeSlice::from_cast(inode, offset); let commit = slice.commit(); - self.buffer.commit(commit).map_err(|err| Error::from(err)) + self.volume.commit(commit).map_err(|err| Error::from(err)) } pub fn root_inode(&self) -> (Inode, Address) { @@ -103,14 +103,14 @@ where self.inodes_nth(index).next() } - pub fn inodes<'a>(&'a self) -> Inodes<'a, S, B> { + pub fn inodes<'a>(&'a self) -> Inodes<'a, S, V> { self.inodes_nth(1) } - pub fn inodes_nth<'a>(&'a self, index: usize) -> Inodes<'a, S, B> { + pub fn inodes_nth<'a>(&'a self, index: usize) -> Inodes<'a, S, V> { assert!(index > 0, "inodes are 1-indexed"); Inodes { - buffer: &self.buffer, + volume: &self.volume, block_groups: &self.block_groups.inner, log_block_size: self.log_block_size(), inode_size: self.inode_size(), @@ -175,8 +175,8 @@ where } } -pub struct Inodes<'a, S: Size, B: 'a + Buffer>> { - buffer: &'a B, +pub struct Inodes<'a, S: Size, V: 'a + Volume>> { + volume: &'a V, block_groups: &'a [BlockGroupDescriptor], log_block_size: u32, inode_size: usize, @@ -186,10 +186,10 @@ pub struct Inodes<'a, S: Size, B: 'a + Buffer>> { _phantom: PhantomData, } -impl<'a, S: Size + Copy, B: 'a + Buffer>> Iterator - for Inodes<'a, S, B> +impl<'a, S: Size + Copy, V: 'a + Volume>> Iterator + for Inodes<'a, S, V> where - Error: From, + Error: From, { type Item = (Inode, Address); @@ -208,7 +208,7 @@ where self.log_block_size, ); unsafe { - Inode::find_inode(self.buffer, offset, self.inode_size).ok() + Inode::find_inode(self.volume, offset, self.inode_size).ok() } } else { None @@ -222,7 +222,7 @@ mod tests { use std::cell::RefCell; use sector::{Address, Size512}; - use buffer::Buffer; + use volume::Volume; use super::Ext2; diff --git a/src/lib.rs b/src/lib.rs index b803f88..0e47614 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -16,7 +16,7 @@ extern crate core; pub mod error; pub mod sys; pub mod sector; -pub mod buffer; +pub mod volume; pub mod fs; #[cfg(test)] diff --git a/src/sys/block_group.rs b/src/sys/block_group.rs index 56c9dbf..2cc40e7 100644 --- a/src/sys/block_group.rs +++ b/src/sys/block_group.rs @@ -5,7 +5,7 @@ use alloc::Vec; use error::Error; use sector::{Address, Size}; -use buffer::Buffer; +use volume::Volume; /// The Block Group Descriptor Table contains a descriptor for each block group /// within the file system. The number of block groups within the file system, @@ -54,13 +54,13 @@ impl Debug for BlockGroupDescriptor { impl BlockGroupDescriptor { pub unsafe fn find_descriptor< S: Size + Copy + PartialOrd, - B: Buffer>, + V: Volume>, >( - haystack: &B, + haystack: &V, offset: Address, ) -> Result<(BlockGroupDescriptor, Address), Error> where - Error: From, + Error: From, { let end = offset + Address::from(mem::size_of::()); @@ -81,14 +81,14 @@ impl BlockGroupDescriptor { pub unsafe fn find_descriptor_table< S: Size + Copy + PartialOrd, - B: Buffer>, + V: Volume>, >( - haystack: &B, + haystack: &V, offset: Address, count: usize, ) -> Result<(Vec, Address), Error> where - Error: From, + Error: From, { let end = offset + Address::from(count * mem::size_of::()); @@ -120,10 +120,10 @@ mod tests { #[test] fn find() { - let buffer = vec![0_u8; 4096]; + let volume = vec![0_u8; 4096]; let table = unsafe { BlockGroupDescriptor::find_descriptor_table( - &buffer, + &volume, Address::::new(4, 0), 8, ) diff --git a/src/sys/inode.rs b/src/sys/inode.rs index 44f8cd0..e537ccb 100644 --- a/src/sys/inode.rs +++ b/src/sys/inode.rs @@ -3,7 +3,7 @@ use core::fmt::{self, Debug}; use error::Error; use sector::{Address, Size}; -use buffer::Buffer; +use volume::Volume; /// An inode is a structure on the disk that represents a file, directory, /// symbolic link, etc. Inodes do not contain the data of the file / directory / @@ -99,14 +99,14 @@ impl Debug for Inode { impl Inode { pub unsafe fn find_inode< S: Size + Copy + PartialOrd, - B: Buffer>, + V: Volume>, >( - haystack: &B, + haystack: &V, offset: Address, size: usize, ) -> Result<(Inode, Address), Error> where - Error: From, + Error: From, { if size != mem::size_of::() { unimplemented!("inodes with a size != 128"); diff --git a/src/sys/superblock.rs b/src/sys/superblock.rs index eab0395..6f44b6a 100644 --- a/src/sys/superblock.rs +++ b/src/sys/superblock.rs @@ -3,7 +3,7 @@ use core::fmt::{self, Debug}; use error::Error; use sector::{Address, Size}; -use buffer::Buffer; +use volume::Volume; /// Ext2 signature (0xef53), used to help confirm the presence of Ext2 on a /// volume @@ -195,11 +195,11 @@ impl Debug for Superblock { } impl Superblock { - pub unsafe fn find>>( - haystack: &B, + pub unsafe fn find>>( + haystack: &V, ) -> Result<(Superblock, Address), Error> where - Error: From, + Error: From, { let offset = Address::from(1024_usize); let end = offset + Address::from(mem::size_of::()); @@ -301,11 +301,11 @@ mod tests { #[test] fn find() { - let mut buffer = vec![0_u8; 4096]; + let mut volume = vec![0_u8; 4096]; // magic - buffer[1024 + 56] = EXT2_MAGIC as u8; - buffer[1024 + 57] = (EXT2_MAGIC >> 8) as u8; - let superblock = unsafe { Superblock::find::(&buffer) }; + volume[1024 + 56] = EXT2_MAGIC as u8; + volume[1024 + 57] = (EXT2_MAGIC >> 8) as u8; + let superblock = unsafe { Superblock::find::(&volume) }; assert!( superblock.is_ok(), "Err({:?})", diff --git a/src/buffer/length.rs b/src/volume/length.rs similarity index 100% rename from src/buffer/length.rs rename to src/volume/length.rs diff --git a/src/buffer/mod.rs b/src/volume/mod.rs similarity index 73% rename from src/buffer/mod.rs rename to src/volume/mod.rs index 57b4ca5..165bd3f 100644 --- a/src/buffer/mod.rs +++ b/src/volume/mod.rs @@ -12,7 +12,7 @@ use sector::{Address, Size}; pub mod length; use self::length::Length; -pub trait Buffer +pub trait Volume where [T]: ToOwned, Idx: PartialEq + PartialOrd, @@ -22,17 +22,17 @@ where fn len(&self) -> Length; fn commit( &mut self, - slice: Option>, + slice: Option>, ) -> Result<(), Self::Error>; unsafe fn slice_unchecked<'a>( &'a self, range: Range, - ) -> BufferSlice<'a, T, Idx>; + ) -> VolumeSlice<'a, T, Idx>; fn slice<'a>( &'a self, range: Range, - ) -> Option> { + ) -> Option> { if self.len() >= range.end && self.len() > range.start { unsafe { Some(self.slice_unchecked(range)) } } else { @@ -41,7 +41,7 @@ where } } -pub struct BufferSlice<'a, T: 'a, Idx> +pub struct VolumeSlice<'a, T: 'a, Idx> where [T]: ToOwned, { @@ -49,39 +49,39 @@ where index: Idx, } -impl BufferSlice<'static, T, Idx> +impl VolumeSlice<'static, T, Idx> where [T]: ToOwned, { - pub fn with_static(inner: &'static [T]) -> BufferSlice<'static, T, Idx> { - BufferSlice { + pub fn with_static(inner: &'static [T]) -> VolumeSlice<'static, T, Idx> { + VolumeSlice { inner: Cow::Borrowed(inner), index: Idx::default(), } } } -impl BufferSlice<'static, T, Idx> +impl VolumeSlice<'static, T, Idx> where [T]: ToOwned, { pub fn new_owned( inner: <[T] as ToOwned>::Owned, index: Idx, - ) -> BufferSlice<'static, T, Idx> { - BufferSlice { + ) -> VolumeSlice<'static, T, Idx> { + VolumeSlice { inner: Cow::Owned(inner), index, } } } -impl<'a, T, Idx> BufferSlice<'a, T, Idx> +impl<'a, T, Idx> VolumeSlice<'a, T, Idx> where [T]: ToOwned, { - pub fn new(inner: &'a [T], index: Idx) -> BufferSlice<'a, T, Idx> { - BufferSlice { + pub fn new(inner: &'a [T], index: Idx) -> VolumeSlice<'a, T, Idx> { + VolumeSlice { inner: Cow::Borrowed(inner), index, } @@ -99,7 +99,7 @@ where } } -impl<'a, Idx: Copy> BufferSlice<'a, u8, Idx> { +impl<'a, Idx: Copy> VolumeSlice<'a, u8, Idx> { pub unsafe fn dynamic_cast(&self) -> (T, Idx) { assert!(self.inner.len() >= mem::size_of::()); let index = self.index; @@ -110,28 +110,28 @@ impl<'a, Idx: Copy> BufferSlice<'a, u8, Idx> { pub fn from_cast( cast: &'a T, index: Idx, - ) -> BufferSlice<'a, u8, Idx> { + ) -> VolumeSlice<'a, u8, Idx> { let len = mem::size_of::(); let ptr = cast as *const T as *const u8; let slice = unsafe { slice::from_raw_parts(ptr, len) }; - BufferSlice::new(slice, index) + VolumeSlice::new(slice, index) } } -impl<'a, T, Idx> BufferSlice<'a, T, Idx> +impl<'a, T, Idx> VolumeSlice<'a, T, Idx> where [T]: ToOwned>, { - pub fn commit(self) -> Option> { + pub fn commit(self) -> Option> { if self.is_mutated() { - Some(BufferCommit::new(self.inner.into_owned(), self.index)) + Some(VolumeCommit::new(self.inner.into_owned(), self.index)) } else { None } } } -impl<'a, T, Idx> AsRef<[T]> for BufferSlice<'a, T, Idx> +impl<'a, T, Idx> AsRef<[T]> for VolumeSlice<'a, T, Idx> where [T]: ToOwned, { @@ -140,7 +140,7 @@ where } } -impl<'a, T, Idx> AsMut<[T]> for BufferSlice<'a, T, Idx> +impl<'a, T, Idx> AsMut<[T]> for VolumeSlice<'a, T, Idx> where [T]: ToOwned, <[T] as ToOwned>::Owned: AsMut<[T]>, @@ -150,7 +150,7 @@ where } } -impl<'a, T, Idx> Deref for BufferSlice<'a, T, Idx> +impl<'a, T, Idx> Deref for VolumeSlice<'a, T, Idx> where [T]: ToOwned, { @@ -161,7 +161,7 @@ where } } -impl<'a, T, Idx> DerefMut for BufferSlice<'a, T, Idx> +impl<'a, T, Idx> DerefMut for VolumeSlice<'a, T, Idx> where [T]: ToOwned, <[T] as ToOwned>::Owned: AsMut<[T]>, @@ -171,23 +171,23 @@ where } } -pub struct BufferCommit { +pub struct VolumeCommit { inner: Vec, index: Idx, } -impl BufferCommit { - pub fn with_vec(inner: Vec) -> BufferCommit { - BufferCommit { +impl VolumeCommit { + pub fn with_vec(inner: Vec) -> VolumeCommit { + VolumeCommit { inner, index: Idx::default(), } } } -impl BufferCommit { - pub fn new(inner: Vec, index: Idx) -> BufferCommit { - BufferCommit { inner, index } +impl VolumeCommit { + pub fn new(inner: Vec, index: Idx) -> VolumeCommit { + VolumeCommit { inner, index } } pub fn into_inner(self) -> Vec { @@ -199,19 +199,19 @@ impl BufferCommit { } } -impl AsRef<[T]> for BufferCommit { +impl AsRef<[T]> for VolumeCommit { fn as_ref(&self) -> &[T] { self.inner.as_ref() } } -impl AsMut<[T]> for BufferCommit { +impl AsMut<[T]> for VolumeCommit { fn as_mut(&mut self) -> &mut [T] { self.inner.as_mut() } } -impl Deref for BufferCommit { +impl Deref for VolumeCommit { type Target = [T]; fn deref(&self) -> &Self::Target { @@ -219,15 +219,15 @@ impl Deref for BufferCommit { } } -impl DerefMut for BufferCommit { +impl DerefMut for VolumeCommit { fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut() } } macro_rules! impl_slice { - (@inner $buffer:ty $( , $lt:lifetime )* ) => { - impl<$( $lt, )* S: Size + PartialOrd + Copy, T> Buffer> for $buffer + (@inner $volume:ty $( , $lt:lifetime )* ) => { + impl<$( $lt, )* S: Size + PartialOrd + Copy, T> Volume> for $volume where T: Clone, [T]: ToOwned, @@ -238,7 +238,7 @@ macro_rules! impl_slice { Length::Bounded(Address::from(>::as_ref(self).len())) } - fn commit(&mut self, slice: Option>>) -> Result<(), Infallible> { + fn commit(&mut self, slice: Option>>) -> Result<(), Infallible> { slice.map(|slice| { let index = slice.at_index().index64() as usize; let end = index + slice.as_ref().len(); @@ -254,21 +254,21 @@ macro_rules! impl_slice { unsafe fn slice_unchecked<'a>( &'a self, range: Range>, - ) -> BufferSlice<'a, T, Address> { + ) -> VolumeSlice<'a, T, Address> { let index = range.start; let range = range.start.index64() as usize..range.end.index64() as usize; - BufferSlice::new( + VolumeSlice::new( >::as_ref(self).get_unchecked(range), index, ) } } }; - ($buffer:ty) => { - impl_slice!(@inner $buffer); + ($volume:ty) => { + impl_slice!(@inner $volume); }; - ($buffer:ty $( , $lt:lifetime )* ) => { - impl_slice!(@inner $buffer $( , $lt )* ); + ($volume:ty $( , $lt:lifetime )* ) => { + impl_slice!(@inner $volume $( , $lt )* ); }; } @@ -285,10 +285,10 @@ mod file { use sector::{Address, Size}; - use super::{Buffer, BufferCommit, BufferSlice}; + use super::{Volume, VolumeCommit, VolumeSlice}; use super::length::Length; - impl Buffer> for RefCell { + impl Volume> for RefCell { type Error = io::Error; fn len(&self) -> Length> { @@ -302,7 +302,7 @@ mod file { fn commit( &mut self, - slice: Option>>, + slice: Option>>, ) -> Result<(), Self::Error> { slice .map(|slice| { @@ -320,7 +320,7 @@ mod file { unsafe fn slice_unchecked<'a>( &'a self, range: Range>, - ) -> BufferSlice<'a, u8, Address> { + ) -> VolumeSlice<'a, u8, Address> { let index = range.start; let len = range.end - range.start; let mut vec = Vec::with_capacity(len.index64() as usize); @@ -330,15 +330,15 @@ mod file { .seek(SeekFrom::Start(index.index64())) .and_then(|_| refmut.read_exact(&mut vec[..])) .unwrap_or_else(|err| { - panic!("could't read from File Buffer: {:?}", err) + panic!("could't read from File Volume: {:?}", err) }); - BufferSlice::new_owned(vec, index) + VolumeSlice::new_owned(vec, index) } fn slice<'a>( &'a self, range: Range>, - ) -> Option>> { + ) -> Option>> { let index = range.start; let mut vec = Vec::with_capacity( (range.end - range.start).index64() as usize, @@ -347,7 +347,7 @@ mod file { refmut .seek(SeekFrom::Start(index.index64())) .and_then(|_| refmut.read_exact(&mut vec[..])) - .map(move |_| BufferSlice::new_owned(vec, index)) + .map(move |_| VolumeSlice::new_owned(vec, index)) .ok() } } @@ -359,10 +359,10 @@ mod tests { use super::*; #[test] - fn buffer() { - let mut buffer = vec![0; 1024]; + fn volume() { + let mut volume = vec![0; 1024]; let commit = { - let mut slice = buffer + let mut slice = volume .slice( Address::::from(256_usize) ..Address::::from(512_usize), @@ -371,9 +371,9 @@ mod tests { slice.iter_mut().for_each(|x| *x = 1); slice.commit() }; - assert!(buffer.commit(commit).is_ok()); + assert!(volume.commit(commit).is_ok()); - for (i, &x) in buffer.iter().enumerate() { + for (i, &x) in volume.iter().enumerate() { if i < 256 || i >= 512 { assert_eq!(x, 0); } else {