Skip to content

Commit 2345214

Browse files
andre-richterandre-richter
committed
Various minor improvements
1 parent b22b0b1 commit 2345214

File tree

50 files changed

+407
-381
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

50 files changed

+407
-381
lines changed

‎07_timestamps/README.md

+11-11
Original file line numberDiff line numberDiff line change
@@ -302,6 +302,15 @@ diff -uNr 06_uart_chainloader/src/_arch/aarch64/time.rs 07_timestamps/src/_arch/
302302
+// Private Code
303303
+//--------------------------------------------------------------------------------------------------
304304
+
305+
+fn arch_timer_counter_frequency() -> NonZeroU32 {
306+
+ // Read volatile is needed here to prevent the compiler from optimizing
307+
+ // ARCH_TIMER_COUNTER_FREQUENCY away.
308+
+ //
309+
+ // This is safe, because all the safety requirements as stated in read_volatile()'s
310+
+ // documentation are fulfilled.
311+
+ unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
312+
+}
313+
+
305314
+impl GenericTimerCounterValue {
306315
+ pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
307316
+}
@@ -320,13 +329,7 @@ diff -uNr 06_uart_chainloader/src/_arch/aarch64/time.rs 07_timestamps/src/_arch/
320329
+ return Duration::ZERO;
321330
+ }
322331
+
323-
+ // Read volatile is needed here to prevent the compiler from optimizing
324-
+ // ARCH_TIMER_COUNTER_FREQUENCY away.
325-
+ //
326-
+ // This is safe, because all the safety requirements as stated in read_volatile()'s
327-
+ // documentation are fulfilled.
328-
+ let frequency: NonZeroU64 =
329-
+ unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
332+
+ let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
330333
+
331334
+ // Div<NonZeroU64> implementation for u64 cannot panic.
332335
+ let secs = counter_value.0.div(frequency);
@@ -361,10 +364,7 @@ diff -uNr 06_uart_chainloader/src/_arch/aarch64/time.rs 07_timestamps/src/_arch/
361364
+ return Err("Conversion error. Duration too big");
362365
+ }
363366
+
364-
+ // This is safe, because all the safety requirements as stated in read_volatile()'s
365-
+ // documentation are fulfilled.
366-
+ let frequency: u128 =
367-
+ unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
367+
+ let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
368368
+ let duration: u128 = duration.as_nanos();
369369
+
370370
+ // This is safe, because frequency can never be greater than u32::MAX, and

‎07_timestamps/src/_arch/aarch64/time.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ static ARCH_TIMER_COUNTER_FREQUENCY: NonZeroU32 = NonZeroU32::MIN;
4242
// Private Code
4343
//--------------------------------------------------------------------------------------------------
4444

45+
fn arch_timer_counter_frequency() -> NonZeroU32 {
46+
// Read volatile is needed here to prevent the compiler from optimizing
47+
// ARCH_TIMER_COUNTER_FREQUENCY away.
48+
//
49+
// This is safe, because all the safety requirements as stated in read_volatile()'s
50+
// documentation are fulfilled.
51+
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
52+
}
53+
4554
impl GenericTimerCounterValue {
4655
pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
4756
}
@@ -60,13 +69,7 @@ impl From<GenericTimerCounterValue> for Duration {
6069
return Duration::ZERO;
6170
}
6271

63-
// Read volatile is needed here to prevent the compiler from optimizing
64-
// ARCH_TIMER_COUNTER_FREQUENCY away.
65-
//
66-
// This is safe, because all the safety requirements as stated in read_volatile()'s
67-
// documentation are fulfilled.
68-
let frequency: NonZeroU64 =
69-
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
72+
let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
7073

7174
// Div<NonZeroU64> implementation for u64 cannot panic.
7275
let secs = counter_value.0.div(frequency);
@@ -101,10 +104,7 @@ impl TryFrom<Duration> for GenericTimerCounterValue {
101104
return Err("Conversion error. Duration too big");
102105
}
103106

104-
// This is safe, because all the safety requirements as stated in read_volatile()'s
105-
// documentation are fulfilled.
106-
let frequency: u128 =
107-
unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
107+
let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
108108
let duration: u128 = duration.as_nanos();
109109

110110
// This is safe, because frequency can never be greater than u32::MAX, and

‎08_hw_debug_JTAG/src/_arch/aarch64/time.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ static ARCH_TIMER_COUNTER_FREQUENCY: NonZeroU32 = NonZeroU32::MIN;
4242
// Private Code
4343
//--------------------------------------------------------------------------------------------------
4444

