Skip to content

Commit 0c40987

Browse files
dianpopadianpopa
committed
fix incorrectly commented code for doc examples
and format the code afterwards. Signed-off-by: Diana Popa <[email protected]>
1 parent faf595e commit 0c40987

File tree

2 files changed

+109
-101
lines changed

2 files changed

+109
-101
lines changed

‎memory_model/src/guest_memory.rs

Lines changed: 67 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -97,13 +97,13 @@ impl GuestMemory {
9797
/// # Examples
9898
///
9999
/// ```
100-
/// # use memory_model::{Address, GuestAddress, GuestMemory, MemoryMapping};
101-
/// # fn test_end_addr() -> Result<(), ()> {
100+
/// use memory_model::{Address, GuestAddress, GuestMemory, MemoryMapping};
101+
/// fn test_end_addr() -> Result<(), ()> {
102102
/// let start_addr = GuestAddress(0x1000);
103103
/// let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
104104
/// assert_eq!(start_addr.checked_add(0x400), Some(gm.end_addr()));
105105
/// Ok(())
106-
/// # }
106+
/// }
107107
/// ```
108108
pub fn end_addr(&self) -> GuestAddress {
109109
self.regions
@@ -180,14 +180,16 @@ impl GuestMemory {
180180
/// * Write a slice at guestaddress 0x200.
181181
///
182182
/// ```
183-
/// # use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
184-
/// # fn test_write_u64() -> Result<(), ()> {
185-
/// # let start_addr = GuestAddress(0x1000);
186-
/// # let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
187-
/// let res = gm.write_slice_at_addr(&[1,2,3,4,5], GuestAddress(0x200)).map_err(|_| ())?;
183+
/// use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
184+
/// fn test_write_u64() -> Result<(), ()> {
185+
/// let start_addr = GuestAddress(0x1000);
186+
/// let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
187+
/// let res = gm
188+
/// .write_slice_at_addr(&[1, 2, 3, 4, 5], GuestAddress(0x200))
189+
/// .map_err(|_| ())?;
188190
/// assert_eq!(5, res);
189191
/// Ok(())
190-
/// # }
192+
/// }
191193
/// ```
192194
pub fn write_slice_at_addr(&self, buf: &[u8], guest_addr: GuestAddress) -> Result<usize> {
193195
self.do_in_region_partial(guest_addr, move |mapping, offset| {
@@ -206,15 +208,17 @@ impl GuestMemory {
206208
/// * Read a slice of length 16 at guestaddress 0x200.
207209
///
208210
/// ```
209-
/// # use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
210-
/// # fn test_write_u64() -> Result<(), ()> {
211-
/// # let start_addr = GuestAddress(0x1000);
212-
/// # let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
211+
/// use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
212+
/// fn test_write_u64() -> Result<(), ()> {
213+
/// let start_addr = GuestAddress(0x1000);
214+
/// let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
213215
/// let buf = &mut [0u8; 16];
214-
/// let res = gm.read_slice_at_addr(buf, GuestAddress(0x200)).map_err(|_| ())?;
216+
/// let res = gm
217+
/// .read_slice_at_addr(buf, GuestAddress(0x200))
218+
/// .map_err(|_| ())?;
215219
/// assert_eq!(16, res);
216220
/// Ok(())
217-
/// # }
221+
/// }
218222
/// ```
219223
pub fn read_slice_at_addr(&self, buf: &mut [u8], guest_addr: GuestAddress) -> Result<usize> {
220224
self.do_in_region_partial(guest_addr, move |mapping, offset| {
@@ -236,16 +240,18 @@ impl GuestMemory {
236240
/// * Read a u64 from two areas of guest memory backed by separate mappings.
237241
///
238242
/// ```
239-
/// # use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
240-
/// # fn test_read_u64() -> Result<u64, ()> {
241-
/// # let start_addr1 = GuestAddress(0x0);
242-
/// # let start_addr2 = GuestAddress(0x400);
243-
/// # let mut gm = GuestMemory::new(&vec![(start_addr1, 0x400), (start_addr2, 0x400)])
244-
/// # .map_err(|_| ())?;
245-
/// let num1: u64 = gm.read_obj_from_addr(GuestAddress(32)).map_err(|_| ())?;
246-
/// let num2: u64 = gm.read_obj_from_addr(GuestAddress(0x400+32)).map_err(|_| ())?;
247-
/// # Ok(num1 + num2)
248-
/// # }
243+
/// use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
244+
/// fn test_read_u64() -> Result<u64, ()> {
245+
/// let start_addr1 = GuestAddress(0x0);
246+
/// let start_addr2 = GuestAddress(0x400);
247+
/// let mut gm =
248+
/// GuestMemory::new(&vec![(start_addr1, 0x400), (start_addr2, 0x400)]).map_err(|_| ())?;
249+
/// let num1: u64 = gm.read_obj_from_addr(GuestAddress(32)).map_err(|_| ())?;
250+
/// let num2: u64 = gm
251+
/// .read_obj_from_addr(GuestAddress(0x400 + 32))
252+
/// .map_err(|_| ())?;
253+
/// Ok(num1 + num2)
254+
/// }
249255
/// ```
250256
pub fn read_obj_from_addr<T: DataInit>(&self, guest_addr: GuestAddress) -> Result<T> {
251257
self.do_in_region(guest_addr, mem::size_of::<T>(), |mapping, offset| {
@@ -265,13 +271,13 @@ impl GuestMemory {
265271
/// * Write a u64 at guest address 0x1100.
266272
///
267273
/// ```
268-
/// # use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
269-
/// # fn test_write_u64() -> Result<(), ()> {
270-
/// # let start_addr = GuestAddress(0x1000);
271-
/// # let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
274+
/// use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
275+
/// fn test_write_u64() -> Result<(), ()> {
276+
/// let start_addr = GuestAddress(0x1000);
277+
/// let mut gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
272278
/// gm.write_obj_at_addr(55u64, GuestAddress(0x1100))
273279
/// .map_err(|_| ())
274-
/// # }
280+
/// }
275281
/// ```
276282
pub fn write_obj_at_addr<T: DataInit>(&self, val: T, guest_addr: GuestAddress) -> Result<()> {
277283
self.do_in_region(guest_addr, mem::size_of::<T>(), move |mapping, offset| {
@@ -293,19 +299,19 @@ impl GuestMemory {
293299
/// * Read bytes from /dev/urandom
294300
///
295301
/// ```
296-
/// # use memory_model::{Address, GuestAddress, GuestMemory, MemoryMapping};
297-
/// # use std::fs::File;
298-
/// # use std::path::Path;
299-
/// # fn test_read_random() -> Result<u32, ()> {
300-
/// # let start_addr = GuestAddress(0x1000);
301-
/// # let gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
302-
/// let mut file = File::open(Path::new("/dev/urandom")).map_err(|_| ())?;
303-
/// let addr = GuestAddress(0x1010);
304-
/// gm.read_to_memory(addr, &mut file, 128).map_err(|_| ())?;
305-
/// let read_addr = addr.checked_add(8).ok_or(())?;
306-
/// let rand_val: u32 = gm.read_obj_from_addr(read_addr).map_err(|_| ())?;
307-
/// # Ok(rand_val)
308-
/// # }
302+
/// use memory_model::{Address, GuestAddress, GuestMemory, MemoryMapping};
303+
/// use std::fs::File;
304+
/// use std::path::Path;
305+
/// fn test_read_random() -> Result<u32, ()> {
306+
/// let start_addr = GuestAddress(0x1000);
307+
/// let gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
308+
/// let mut file = File::open(Path::new("/dev/urandom")).map_err(|_| ())?;
309+
/// let addr = GuestAddress(0x1010);
310+
/// gm.read_to_memory(addr, &mut file, 128).map_err(|_| ())?;
311+
/// let read_addr = addr.checked_add(8).ok_or(())?;
312+
/// let rand_val: u32 = gm.read_obj_from_addr(read_addr).map_err(|_| ())?;
313+
/// Ok(rand_val)
314+
/// }
309315
/// ```
310316
pub fn read_to_memory<F>(
311317
&self,
@@ -335,17 +341,17 @@ impl GuestMemory {
335341
/// * Write 128 bytes to /dev/null
336342
///
337343
/// ```
338-
/// # use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
339-
/// # use std::fs::File;
340-
/// # use std::path::Path;
341-
/// # fn test_write_null() -> Result<(), ()> {
342-
/// # let start_addr = GuestAddress(0x1000);
343-
/// # let gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
344-
/// let mut file = File::open(Path::new("/dev/null")).map_err(|_| ())?;
345-
/// let addr = GuestAddress(0x1010);
346-
/// gm.write_from_memory(addr, &mut file, 128).map_err(|_| ())?;
347-
/// # Ok(())
348-
/// # }
344+
/// use memory_model::{GuestAddress, GuestMemory, MemoryMapping};
345+
/// use std::fs::File;
346+
/// use std::path::Path;
347+
/// fn test_write_null() -> Result<(), ()> {
348+
/// let start_addr = GuestAddress(0x1000);
349+
/// let gm = GuestMemory::new(&vec![(start_addr, 0x400)]).map_err(|_| ())?;
350+
/// let mut file = File::open(Path::new("/dev/null")).map_err(|_| ())?;
351+
/// let addr = GuestAddress(0x1010);
352+
/// gm.write_from_memory(addr, &mut file, 128).map_err(|_| ())?;
353+
/// Ok(())
354+
/// }
349355
/// ```
350356
pub fn write_from_memory<F>(
351357
&self,
@@ -374,14 +380,14 @@ impl GuestMemory {
374380
/// # Examples
375381
///
376382
/// ```
377-
/// # use memory_model::{GuestAddress, GuestMemory};
378-
/// # fn test_host_addr() -> Result<(), ()> {
383+
/// use memory_model::{GuestAddress, GuestMemory};
384+
/// fn test_host_addr() -> Result<(), ()> {
379385
/// let start_addr = GuestAddress(0x1000);
380386
/// let mut gm = GuestMemory::new(&vec![(start_addr, 0x500)]).map_err(|_| ())?;
381387
/// let addr = gm.get_host_address(GuestAddress(0x1200)).unwrap();
382388
/// println!("Host address is {:p}", addr);
383389
/// Ok(())
384-
/// # }
390+
/// }
385391
/// ```
386392
pub fn get_host_address(&self, guest_addr: GuestAddress) -> Result<*const u8> {
387393
self.do_in_region(guest_addr, 1, |mapping, offset| {
@@ -408,19 +414,19 @@ impl GuestMemory {
408414
/// and dividing their sizes to 1024, then summing up the values in an accumulator.
409415
///
410416
/// ```
411-
/// # use memory_model::{GuestAddress, GuestMemory};
412-
/// # fn test_map_fold() -> Result<(), ()> {
417+
/// use memory_model::{GuestAddress, GuestMemory};
418+
/// fn test_map_fold() -> Result<(), ()> {
413419
/// let start_addr1 = GuestAddress(0x0);
414420
/// let start_addr2 = GuestAddress(0x400);
415421
/// let mem = GuestMemory::new(&vec![(start_addr1, 1024), (start_addr2, 2048)]).unwrap();
416422
/// let total_size = mem.map_and_fold(
417423
/// 0,
418424
/// |(_, region)| region.size() / 1024,
419-
/// |acc, size| acc + size
425+
/// |acc, size| acc + size,
420426
/// );
421427
/// println!("Total memory size = {} KB", total_size);
422428
/// Ok(())
423-
/// # }
429+
/// }
424430
/// ```
425431
pub fn map_and_fold<F, G, T>(&self, init: T, mapf: F, foldf: G) -> T
426432
where

‎memory_model/src/mmap.rs

Lines changed: 42 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -94,11 +94,11 @@ impl MemoryMapping {
9494
/// * Write a slice at offset 256.
9595
///
9696
/// ```
97-
/// # use memory_model::MemoryMapping;
98-
/// # let mut mem_map = MemoryMapping::new(1024).unwrap();
99-
/// let res = mem_map.write_slice(&[1,2,3,4,5], 256);
100-
/// assert!(res.is_ok());
101-
/// assert_eq!(res.unwrap(), 5);
97+
/// use memory_model::MemoryMapping;
98+
/// let mut mem_map = MemoryMapping::new(1024).unwrap();
99+
/// let res = mem_map.write_slice(&[1, 2, 3, 4, 5], 256);
100+
/// assert!(res.is_ok());
101+
/// assert_eq!(res.unwrap(), 5);
102102
/// ```
103103
pub fn write_slice(&self, buf: &[u8], offset: usize) -> Result<usize> {
104104
if offset >= self.size {
@@ -122,12 +122,12 @@ impl MemoryMapping {
122122
/// * Read a slice of size 16 at offset 256.
123123
///
124124
/// ```
125-
/// # use memory_model::MemoryMapping;
126-
/// # let mut mem_map = MemoryMapping::new(1024).unwrap();
127-
/// let buf = &mut [0u8; 16];
128-
/// let res = mem_map.read_slice(buf, 256);
129-
/// assert!(res.is_ok());
130-
/// assert_eq!(res.unwrap(), 16);
125+
/// use memory_model::MemoryMapping;
126+
/// let mut mem_map = MemoryMapping::new(1024).unwrap();
127+
/// let buf = &mut [0u8; 16];
128+
/// let res = mem_map.read_slice(buf, 256);
129+
/// assert!(res.is_ok());
130+
/// assert_eq!(res.unwrap(), 16);
131131
/// ```
132132
pub fn read_slice(&self, mut buf: &mut [u8], offset: usize) -> Result<usize> {
133133
if offset >= self.size {
@@ -149,10 +149,10 @@ impl MemoryMapping {
149149
/// * Write a u64 at offset 16.
150150
///
151151
/// ```
152-
/// # use memory_model::MemoryMapping;
153-
/// # let mut mem_map = MemoryMapping::new(1024).unwrap();
154-
/// let res = mem_map.write_obj(55u64, 16);
155-
/// assert!(res.is_ok());
152+
/// use memory_model::MemoryMapping;
153+
/// let mut mem_map = MemoryMapping::new(1024).unwrap();
154+
/// let res = mem_map.write_obj(55u64, 16);
155+
/// assert!(res.is_ok());
156156
/// ```
157157
pub fn write_obj<T: DataInit>(&self, val: T, offset: usize) -> Result<()> {
158158
unsafe {
@@ -177,12 +177,12 @@ impl MemoryMapping {
177177
/// * Read a u64 written to offset 32.
178178
///
179179
/// ```
180-
/// # use memory_model::MemoryMapping;
181-
/// # let mut mem_map = MemoryMapping::new(1024).unwrap();
182-
/// let res = mem_map.write_obj(55u64, 32);
183-
/// assert!(res.is_ok());
184-
/// let num: u64 = mem_map.read_obj(32).unwrap();
185-
/// assert_eq!(55, num);
180+
/// use memory_model::MemoryMapping;
181+
/// let mut mem_map = MemoryMapping::new(1024).unwrap();
182+
/// let res = mem_map.write_obj(55u64, 32);
183+
/// assert!(res.is_ok());
184+
/// let num: u64 = mem_map.read_obj(32).unwrap();
185+
/// assert_eq!(55, num);
186186
/// ```
187187
pub fn read_obj<T: DataInit>(&self, offset: usize) -> Result<T> {
188188
let (end, fail) = offset.overflowing_add(std::mem::size_of::<T>());
@@ -210,16 +210,16 @@ impl MemoryMapping {
210210
/// * Read bytes from /dev/urandom
211211
///
212212
/// ```
213-
/// # use memory_model::MemoryMapping;
214-
/// # use std::fs::File;
215-
/// # use std::path::Path;
216-
/// # fn test_read_random() -> Result<u32, ()> {
217-
/// # let mut mem_map = MemoryMapping::new(1024).unwrap();
218-
/// let mut file = File::open(Path::new("/dev/urandom")).map_err(|_| ())?;
219-
/// mem_map.read_to_memory(32, &mut file, 128).map_err(|_| ())?;
220-
/// let rand_val: u32 = mem_map.read_obj(40).map_err(|_| ())?;
221-
/// # Ok(rand_val)
222-
/// # }
213+
/// use memory_model::MemoryMapping;
214+
/// use std::fs::File;
215+
/// use std::path::Path;
216+
/// fn test_read_random() -> Result<u32, ()> {
217+
/// let mut mem_map = MemoryMapping::new(1024).unwrap();
218+
/// let mut file = File::open(Path::new("/dev/urandom")).map_err(|_| ())?;
219+
/// mem_map.read_to_memory(32, &mut file, 128).map_err(|_| ())?;
220+
/// let rand_val: u32 = mem_map.read_obj(40).map_err(|_| ())?;
221+
/// Ok(rand_val)
222+
/// }
223223
/// ```
224224
pub fn read_to_memory<F>(&self, mem_offset: usize, src: &mut F, count: usize) -> Result<()>
225225
where
@@ -251,15 +251,17 @@ impl MemoryMapping {
251251
/// * Write 128 bytes to /dev/null
252252
///
253253
/// ```
254-
/// # use memory_model::MemoryMapping;
255-
/// # use std::fs::File;
256-
/// # use std::path::Path;
257-
/// # fn test_write_null() -> Result<(), ()> {
258-
/// # let mut mem_map = MemoryMapping::new(1024).unwrap();
259-
/// let mut file = File::open(Path::new("/dev/null")).map_err(|_| ())?;
260-
/// mem_map.write_from_memory(32, &mut file, 128).map_err(|_| ())?;
261-
/// # Ok(())
262-
/// # }
254+
/// use memory_model::MemoryMapping;
255+
/// use std::fs::File;
256+
/// use std::path::Path;
257+
/// fn test_write_null() -> Result<(), ()> {
258+
/// let mut mem_map = MemoryMapping::new(1024).unwrap();
259+
/// let mut file = File::open(Path::new("/dev/null")).map_err(|_| ())?;
260+
/// mem_map
261+
/// .write_from_memory(32, &mut file, 128)
262+
/// .map_err(|_| ())?;
263+
/// Ok(())
264+
/// }
263265
/// ```
264266
pub fn write_from_memory<F>(&self, mem_offset: usize, dst: &mut F, count: usize) -> Result<()>
265267
where

0 commit comments

Comments
 (0)