fc_util: some refactoring

1. Move time related functions to a separate
   module.
2. Create a new module called rand and move rand
   related functionality like `xor_rng_u32` there.

Signed-off-by: Diana Popa <[email protected]>

Author: dianpopa

api_server/src/lib.rs

@@ -196,16 +196,17 @@ impl ApiServer {
         let listener = UnixListener::bind(path, &handle).map_err(Error::Io)?;
 
         if let Some(start_time) = start_time_us {
-            let delta_us = (fc_util::get_time(fc_util::ClockType::Monotonic) / 1000) - start_time;
+            let delta_us =
+                (fc_util::time::get_time(fc_util::time::ClockType::Monotonic) / 1000) - start_time;
             METRICS
                 .api_server
                 .process_startup_time_us
                 .add(delta_us as usize);
         }
 
         if let Some(cpu_start_time) = start_time_cpu_us {
-            let delta_us =
-                fc_util::get_time(fc_util::ClockType::ProcessCpu) / 1000 - cpu_start_time;
+            let delta_us = fc_util::time::get_time(fc_util::time::ClockType::ProcessCpu) / 1000
+                - cpu_start_time;
             METRICS
                 .api_server
                 .process_startup_time_cpu_us

devices/src/legacy/rtc_pl031.rs

@@ -77,7 +77,7 @@ impl RTC {
         RTC {
             // This is used only for duration measuring purposes.
             previous_now: Instant::now(),
-            tick_offset: fc_util::get_time(fc_util::ClockType::Real) as i64,
+            tick_offset: fc_util::time::get_time(fc_util::time::ClockType::Real) as i64,
             match_value: 0,
             load: 0,
             imsc: 0,
@@ -93,7 +93,7 @@ impl RTC {
     fn get_time(&self) -> u32 {
         let ts = (self.tick_offset as i128)
             + (Instant::now().duration_since(self.previous_now).as_nanos() as i128);
-        (ts / fc_util::NANOS_PER_SECOND as i128) as u32
+        (ts / fc_util::time::NANOS_PER_SECOND as i128) as u32
     }
 
     fn handle_write(&mut self, offset: u64, val: u32) -> Result<()> {
@@ -112,7 +112,7 @@ impl RTC {
                 self.previous_now = Instant::now();
                 // If the unwrap fails, then the internal value of the clock has been corrupted and
                 // we want to terminate the execution of the process.
-                self.tick_offset = fc_util::seconds_to_nanoseconds(i64::from(val)).unwrap();
+                self.tick_offset = fc_util::time::seconds_to_nanoseconds(i64::from(val)).unwrap();
             }
             RTCIMSC => {
                 self.imsc = val & 1;
@@ -207,8 +207,8 @@ mod tests {
         assert_eq!(v, 123);
 
         // Read and write to the LR register.
-        let v = fc_util::get_time(fc_util::ClockType::Real);
-        LittleEndian::write_u32(&mut data, (v / fc_util::NANOS_PER_SECOND) as u32);
+        let v = fc_util::time::get_time(fc_util::time::ClockType::Real);
+        LittleEndian::write_u32(&mut data, (v / fc_util::time::NANOS_PER_SECOND) as u32);
         let tick_offset_before = rtc.tick_offset;
         let previous_now_before = rtc.previous_now;
         rtc.write(RTCLR, &mut data);
@@ -217,7 +217,7 @@ mod tests {
 
         rtc.read(RTCLR, &mut data);
         let v_read = LittleEndian::read_u32(&data);
-        assert_eq!((v / fc_util::NANOS_PER_SECOND) as u32, v_read);
+        assert_eq!((v / fc_util::time::NANOS_PER_SECOND) as u32, v_read);
 
         // Read and write to IMSC register.
         // Test with non zero value.

dumbo/src/ns.rs

@@ -9,7 +9,7 @@ use std::net::Ipv4Addr;
 use std::num::NonZeroUsize;
 use std::result::Result;
 
-use fc_util::timestamp_cycles;
+use fc_util::time::timestamp_cycles;
 use logger::{Metric, METRICS};
 use net_util::MacAddr;
 use pdu::arp::{test_speculative_tpa, Error as ArpFrameError, EthIPv4ArpFrame, ETH_IPV4_FRAME_LEN};

dumbo/src/tcp/connection.rs

@@ -8,7 +8,7 @@
 
 use std::num::{NonZeroU16, NonZeroU64, NonZeroUsize, Wrapping};
 
-use fc_util::timestamp_cycles;
+use fc_util::rand::xor_rng_u32;
 use pdu::bytes::NetworkBytes;
 use pdu::tcp::{Error as TcpSegmentError, Flags as TcpFlags, TcpSegment};
 use pdu::Incomplete;
@@ -112,16 +112,6 @@ pub enum WriteNextError {
     TcpSegment(TcpSegmentError),
 }
 
-// This generates pseudo random u32 numbers based on the current timestamp. Only works for x86_64,
-// but can find something else if we ever need to support different architectures.
-fn xor_rng_u32() -> u32 {
-    let mut t: u32 = timestamp_cycles() as u32;
-    // Taken from https://en.wikipedia.org/wiki/Xorshift
-    t ^= t << 13;
-    t ^= t >> 17;
-    t ^ (t << 5)
-}
-
 /// Contains the state information and implements the logic for a minimalist TCP connection.
 ///
 /// One particular thing is that whenever the connection sends a `RST` segment, it will also stop
@@ -1784,11 +1774,4 @@ pub(crate) mod tests {
         // and we don't wait for our FIN to be ACKed.
         assert!(c.is_done());
     }
-
-    #[test]
-    fn test_xor_rng_u32() {
-        for _ in 0..1000 {
-            assert_ne!(xor_rng_u32(), xor_rng_u32());
-        }
-    }
 }

dumbo/src/tcp/endpoint.rs

@@ -13,7 +13,7 @@
 
 use std::num::{NonZeroU16, NonZeroU64, Wrapping};
 
-use fc_util::timestamp_cycles;
+use fc_util::time::timestamp_cycles;
 use logger::{Metric, METRICS};
 use mmds::parse_request;
 use pdu::bytes::NetworkBytes;

fc_util/src/lib.rs

@@ -3,211 +3,6 @@
 
 extern crate libc;
 
-use std::fmt;
-
+pub mod rand;
+pub mod time;
 pub mod validators;
-
-/// Constant to convert seconds to nanoseconds.
-pub const NANOS_PER_SECOND: u64 = 1_000_000_000;
-
-/// Wrapper over `libc::clockid_t` to specify Linux Kernel clock source.
-pub enum ClockType {
-    /// Equivalent to `libc::CLOCK_MONOTONIC`.
-    Monotonic,
-    /// Equivalent to `libc::CLOCK_REALTIME`.
-    Real,
-    /// Equivalent to `libc::CLOCK_PROCESS_CPUTIME_ID`.
-    ProcessCpu,
-    /// Equivalent to `libc::CLOCK_THREAD_CPUTIME_ID`.
-    ThreadCpu,
-}
-
-impl Into<libc::clockid_t> for ClockType {
-    fn into(self) -> libc::clockid_t {
-        match self {
-            ClockType::Monotonic => libc::CLOCK_MONOTONIC,
-            ClockType::Real => libc::CLOCK_REALTIME,
-            ClockType::ProcessCpu => libc::CLOCK_PROCESS_CPUTIME_ID,
-            ClockType::ThreadCpu => libc::CLOCK_THREAD_CPUTIME_ID,
-        }
-    }
-}
-
-/// Structure representing the date in local time with nanosecond precision.
-pub struct LocalTime {
-    /// Seconds in current minute.
-    sec: i32,
-    /// Minutes in current hour.
-    min: i32,
-    /// Hours in current day, 24H format.
-    hour: i32,
-    /// Days in current month.
-    mday: i32,
-    /// Months in current year.
-    mon: i32,
-    /// Years passed since 1900 BC.
-    year: i32,
-    /// Nanoseconds in current second.
-    nsec: i64,
-}
-
-impl LocalTime {
-    /// Returns the [LocalTime](struct.LocalTime.html) structure for the calling moment.
-    pub fn now() -> LocalTime {
-        let mut timespec = libc::timespec {
-            tv_sec: 0,
-            tv_nsec: 0,
-        };
-        let mut tm: libc::tm = libc::tm {
-            tm_sec: 0,
-            tm_min: 0,
-            tm_hour: 0,
-            tm_mday: 0,
-            tm_mon: 0,
-            tm_year: 0,
-            tm_wday: 0,
-            tm_yday: 0,
-            tm_isdst: 0,
-            tm_gmtoff: 0,
-            tm_zone: std::ptr::null(),
-        };
-
-        // Safe because the parameters are valid.
-        unsafe {
-            libc::clock_gettime(libc::CLOCK_REALTIME, &mut timespec);
-            libc::localtime_r(&timespec.tv_sec, &mut tm);
-        }
-
-        LocalTime {
-            sec: tm.tm_sec,
-            min: tm.tm_min,
-            hour: tm.tm_hour,
-            mday: tm.tm_mday,
-            mon: tm.tm_mon,
-            year: tm.tm_year,
-            nsec: timespec.tv_nsec,
-        }
-    }
-}
-
-impl fmt::Display for LocalTime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}-{:02}-{:02}T{:02}:{:02}:{:02}.{:09}",
-            self.year + 1900,
-            self.mon + 1,
-            self.mday,
-            self.hour,
-            self.min,
-            self.sec,
-            self.nsec
-        )
-    }
-}
-
-/// Returns a timestamp in nanoseconds from a monotonic clock.
-///
-/// Uses `_rdstc` on `x86_64` and [`get_time`](fn.get_time.html) on other architectures.
-pub fn timestamp_cycles() -> u64 {
-    #[cfg(target_arch = "x86_64")]
-    // Safe because there's nothing that can go wrong with this call.
-    unsafe {
-        std::arch::x86_64::_rdtsc() as u64
-    }
-    #[cfg(not(target_arch = "x86_64"))]
-    {
-        get_time(ClockType::Monotonic)
-    }
-}
-
-/// Returns a timestamp in nanoseconds based on the provided clock type.
-///
-/// # Arguments
-///
-/// * `clock_type` - Identifier of the Linux Kernel clock on which to act.
-pub fn get_time(clock_type: ClockType) -> u64 {
-    let mut time_struct = libc::timespec {
-        tv_sec: 0,
-        tv_nsec: 0,
-    };
-    // Safe because the parameters are valid.
-    unsafe { libc::clock_gettime(clock_type.into(), &mut time_struct) };
-    seconds_to_nanoseconds(time_struct.tv_sec).unwrap() as u64 + (time_struct.tv_nsec as u64)
-}
-
-/// Converts a timestamp in seconds to an equivalent one in nanoseconds.
-/// Returns `None` if the conversion overflows.
-///
-/// # Arguments
-///
-/// * `value` - Timestamp in seconds.
-pub fn seconds_to_nanoseconds(value: i64) -> Option<i64> {
-    value.checked_mul(NANOS_PER_SECOND as i64)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_time() {
-        for _ in 0..1000 {
-            assert!(get_time(ClockType::Monotonic) <= get_time(ClockType::Monotonic));
-        }
-
-        for _ in 0..1000 {
-            assert!(get_time(ClockType::ProcessCpu) <= get_time(ClockType::ProcessCpu));
-        }
-
-        for _ in 0..1000 {
-            assert!(get_time(ClockType::ThreadCpu) <= get_time(ClockType::ThreadCpu));
-        }
-
-        assert_ne!(get_time(ClockType::Real), 0);
-    }
-
-    #[test]
-    fn test_local_time_display() {
-        let local_time = LocalTime {
-            sec: 30,
-            min: 15,
-            hour: 10,
-            mday: 4,
-            mon: 6,
-            year: 119,
-            nsec: 123_456_789,
-        };
-        assert_eq!(
-            String::from("2019-07-04T10:15:30.123456789"),
-            local_time.to_string()
-        );
-
-        let local_time = LocalTime {
-            sec: 5,
-            min: 5,
-            hour: 5,
-            mday: 23,
-            mon: 7,
-            year: 44,
-            nsec: 123,
-        };
-        assert_eq!(
-            String::from("1944-08-23T05:05:05.000000123"),
-            local_time.to_string()
-        );
-
-        let local_time = LocalTime::now();
-        assert!(local_time.mon >= 0 && local_time.mon <= 11);
-    }
-
-    #[test]
-    fn test_seconds_to_nanoseconds() {
-        assert_eq!(
-            seconds_to_nanoseconds(100).unwrap() as u64,
-            100 * NANOS_PER_SECOND
-        );
-
-        assert!(seconds_to_nanoseconds(9_223_372_037).is_none());
-    }
-}

fc_util/src/rand.rs

@@ -0,0 +1,25 @@
+// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use super::time;
+
+/// Generates pseudo random u32 numbers based on the current timestamp.
+pub fn xor_rng_u32() -> u32 {
+    let mut t: u32 = time::timestamp_cycles() as u32;
+    // Taken from https://en.wikipedia.org/wiki/Xorshift.
+    t ^= t << 13;
+    t ^= t >> 17;
+    t ^ (t << 5)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_xor_rng_u32() {
+        for _ in 0..1000 {
+            assert_ne!(xor_rng_u32(), xor_rng_u32());
+        }
+    }
+}