2947286109

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/google/OpenSK/commit/<a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/987ed98b493e67c0fcd138246287c3ad86bd28f0">987ed98b4">&lt;a href=&quot;https://github.com/google/OpenSK/commit/</a><a class="double-link" href="https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/987ed98b493e67c0fcd138246287c3ad86bd28f0">987ed98b4</a><a href="https://github.com/google/OpenSK/commit/987ed98b493e67c0fcd138246287c3ad86bd28f0">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/987ed98b493e67c0fcd138246287c3ad86bd28f0&quot;&gt;987ed98b4&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/987ed98b493e67c0fcd138246287c3ad86bd28f0&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #538: Storage type

Run Details

6 of 6 new or added lines in 1 file covered. (100.0%)

14273 of 16160 relevant lines covered (88.32%)

514271.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/env/tock/storage.rs

// Copyright 2019-2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::api::upgrade_storage::helper::{find_slice, is_aligned, ModRange};
use crate::api::upgrade_storage::UpgradeStorage;
use alloc::borrow::Cow;
use alloc::vec::Vec;
use core::cell::Cell;
use libtock_core::{callback, syscalls};
use persistent_store::{Storage, StorageError, StorageIndex, StorageResult};

const DRIVER_NUMBER: usize = 0x50003;

mod subscribe_nr {
    pub const DONE: usize = 0;
}

mod command_nr {
    pub const GET_INFO: usize = 1;
    pub mod get_info_nr {
        pub const WORD_SIZE: usize = 0;
        pub const PAGE_SIZE: usize = 1;
        pub const MAX_WORD_WRITES: usize = 2;
        pub const MAX_PAGE_ERASES: usize = 3;
    }
    pub const WRITE_SLICE: usize = 2;
    pub const ERASE_PAGE: usize = 3;
}

mod allow_nr {
    pub const WRITE_SLICE: usize = 0;
}

mod memop_nr {
    pub const STORAGE_CNT: u32 = 12;
    pub const STORAGE_PTR: u32 = 13;
    pub const STORAGE_LEN: u32 = 14;
    pub const STORAGE_TYPE: u32 = 15;
}

mod storage_type {
    pub const STORE: usize = 1;
    pub const PARTITION: usize = 2;
}

fn get_info(nr: usize, arg: usize) -> StorageResult<usize> {
    let code = syscalls::command(DRIVER_NUMBER, command_nr::GET_INFO, nr, arg);
    code.map_err(|_| StorageError::CustomError)
}

fn memop(nr: u32, arg: usize) -> StorageResult<usize> {
    let code = unsafe { syscalls::raw::memop(nr, arg) };
    if code < 0 {
        Err(StorageError::CustomError)
    } else {
        Ok(code as usize)
    }
}

fn block_command(driver: usize, cmd: usize, arg1: usize, arg2: usize) -> StorageResult<()> {
    let done = Cell::new(None);
    let mut alarm = |status| done.set(Some(status));
    let subscription = syscalls::subscribe::<callback::Identity1Consumer, _>(
        DRIVER_NUMBER,
        subscribe_nr::DONE,
        &mut alarm,
    );
    if subscription.is_err() {
        return Err(StorageError::CustomError);
    }

    let code = syscalls::command(driver, cmd, arg1, arg2);
    if code.is_err() {
        return Err(StorageError::CustomError);
    }

    libtock_drivers::util::yieldk_for(|| done.get().is_some());
    if done.get().unwrap() == 0 {
        Ok(())
    } else {
        Err(StorageError::CustomError)
    }
}

fn write_slice(ptr: usize, value: &[u8]) -> StorageResult<()> {
    let code = unsafe {
        syscalls::raw::allow(
            DRIVER_NUMBER,
            allow_nr::WRITE_SLICE,
            // We rely on the driver not writing to the slice. This should use read-only allow
            // when available. See https://github.com/tock/tock/issues/1274.
            value.as_ptr() as *mut u8,
            value.len(),
        )
    };
    if code < 0 {
        return Err(StorageError::CustomError);
    }

    block_command(DRIVER_NUMBER, command_nr::WRITE_SLICE, ptr, value.len())
}

fn erase_page(ptr: usize, page_length: usize) -> StorageResult<()> {
    block_command(DRIVER_NUMBER, command_nr::ERASE_PAGE, ptr, page_length)
}

