Archives
/
rust-raspberrypi-OS-tutorials
mirror of https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Update some links

Browse Source
pull/71/head
Andre Richter 4 years ago
parent f46c742289
commit c78568bba1
No known key found for this signature in database
GPG Key ID: 2116C1AB102F615E
12 changed files with 61 additions and 50 deletions
Show Stats Download Patch File Download Diff File

11
05_safe_globals/README.md
Unescape Escape View File

@ -251,7 +251,7 @@ diff -uNr 04_zero_overhead_abstraction/src/main.rs 05_safe_globals/src/main.rs
diff -uNr 04_zero_overhead_abstraction/src/synchronization.rs 05_safe_globals/src/synchronization.rs diff -uNr 04_zero_overhead_abstraction/src/synchronization.rs 05_safe_globals/src/synchronization.rs
--- 04_zero_overhead_abstraction/src/synchronization.rs --- 04_zero_overhead_abstraction/src/synchronization.rs
+++ 05_safe_globals/src/synchronization.rs +++ 05_safe_globals/src/synchronization.rs
@@ -0,0 +1,91 @@ @@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0 +// SPDX-License-Identifier: MIT OR Apache-2.0
+// +//
+// Copyright (c) 2020 Andre Richter <andre.o.richter@gmail.com> +// Copyright (c) 2020 Andre Richter <andre.o.richter@gmail.com>
@ -270,10 +270,8 @@ diff -uNr 04_zero_overhead_abstraction/src/synchronization.rs 05_safe_globals/sr
+ /// Any object implementing this trait guarantees exclusive access to the data contained within + /// Any object implementing this trait guarantees exclusive access to the data contained within
+ /// the Mutex for the duration of the provided closure. + /// the Mutex for the duration of the provided closure.
+ /// + ///
+ /// The trait follows the [Rust embedded WG's + /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
+ /// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore + /// such as [deadlock prevention].
+ /// provides some goodness such as [deadlock
+ /// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
+ /// + ///
+ /// # Example + /// # Example
+ /// + ///
@ -281,6 +279,9 @@ diff -uNr 04_zero_overhead_abstraction/src/synchronization.rs 05_safe_globals/sr
+ /// best implemented **for a reference to a container struct**, and has a usage pattern that + /// best implemented **for a reference to a container struct**, and has a usage pattern that
+ /// might feel strange at first: + /// might feel strange at first:
+ /// + ///
+ /// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
+ /// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
+ ///
+ /// ``` + /// ```
+ /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); + /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
+ /// + ///

9
05_safe_globals/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
06_drivers_gpio_uart/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
07_uart_chainloader/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
08_timestamps/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
09_hw_debug_JTAG/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
10_privilege_level/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
11_virtual_memory/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
12_exceptions_part1_groundwork/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

9
13_integrated_testing/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

10
14_exceptions_part2_peripheral_IRQs/README.md
Unescape Escape View File

@ -2580,7 +2580,7 @@ diff -uNr 13_integrated_testing/src/state.rs 14_exceptions_part2_peripheral_IRQs
diff -uNr 13_integrated_testing/src/synchronization.rs 14_exceptions_part2_peripheral_IRQs/src/synchronization.rs diff -uNr 13_integrated_testing/src/synchronization.rs 14_exceptions_part2_peripheral_IRQs/src/synchronization.rs
--- 13_integrated_testing/src/synchronization.rs --- 13_integrated_testing/src/synchronization.rs
+++ 14_exceptions_part2_peripheral_IRQs/src/synchronization.rs +++ 14_exceptions_part2_peripheral_IRQs/src/synchronization.rs
@@ -42,6 +42,21 @@ @@ -43,6 +43,21 @@
/// Creates a critical section and grants temporary mutable access to the encapsulated data. /// Creates a critical section and grants temporary mutable access to the encapsulated data.
fn lock<R>(&mut self, f: impl FnOnce(&mut Self::Data) -> R) -> R; fn lock<R>(&mut self, f: impl FnOnce(&mut Self::Data) -> R) -> R;
} }
@ -2602,7 +2602,7 @@ diff -uNr 13_integrated_testing/src/synchronization.rs 14_exceptions_part2_perip
} }
/// A pseudo-lock for teaching purposes. /// A pseudo-lock for teaching purposes.
@@ -52,10 +67,17 @@ @@ -53,10 +68,17 @@
/// other cores to the contained data. This part is preserved for later lessons. /// other cores to the contained data. This part is preserved for later lessons.
/// ///
/// The lock will only be used as long as it is safe to do so, i.e. as long as the kernel is /// The lock will only be used as long as it is safe to do so, i.e. as long as the kernel is
@ -2622,7 +2622,7 @@ diff -uNr 13_integrated_testing/src/synchronization.rs 14_exceptions_part2_perip
data: UnsafeCell<T>, data: UnsafeCell<T>,
} }
@@ -63,10 +85,20 @@ @@ -64,10 +86,20 @@
// Public Code // Public Code
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -2646,7 +2646,7 @@ diff -uNr 13_integrated_testing/src/synchronization.rs 14_exceptions_part2_perip
pub const fn new(data: T) -> Self { pub const fn new(data: T) -> Self {
Self { Self {
data: UnsafeCell::new(data), data: UnsafeCell::new(data),
@@ -77,8 +109,9 @@ @@ -78,8 +110,9 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// OS Interface Code // OS Interface Code
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -2657,7 +2657,7 @@ diff -uNr 13_integrated_testing/src/synchronization.rs 14_exceptions_part2_perip
type Data = T; type Data = T;
fn lock<R>(&mut self, f: impl FnOnce(&mut Self::Data) -> R) -> R { fn lock<R>(&mut self, f: impl FnOnce(&mut Self::Data) -> R) -> R {
@@ -86,6 +119,32 @@ @@ -87,6 +120,32 @@
// mutable reference will ever only be given out once at a time. // mutable reference will ever only be given out once at a time.
let data = unsafe { &mut *self.data.get() }; let data = unsafe { &mut *self.data.get() };

9
14_exceptions_part2_peripheral_IRQs/src/synchronization.rs
Unescape Escape View File

@ -16,10 +16,8 @@ pub mod interface {
/// Any object implementing this trait guarantees exclusive access to the data contained within /// Any object implementing this trait guarantees exclusive access to the data contained within
/// the Mutex for the duration of the provided closure. /// the Mutex for the duration of the provided closure.
/// ///
/// The trait follows the [Rust embedded WG's /// The trait follows the [Rust embedded WG's proposal] and therefore provides some goodness
/// proposal](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md) and therefore /// such as [deadlock prevention].
/// provides some goodness such as [deadlock
/// prevention](https://github.com/korken89/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility).
/// ///
/// # Example /// # Example
/// ///
@ -27,6 +25,9 @@ pub mod interface {
/// best implemented **for a reference to a container struct**, and has a usage pattern that /// best implemented **for a reference to a container struct**, and has a usage pattern that
/// might feel strange at first: /// might feel strange at first:
/// ///
/// [Rust embedded WG's proposal]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md
/// [deadlock prevention]: https://github.com/rust-embedded/wg/blob/master/rfcs/0377-mutex-trait.md#design-decisions-and-compatibility
///
/// ``` /// ```
/// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0)); /// static MUT: Mutex<RefCell<i32>> = Mutex::new(RefCell::new(0));
/// ///

Write Preview
Loading…
Cancel
Save