Updated to handle time source issues on FreeBSD (#3547)

* Updated to handle time source issues on FreeBSD

* Fixed unresolved changes in LSCPU

* Made filter part of the testsuite class

* Moved tools into blocks

* Resolved mypy issues

* Updated flows to run linux first and resolved mypy errors

* Resolved dmesg blocking issue

Author: r-dailey

lisa/tools/lscpu.py

@@ -443,6 +443,17 @@ def calculate_vcpu_count(self, force_run: bool = False) -> int:
             * self.get_thread_per_core_count()
         )
 
+    def get_cpu_type(self, force_run: bool = False) -> CpuType:
+        result = self.run("-n hw.model", force_run=force_run).stdout.strip()
+        if "AMD" in result:
+            return CpuType.AMD
+        elif "Intel" in result:
+            return CpuType.Intel
+        elif "ARM" in result or "aarch64" in result:
+            return CpuType.ARM
+        else:
+            raise LisaException(f"Unknow cpu type. The output of lscpu is {result}")
+
 
 class VMWareESXiLscpu(Lscpu):
     #    CPU Threads: 208

microsoft/testsuites/core/timesync.py

@@ -1,3 +1,4 @@
+import re
 import time
 from copy import deepcopy
 from datetime import timedelta
@@ -21,7 +22,18 @@
     simple_requirement,
 )
 from lisa.operating_system import BSD, CpuArchitecture, Redhat, Suse, Windows
-from lisa.tools import Cat, Chrony, Dmesg, Hwclock, Ls, Lscpu, Ntp, Ntpstat, Service
+from lisa.tools import (
+    Cat,
+    Chrony,
+    Dmesg,
+    Hwclock,
+    Ls,
+    Lscpu,
+    Ntp,
+    Ntpstat,
+    Service,
+    Sysctl,
+)
 from lisa.tools.date import Date
 from lisa.tools.lscpu import CpuType
 from lisa.util import constants
@@ -74,6 +86,9 @@ class TimeSync(TestSuite):
     )
     current_clockevent = "/sys/devices/system/clockevents/clockevent0/current_device"
     unbind_clockevent = "/sys/devices/system/clockevents/clockevent0/unbind_device"
+    # Positive Example:
+    # Features=0x1c77b221<FPU,VME,DE,PSE,TSC,MSR,PAE,MCE,CX8,APIC,SEP,MTRR,PGE,MCA,CMOV,PAT,PSE36,CLFLUSH,MMX,FXSR,SSE,SSE2,HTT>
+    __freebsd_tsc_filter = re.compile(r"Features=.*<.*,TSC,.*>")
 
     @TestCaseMetadata(
         description="""
@@ -167,41 +182,70 @@ def verify_timesync_unbind_clocksource(self, node: Node, log: Logger) -> None:
                     "lis_hyperv_clocksource_tsc_page",
                     "hyperv_clocksource",
                     "tsc",
+                    "Hyper-V-TSC",
                 ],
                 CpuArchitecture.ARM64: [
                     "arch_sys_counter",
+                    "ARM MPCore Timecounter",
                 ],
             }
+            cat = node.tools[Cat]
             lscpu = node.tools[Lscpu]
             arch = lscpu.get_architecture()
             clocksource = clocksource_map.get(arch, None)
             if not clocksource:
                 raise UnsupportedCpuArchitectureException(arch)
-            cat = node.tools[Cat]
-            clock_source_result = cat.run(self.current_clocksource)
+            if not isinstance(node.os, BSD):
+                clock_source_result = cat.run(self.current_clocksource)
+            else:
+                sysctl = node.tools[Sysctl]
+                clock_source_result = sysctl.run(
+                    "-n kern.timecounter.hardware",
+                    force_run=True,
+                    sudo=True,
+                    expected_exit_code=0,
+                    expected_exit_code_failure_message="fail to get hardware value",
+                )
             assert_that([clock_source_result.stdout]).described_as(
-                f"Expected clocksource name is one of {clocksource},"
-                f" but actual it is {clock_source_result.stdout}."
+                f"Expected clocksource name is one of {clocksource}, "
+                f"but actually it is {clock_source_result.stdout}."
             ).is_subset_of(clocksource)
 
             # 2. Check CPU flag contains constant_tsc from /proc/cpuinfo.
+            dmesg = node.tools[Dmesg]
             if CpuArchitecture.X64 == arch:
-                cpu_info_result = cat.run("/proc/cpuinfo")
-                if CpuType.Intel == lscpu.get_cpu_type():
-                    expected_tsc_str = " constant_tsc "
-                elif CpuType.AMD == lscpu.get_cpu_type():
-                    expected_tsc_str = " tsc "
-                shown_up_times = cpu_info_result.stdout.count(expected_tsc_str)
-                assert_that(shown_up_times).described_as(
-                    f"Expected {expected_tsc_str} shown up times in cpu flags is"
-                    " equal to cpu count."
-                ).is_equal_to(lscpu.get_core_count())
+                if not isinstance(node.os, BSD):
+                    cpu_info_result = cat.run("/proc/cpuinfo")
+                    if CpuType.Intel == lscpu.get_cpu_type():
+                        expected_tsc_str = " constant_tsc "
+                    elif CpuType.AMD == lscpu.get_cpu_type():
+                        expected_tsc_str = " tsc "
+                    shown_up_times = cpu_info_result.stdout.count(expected_tsc_str)
+                    assert_that(shown_up_times).described_as(
+                        f"Expected {expected_tsc_str} shown up times in cpu flags is"
+                        f" equal to cpu count."
+                    ).is_equal_to(lscpu.get_core_count())
+                else:
+                    cpu_info_results = self.__freebsd_tsc_filter.findall(
+                        dmesg.get_output()
+                    )
+                    count_of_results = len(cpu_info_results)
+                    assert_that(count_of_results).described_as(
+                        "Expected TSC shown up times in cpu flags is"
+                        " equal to cpu count."
+                    ).is_equal_to(lscpu.get_core_count())
 
             # 3. Check clocksource name shown up in dmesg.
-            dmesg = node.tools[Dmesg]
-            assert_that(dmesg.get_output()).described_as(
-                f"Expected clocksource {clock_source_result.stdout} shown up in dmesg."
-            ).contains(f"clocksource {clock_source_result.stdout}")
+            if not isinstance(node.os, BSD):
+                assert_that(dmesg.get_output()).described_as(
+                    f"Expected clocksource {clock_source_result.stdout}"
+                    f" shown up in dmesg."
+                ).contains(f"clocksource {clock_source_result.stdout}")
+            else:
+                assert_that(dmesg.get_output()).described_as(
+                    f'Expected Timecounter "{clock_source_result.stdout}"'
+                    f" shown up in dmesg."
+                ).contains(f'Timecounter "{clock_source_result.stdout}"')
 
             # 4. Unbind current clock source if there are 2+ clock sources,
             # check current clock source can be switched to a different one.