pub struct TockStorage {
    word_size: usize,
    page_size: usize,
    num_pages: usize,
    max_word_writes: usize,
    max_page_erases: usize,
    storage_locations: Vec<&'static [u8]>,
}

impl TockStorage {
    /// Provides access to the embedded flash if available.
    ///
    /// # Errors
    ///
    /// Returns `CustomError` if any of the following conditions do not hold:
    /// - The word size is a power of two.
    /// - The page size is a power of two.
    /// - The page size is a multiple of the word size.
    /// - The storage is page-aligned.
    pub fn new() -> StorageResult<TockStorage> {
        let mut syscall = TockStorage {
            word_size: get_info(command_nr::get_info_nr::WORD_SIZE, 0)?,
            page_size: get_info(command_nr::get_info_nr::PAGE_SIZE, 0)?,
            num_pages: 0,
            max_word_writes: get_info(command_nr::get_info_nr::MAX_WORD_WRITES, 0)?,
            max_page_erases: get_info(command_nr::get_info_nr::MAX_PAGE_ERASES, 0)?,
            storage_locations: Vec::new(),
        };
        if !syscall.word_size.is_power_of_two()
            || !syscall.page_size.is_power_of_two()
            || !syscall.is_word_aligned(syscall.page_size)
        {
            return Err(StorageError::CustomError);
        }
        for i in 0..memop(memop_nr::STORAGE_CNT, 0)? {
            if memop(memop_nr::STORAGE_TYPE, i)? != storage_type::STORE {
                continue;
            }
            let storage_ptr = memop(memop_nr::STORAGE_PTR, i)?;
            let storage_len = memop(memop_nr::STORAGE_LEN, i)?;
            if !syscall.is_page_aligned(storage_ptr) || !syscall.is_page_aligned(storage_len) {
                return Err(StorageError::CustomError);
            }
            syscall.num_pages += storage_len / syscall.page_size;
            syscall
                .storage_locations
                .push(unsafe { core::slice::from_raw_parts(storage_ptr as *mut u8, storage_len) });
        }
        Ok(syscall)
    }

    fn is_word_aligned(&self, x: usize) -> bool {
        is_aligned(self.word_size, x)
    }

    fn is_page_aligned(&self, x: usize) -> bool {
        is_aligned(self.page_size, x)
    }
}

impl Storage for TockStorage {
    fn word_size(&self) -> usize {
        self.word_size
    }

    fn page_size(&self) -> usize {
        self.page_size
    }

    fn num_pages(&self) -> usize {
        self.num_pages
    }

    fn max_word_writes(&self) -> usize {
        self.max_word_writes
    }

    fn max_page_erases(&self) -> usize {
        self.max_page_erases
    }

    fn read_slice(&self, index: StorageIndex, length: usize) -> StorageResult<Cow<[u8]>> {
        let start = index.range(length, self)?.start;
        find_slice(&self.storage_locations, start, length).map(Cow::Borrowed)
    }

    fn write_slice(&mut self, index: StorageIndex, value: &[u8]) -> StorageResult<()> {
        if !self.is_word_aligned(index.byte) || !self.is_word_aligned(value.len()) {
            return Err(StorageError::NotAligned);
        }
        let ptr = self.read_slice(index, value.len())?.as_ptr() as usize;
        write_slice(ptr, value)
    }

    fn erase_page(&mut self, page: usize) -> StorageResult<()> {
        let index = StorageIndex { page, byte: 0 };
        let length = self.page_size();
        let ptr = self.read_slice(index, length)?.as_ptr() as usize;
        erase_page(ptr, length)
    }
}

pub struct TockUpgradeStorage {
    page_size: usize,
    partition: ModRange,
    metadata: ModRange,
}

impl TockUpgradeStorage {
    const METADATA_ADDRESS_A: usize = 0x4000;
    const METADATA_ADDRESS_B: usize = 0x5000;