45+
fn arch_timer_counter_frequency() -> NonZeroU32 {
46+
// Read volatile is needed here to prevent the compiler from optimizing
47+
// ARCH_TIMER_COUNTER_FREQUENCY away.
48+
//
49+
// This is safe, because all the safety requirements as stated in read_volatile()'s
50+
// documentation are fulfilled.
51+
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
52+
}
53+
4554
impl GenericTimerCounterValue {
4655
pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
4756
}
@@ -60,13 +69,7 @@ impl From<GenericTimerCounterValue> for Duration {
6069
return Duration::ZERO;
6170
}
6271

63-
// Read volatile is needed here to prevent the compiler from optimizing
64-
// ARCH_TIMER_COUNTER_FREQUENCY away.
65-
//
66-
// This is safe, because all the safety requirements as stated in read_volatile()'s
67-
// documentation are fulfilled.
68-
let frequency: NonZeroU64 =
69-
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
72+
let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
7073

7174
// Div<NonZeroU64> implementation for u64 cannot panic.
7275
let secs = counter_value.0.div(frequency);
@@ -101,10 +104,7 @@ impl TryFrom<Duration> for GenericTimerCounterValue {
101104
return Err("Conversion error. Duration too big");
102105
}
103106

104-
// This is safe, because all the safety requirements as stated in read_volatile()'s
105-
// documentation are fulfilled.
106-
let frequency: u128 =
107-
unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
107+
let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
108108
let duration: u128 = duration.as_nanos();
109109

110110
// This is safe, because frequency can never be greater than u32::MAX, and

‎09_privilege_level/src/_arch/aarch64/time.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ static ARCH_TIMER_COUNTER_FREQUENCY: NonZeroU32 = NonZeroU32::MIN;
4242
// Private Code
4343
//--------------------------------------------------------------------------------------------------
4444

45+
fn arch_timer_counter_frequency() -> NonZeroU32 {
46+
// Read volatile is needed here to prevent the compiler from optimizing
47+
// ARCH_TIMER_COUNTER_FREQUENCY away.
48+
//
49+
// This is safe, because all the safety requirements as stated in read_volatile()'s
50+
// documentation are fulfilled.
51+
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
52+
}
53+
4554
impl GenericTimerCounterValue {
4655
pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
4756
}
@@ -60,13 +69,7 @@ impl From<GenericTimerCounterValue> for Duration {
6069
return Duration::ZERO;
6170
}
6271

63-
// Read volatile is needed here to prevent the compiler from optimizing
64-
// ARCH_TIMER_COUNTER_FREQUENCY away.
65-
//
66-
// This is safe, because all the safety requirements as stated in read_volatile()'s
67-
// documentation are fulfilled.
68-
let frequency: NonZeroU64 =
69-
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
72+
let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
7073

7174
// Div<NonZeroU64> implementation for u64 cannot panic.
7275
let secs = counter_value.0.div(frequency);
@@ -101,10 +104,7 @@ impl TryFrom<Duration> for GenericTimerCounterValue {
101104
return Err("Conversion error. Duration too big");
102105
}
103106

104-
// This is safe, because all the safety requirements as stated in read_volatile()'s
105-
// documentation are fulfilled.
106-
let frequency: u128 =
107-
unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
107+
let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
108108
let duration: u128 = duration.as_nanos();
109109

110110
// This is safe, because frequency can never be greater than u32::MAX, and

‎10_virtual_mem_part1_identity_mapping/src/_arch/aarch64/time.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ static ARCH_TIMER_COUNTER_FREQUENCY: NonZeroU32 = NonZeroU32::MIN;
4242
// Private Code
4343
//--------------------------------------------------------------------------------------------------
4444

45+
fn arch_timer_counter_frequency() -> NonZeroU32 {
46+
// Read volatile is needed here to prevent the compiler from optimizing
47+
// ARCH_TIMER_COUNTER_FREQUENCY away.
48+
//
49+
// This is safe, because all the safety requirements as stated in read_volatile()'s
50+
// documentation are fulfilled.
51+
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
52+
}
53+
4554
impl GenericTimerCounterValue {
4655
pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
4756
}
@@ -60,13 +69,7 @@ impl From<GenericTimerCounterValue> for Duration {
6069
return Duration::ZERO;
6170
}
6271

63-
// Read volatile is needed here to prevent the compiler from optimizing
64-
// ARCH_TIMER_COUNTER_FREQUENCY away.
65-
//
66-
// This is safe, because all the safety requirements as stated in read_volatile()'s
67-
// documentation are fulfilled.
68-
let frequency: NonZeroU64 =
69-
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
72+
let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
7073

7174
// Div<NonZeroU64> implementation for u64 cannot panic.
7275
let secs = counter_value.0.div(frequency);
@@ -101,10 +104,7 @@ impl TryFrom<Duration> for GenericTimerCounterValue {
101104
return Err("Conversion error. Duration too big");
102105
}
103106

104-
// This is safe, because all the safety requirements as stated in read_volatile()'s
105-
// documentation are fulfilled.
106-
let frequency: u128 =
107-
unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
107+
let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
108108
let duration: u128 = duration.as_nanos();
109109

110110
// This is safe, because frequency can never be greater than u32::MAX, and

‎11_exceptions_part1_groundwork/src/_arch/aarch64/time.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ static ARCH_TIMER_COUNTER_FREQUENCY: NonZeroU32 = NonZeroU32::MIN;
4242
// Private Code
4343
//--------------------------------------------------------------------------------------------------
4444

45+
fn arch_timer_counter_frequency() -> NonZeroU32 {
46+
// Read volatile is needed here to prevent the compiler from optimizing
47+
// ARCH_TIMER_COUNTER_FREQUENCY away.
48+
//
49+
// This is safe, because all the safety requirements as stated in read_volatile()'s
50+
// documentation are fulfilled.
51+
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
52+
}
53+
4554
impl GenericTimerCounterValue {
4655
pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
4756
}
@@ -60,13 +69,7 @@ impl From<GenericTimerCounterValue> for Duration {
6069
return Duration::ZERO;
6170
}
6271

63-
// Read volatile is needed here to prevent the compiler from optimizing
64-
// ARCH_TIMER_COUNTER_FREQUENCY away.
65-
//
66-
// This is safe, because all the safety requirements as stated in read_volatile()'s
67-
// documentation are fulfilled.
68-
let frequency: NonZeroU64 =
69-
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
72+
let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
7073

7174
// Div<NonZeroU64> implementation for u64 cannot panic.
7275
let secs = counter_value.0.div(frequency);
@@ -101,10 +104,7 @@ impl TryFrom<Duration> for GenericTimerCounterValue {
101104
return Err("Conversion error. Duration too big");
102105
}
103106

104-
// This is safe, because all the safety requirements as stated in read_volatile()'s
105-
// documentation are fulfilled.
106-
let frequency: u128 =
107-
unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
107+
let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
108108
let duration: u128 = duration.as_nanos();
109109

110110
// This is safe, because frequency can never be greater than u32::MAX, and

‎12_integrated_testing/kernel/src/_arch/aarch64/time.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ static ARCH_TIMER_COUNTER_FREQUENCY: NonZeroU32 = NonZeroU32::MIN;
4242
// Private Code
4343
//--------------------------------------------------------------------------------------------------
4444

45+
fn arch_timer_counter_frequency() -> NonZeroU32 {
46+
// Read volatile is needed here to prevent the compiler from optimizing
47+
// ARCH_TIMER_COUNTER_FREQUENCY away.
48+
//
49+
// This is safe, because all the safety requirements as stated in read_volatile()'s
50+
// documentation are fulfilled.
51+
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }
52+
}
53+
4554
impl GenericTimerCounterValue {
4655
pub const MAX: Self = GenericTimerCounterValue(u64::MAX);
4756
}
@@ -60,13 +69,7 @@ impl From<GenericTimerCounterValue> for Duration {
6069
return Duration::ZERO;
6170
}
6271

63-
// Read volatile is needed here to prevent the compiler from optimizing
64-
// ARCH_TIMER_COUNTER_FREQUENCY away.
65-
//
66-
// This is safe, because all the safety requirements as stated in read_volatile()'s
67-
// documentation are fulfilled.
68-
let frequency: NonZeroU64 =
69-
unsafe { core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY) }.into();
72+
let frequency: NonZeroU64 = arch_timer_counter_frequency().into();
7073

7174
// Div<NonZeroU64> implementation for u64 cannot panic.
7275
let secs = counter_value.0.div(frequency);
@@ -101,10 +104,7 @@ impl TryFrom<Duration> for GenericTimerCounterValue {
101104
return Err("Conversion error. Duration too big");
102105
}
103106

104-
// This is safe, because all the safety requirements as stated in read_volatile()'s
105-
// documentation are fulfilled.
106-
let frequency: u128 =
107-
unsafe { u32::from(core::ptr::read_volatile(&ARCH_TIMER_COUNTER_FREQUENCY)) as u128 };
107+
let frequency: u128 = u32::from(arch_timer_counter_frequency()) as u128;
108108
let duration: u128 = duration.as_nanos();
109109

110110
// This is safe, because frequency can never be greater than u32::MAX, and

0 commit comments

Comments
 (0)