    /// Provides access to the other upgrade partition and metadata if available.
    ///
    /// The implementation assumes that storage locations returned by the kernel through
    /// `memop_nr::STORAGE_*` calls are in address space order.
    ///
    /// # Errors
    ///
    /// Returns `CustomError` if any of the following conditions do not hold:
    /// - The page size is a power of two.
    /// - The storage slices are page-aligned.
    /// - There are not partition or metadata slices.
    /// Returns a `NotAligned` error if partitions or metadata ranges are
    /// - not exclusive or,
    /// - not consecutive.
    pub fn new() -> StorageResult<TockUpgradeStorage> {
        let mut locations = TockUpgradeStorage {
            page_size: get_info(command_nr::get_info_nr::PAGE_SIZE, 0)?,
            partition: ModRange::new_empty(),
            metadata: ModRange::new_empty(),
        };
        if !locations.page_size.is_power_of_two() {
            return Err(StorageError::CustomError);
        }
        for i in 0..memop(memop_nr::STORAGE_CNT, 0)? {
            let storage_type = memop(memop_nr::STORAGE_TYPE, i)?;
            if !matches!(storage_type, storage_type::PARTITION) {
                continue;
            };
            let storage_ptr = memop(memop_nr::STORAGE_PTR, i)?;
            let storage_len = memop(memop_nr::STORAGE_LEN, i)?;
            if !locations.is_page_aligned(storage_ptr) || !locations.is_page_aligned(storage_len) {
                return Err(StorageError::CustomError);
            }
            let range = ModRange::new(storage_ptr, storage_len);
            match range.start() {
                Self::METADATA_ADDRESS_A | Self::METADATA_ADDRESS_B => locations.metadata = range,
                _ => {
                    locations.partition = locations
                        .partition
                        .append(range)
                        .ok_or(StorageError::NotAligned)?
                }
            }
        }
        if locations.partition.is_empty() {
            return Err(StorageError::CustomError);
        }
        Ok(locations)
    }

    fn is_page_aligned(&self, x: usize) -> bool {
        is_aligned(self.page_size, x)
    }
}

impl UpgradeStorage for TockUpgradeStorage {
    fn read_partition(&self, offset: usize, length: usize) -> StorageResult<&[u8]> {
        if length == 0 {
            return Err(StorageError::OutOfBounds);
        }
        let address = self.partition.start() + offset;
        if self
            .partition
            .contains_range(&ModRange::new(address, length))
        {
            Ok(unsafe { core::slice::from_raw_parts(address as *const u8, length) })
        } else {
            Err(StorageError::OutOfBounds)
        }
    }

    fn write_partition(&mut self, offset: usize, data: &[u8]) -> StorageResult<()> {
        if data.is_empty() {
            return Err(StorageError::OutOfBounds);
        }
        let address = self.partition.start() + offset;
        let write_range = ModRange::new(address, data.len());
        if self.partition.contains_range(&write_range) {
            // Erases all pages that have their first byte in the write range.
            // Since we expect calls in order, we don't want to erase half-written pages.
            for address in write_range.aligned_iter(self.page_size) {
                erase_page(address, self.page_size)?;
            }
            write_slice(address, data)
        } else {
            Err(StorageError::OutOfBounds)
        }
    }

    fn partition_address(&self) -> usize {
        self.partition.start()
    }

    fn partition_length(&self) -> usize {
        self.partition.length()
    }

    fn read_metadata(&self) -> StorageResult<&[u8]> {
        Ok(unsafe {
            core::slice::from_raw_parts(self.metadata.start() as *const u8, self.metadata.length())
        })
    }

    fn write_metadata(&mut self, data: &[u8]) -> StorageResult<()> {
        // If less data is passed in than is reserved, assume the rest is 0xFF.
        if data.len() <= self.metadata.length() {
            for address in self.metadata.aligned_iter(self.page_size) {
                erase_page(address, self.page_size)?;
            }
            write_slice(self.metadata.start(), data)
        } else {
            Err(StorageError::OutOfBounds)
        }
    }
}

1	// Copyright 2019-2021 Google LLC
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	use crate::api::upgrade_storage::helper::{find_slice, is_aligned, ModRange};
16	use crate::api::upgrade_storage::UpgradeStorage;
17	use alloc::borrow::Cow;
18	use alloc::vec::Vec;
19	use core::cell::Cell;
20	use libtock_core::{callback, syscalls};
21	use persistent_store::{Storage, StorageError, StorageIndex, StorageResult};
22
23	const DRIVER_NUMBER: usize = 0x50003;
24
25	mod subscribe_nr {
26	pub const DONE: usize = 0;
27	}
28
29	mod command_nr {
30	pub const GET_INFO: usize = 1;
31	pub mod get_info_nr {
32	pub const WORD_SIZE: usize = 0;
33	pub const PAGE_SIZE: usize = 1;
34	pub const MAX_WORD_WRITES: usize = 2;
35	pub const MAX_PAGE_ERASES: usize = 3;
36	}
37	pub const WRITE_SLICE: usize = 2;
38	pub const ERASE_PAGE: usize = 3;
39	}
40
41	mod allow_nr {
42	pub const WRITE_SLICE: usize = 0;
43	}
44
45	mod memop_nr {
46	pub const STORAGE_CNT: u32 = 12;
47	pub const STORAGE_PTR: u32 = 13;
48	pub const STORAGE_LEN: u32 = 14;
49	pub const STORAGE_TYPE: u32 = 15;
50	}
51
52	mod storage_type {
53	pub const STORE: usize = 1;
54	pub const PARTITION: usize = 2;
55	}
56
57	fn get_info(nr: usize, arg: usize) -> StorageResult<usize> {	×
58	let code = syscalls::command(DRIVER_NUMBER, command_nr::GET_INFO, nr, arg);	×
59	code.map_err(\|_\| StorageError::CustomError)	×
60	}	×
61
62	fn memop(nr: u32, arg: usize) -> StorageResult<usize> {	×
63	let code = unsafe { syscalls::raw::memop(nr, arg) };	×
64	if code < 0 {	×
65	Err(StorageError::CustomError)	×
66	} else {
67	Ok(code as usize)	×
68	}
69	}	×
70
71	fn block_command(driver: usize, cmd: usize, arg1: usize, arg2: usize) -> StorageResult<()> {	×
72	let done = Cell::new(None);	×
73	let mut alarm = \|status\| done.set(Some(status));	×
74	let subscription = syscalls::subscribe::<callback::Identity1Consumer, _>(	×
75	DRIVER_NUMBER,	×
76	subscribe_nr::DONE,	×
77	&mut alarm,	×
78	);	×
79	if subscription.is_err() {	×
80	return Err(StorageError::CustomError);	×
81	}	×
82		×
83	let code = syscalls::command(driver, cmd, arg1, arg2);	×
84	if code.is_err() {	×
85	return Err(StorageError::CustomError);	×
86	}	×
87		×
88	libtock_drivers::util::yieldk_for(\|\| done.get().is_some());	×
89	if done.get().unwrap() == 0 {	×
90	Ok(())	×
91	} else {
92	Err(StorageError::CustomError)	×
93	}
94	}	×
95
96	fn write_slice(ptr: usize, value: &[u8]) -> StorageResult<()> {	×
97	let code = unsafe {	×
98	syscalls::raw::allow(	×
99	DRIVER_NUMBER,	×
100	allow_nr::WRITE_SLICE,	×
101	// We rely on the driver not writing to the slice. This should use read-only allow	×
102	// when available. See https://github.com/tock/tock/issues/1274.	×
103	value.as_ptr() as *mut u8,	×
104	value.len(),	×
105	)	×
106	};	×
107	if code < 0 {	×
108	return Err(StorageError::CustomError);	×
109	}	×
110		×
111	block_command(DRIVER_NUMBER, command_nr::WRITE_SLICE, ptr, value.len())	×
112	}	×
113
114	fn erase_page(ptr: usize, page_length: usize) -> StorageResult<()> {
115	block_command(DRIVER_NUMBER, command_nr::ERASE_PAGE, ptr, page_length)
116	}
117
118	pub struct TockStorage {
119	word_size: usize,
120	page_size: usize,
121	num_pages: usize,
122	max_word_writes: usize,
123	max_page_erases: usize,
124	storage_locations: Vec<&'static [u8]>,
125	}
126
127	impl TockStorage {
128	/// Provides access to the embedded flash if available.
129	///
130	/// # Errors
131	///
132	/// Returns `CustomError` if any of the following conditions do not hold:
133	/// - The word size is a power of two.
134	/// - The page size is a power of two.
135	/// - The page size is a multiple of the word size.
136	/// - The storage is page-aligned.
137	pub fn new() -> StorageResult<TockStorage> {	×
138	let mut syscall = TockStorage {	×
139	word_size: get_info(command_nr::get_info_nr::WORD_SIZE, 0)?,	×
140	page_size: get_info(command_nr::get_info_nr::PAGE_SIZE, 0)?,	×
141	num_pages: 0,
142	max_word_writes: get_info(command_nr::get_info_nr::MAX_WORD_WRITES, 0)?,	×
143	max_page_erases: get_info(command_nr::get_info_nr::MAX_PAGE_ERASES, 0)?,	×
144	storage_locations: Vec::new(),	×
145	};
146	if !syscall.word_size.is_power_of_two()	×
147	\|\| !syscall.page_size.is_power_of_two()	×
148	\|\| !syscall.is_word_aligned(syscall.page_size)	×
149	{
150	return Err(StorageError::CustomError);	×
151	}	×
152	for i in 0..memop(memop_nr::STORAGE_CNT, 0)? {	×
153	if memop(memop_nr::STORAGE_TYPE, i)? != storage_type::STORE {	×
154	continue;
155	}	×
156	let storage_ptr = memop(memop_nr::STORAGE_PTR, i)?;	×
157	let storage_len = memop(memop_nr::STORAGE_LEN, i)?;	×
158	if !syscall.is_page_aligned(storage_ptr) \|\| !syscall.is_page_aligned(storage_len) {	×
159	return Err(StorageError::CustomError);	×
160	}	×
161	syscall.num_pages += storage_len / syscall.page_size;	×
162	syscall	×
163	.storage_locations	×
164	.push(unsafe { core::slice::from_raw_parts(storage_ptr as *mut u8, storage_len) });	×
165	}
166	Ok(syscall)	×
167	}	×
168
169	fn is_word_aligned(&self, x: usize) -> bool {
170	is_aligned(self.word_size, x)
171	}
172
173	fn is_page_aligned(&self, x: usize) -> bool {
174	is_aligned(self.page_size, x)
175	}
176	}
177
178	impl Storage for TockStorage {
179	fn word_size(&self) -> usize {
180	self.word_size
181	}
182
183	fn page_size(&self) -> usize {
184	self.page_size
185	}
186
187	fn num_pages(&self) -> usize {
188	self.num_pages
189	}
190
191	fn max_word_writes(&self) -> usize {
192	self.max_word_writes
193	}
194
195	fn max_page_erases(&self) -> usize {
196	self.max_page_erases
197	}
198
199	fn read_slice(&self, index: StorageIndex, length: usize) -> StorageResult<Cow<[u8]>> {	×
200	let start = index.range(length, self)?.start;	×
201	find_slice(&self.storage_locations, start, length).map(Cow::Borrowed)	×
202	}	×
203
204	fn write_slice(&mut self, index: StorageIndex, value: &[u8]) -> StorageResult<()> {	×
205	if !self.is_word_aligned(index.byte) \|\| !self.is_word_aligned(value.len()) {	×
206	return Err(StorageError::NotAligned);	×
207	}	×
208	let ptr = self.read_slice(index, value.len())?.as_ptr() as usize;	×
209	write_slice(ptr, value)	×
210	}	×
211
212	fn erase_page(&mut self, page: usize) -> StorageResult<()> {	×
213	let index = StorageIndex { page, byte: 0 };	×
214	let length = self.page_size();	×
215	let ptr = self.read_slice(index, length)?.as_ptr() as usize;	×
216	erase_page(ptr, length)	×
217	}	×
218	}
219
220	pub struct TockUpgradeStorage {
221	page_size: usize,
222	partition: ModRange,
223	metadata: ModRange,
224	}
225
226	impl TockUpgradeStorage {
227	const METADATA_ADDRESS_A: usize = 0x4000;
228	const METADATA_ADDRESS_B: usize = 0x5000;
229
230	/// Provides access to the other upgrade partition and metadata if available.
231	///
232	/// The implementation assumes that storage locations returned by the kernel through
233	/// `memop_nr::STORAGE_*` calls are in address space order.
234	///
235	/// # Errors
236	///
237	/// Returns `CustomError` if any of the following conditions do not hold:
238	/// - The page size is a power of two.
239	/// - The storage slices are page-aligned.
240	/// - There are not partition or metadata slices.
241	/// Returns a `NotAligned` error if partitions or metadata ranges are
242	/// - not exclusive or,
243	/// - not consecutive.
244	pub fn new() -> StorageResult<TockUpgradeStorage> {	×
245	let mut locations = TockUpgradeStorage {	×
246	page_size: get_info(command_nr::get_info_nr::PAGE_SIZE, 0)?,	×
247	partition: ModRange::new_empty(),	×
248	metadata: ModRange::new_empty(),	×
249	};	×
250	if !locations.page_size.is_power_of_two() {	×
251	return Err(StorageError::CustomError);	×
252	}	×
253	for i in 0..memop(memop_nr::STORAGE_CNT, 0)? {	×
254	let storage_type = memop(memop_nr::STORAGE_TYPE, i)?;	×
255	if !matches!(storage_type, storage_type::PARTITION) {	×
256	continue;
257	};	×
258	let storage_ptr = memop(memop_nr::STORAGE_PTR, i)?;	×
259	let storage_len = memop(memop_nr::STORAGE_LEN, i)?;	×
260	if !locations.is_page_aligned(storage_ptr) \|\| !locations.is_page_aligned(storage_len) {	×
261	return Err(StorageError::CustomError);	×
262	}	×
263	let range = ModRange::new(storage_ptr, storage_len);	×
264	match range.start() {	×
265	Self::METADATA_ADDRESS_A \| Self::METADATA_ADDRESS_B => locations.metadata = range,	×
266	_ => {
267	locations.partition = locations	×
268	.partition	×
269	.append(range)	×
270	.ok_or(StorageError::NotAligned)?	×
271	}
272	}
273	}
274	if locations.partition.is_empty() {	×
275	return Err(StorageError::CustomError);	×
276	}	×
277	Ok(locations)	×
278	}	×
279
280	fn is_page_aligned(&self, x: usize) -> bool {
281	is_aligned(self.page_size, x)
282	}
283	}
284
285	impl UpgradeStorage for TockUpgradeStorage {
286	fn read_partition(&self, offset: usize, length: usize) -> StorageResult<&[u8]> {	×
287	if length == 0 {	×
288	return Err(StorageError::OutOfBounds);	×
289	}	×
290	let address = self.partition.start() + offset;	×
291	if self	×
292	.partition	×
293	.contains_range(&ModRange::new(address, length))	×
294	{
295	Ok(unsafe { core::slice::from_raw_parts(address as *const u8, length) })	×
296	} else {
297	Err(StorageError::OutOfBounds)	×
298	}
299	}	×
300
301	fn write_partition(&mut self, offset: usize, data: &[u8]) -> StorageResult<()> {	×
302	if data.is_empty() {	×
303	return Err(StorageError::OutOfBounds);	×
304	}	×
305	let address = self.partition.start() + offset;	×
306	let write_range = ModRange::new(address, data.len());	×
307	if self.partition.contains_range(&write_range) {	×
308	// Erases all pages that have their first byte in the write range.
309	// Since we expect calls in order, we don't want to erase half-written pages.
310	for address in write_range.aligned_iter(self.page_size) {	×
311	erase_page(address, self.page_size)?;	×
312	}
313	write_slice(address, data)	×
314	} else {
315	Err(StorageError::OutOfBounds)	×
316	}
317	}	×
318
319	fn partition_address(&self) -> usize {
320	self.partition.start()
321	}
322
323	fn partition_length(&self) -> usize {
324	self.partition.length()
325	}
326
327	fn read_metadata(&self) -> StorageResult<&[u8]> {
328	Ok(unsafe {
329	core::slice::from_raw_parts(self.metadata.start() as *const u8, self.metadata.length())
330	})
331	}
332
333	fn write_metadata(&mut self, data: &[u8]) -> StorageResult<()> {	×
334	// If less data is passed in than is reserved, assume the rest is 0xFF.	×
335	if data.len() <= self.metadata.length() {	×
336	for address in self.metadata.aligned_iter(self.page_size) {	×
337	erase_page(address, self.page_size)?;	×
338	}
339	write_slice(self.metadata.start(), data)	×
340	} else {
341	Err(StorageError::OutOfBounds)	×
342	}
343	}	×
344	}

google / OpenSK / 2947286109

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous