Add DAWR Watchpoint for different data types

Signed-off-by: Sachin P Bappalige <sachinpb@linux.ibm.com>

Author: Sachin P Bappalige

perf/perf_datatype_profiling.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See LICENSE for more details.
+#
+# Copyright: 2025 IBM
+# Author: Tejas Manhas <Tejas.Manhas1@ibm.com>
+import re
+from avocado import Test
+from avocado.utils import distro, process, genio
+from avocado.utils.software_manager.manager import SoftwareManager
+
+
+class datatype_profiling(Test):
+    """
+    This is a test class for datatype profiling that checks datatype offset etc.
+    """
+
+    def setUp(self):
+        '''
+        Install the basic packages to support perf
+        '''
+        detected_distro = distro.detect()
+        if 'ppc64' not in detected_distro.arch:
+            self.cancel('This test is not supported on %s architecture'
+                        % detected_distro.arch)
+        if 'PowerNV' in genio.read_file('/proc/cpuinfo'):
+            self.cancel('This test is only supported on LPAR')
+        process.run("dmesg -C")
+        self.check_mem_event_availability()
+        self.check_dependencies()
+
+    def run_cmd(self, cmd):
+        """
+        run command on SUT as root
+        """
+
+        result = process.run(cmd, shell=True, ignore_status=True)
+        output = result.stdout_text + result.stderr_text
+        return output
+
+    def check_mem_event_availability(self):
+        try:
+            output = self.run_cmd(
+                "perf mem record -e list")
+        except Exception as e:
+            self.log.info(f"Command failed: {e}")
+            return False
+        if not re.search(r"ldlat-loads\s*:\s*available", output):
+            self.cancel("Required memory event 'ldlat-loads' not available")
+
+        if not re.search(r"ldlat-stores\s*:\s*available", output):
+            self.cancel("Required memory event 'ldlat-stores' not available")
+
+    def check_dependencies(self):
+        """
+        Check if required debug packages for current kernel are installed
+        and perf events are available.
+        """
+
+        detected_distro = distro.detect()
+        is_rhel = False
+        is_sles = False
+        if "rhel" in detected_distro.name.lower():
+            is_rhel = True
+        if "suse" in detected_distro.name.lower():
+            is_sles = True
+        # Define base package names (without versions)
+        base_packages = ["perf"]
+
+        # Add debuginfo names based on distro
+        if is_rhel:
+            base_packages += [
+                "kernel-tools-libs",
+                "kernel-tools",
+                "kernel-headers",
+                "kernel-devel",
+                "kernel",
+                "kernel-core",
+                "kernel-modules",
+                "kernel-modules-extra",
+                "kernel-modules-core",
+                "kernel-debuginfo",
+                "kernel-debug-debuginfo",
+                "kernel-debuginfo-common-ppc64le"
+            ]
+        elif is_sles:
+            base_packages += [
+                "kernel-default-debuginfo",
+                "kernel-debug-debuginfo",
+                "kernel-default-devel",
+                "kernel-devel",
+                "kernel-default"
+            ]
+        else:
+            self.cancel("Unsupported Linux distribution")
+
+        smm = SoftwareManager()
+        for package in base_packages:
+            if not smm.check_installed(package) and not smm.install(package):
+                self.cancel('%s is needed for the test to be run' % package)
+
+    def check_perf_report_headers(self, cmd):
+        """
+        Checks for expected headers in perf report output.
+        """
+        output = self.run_cmd(cmd)
+        expected_headers = ["Symbol", "Data Type", "Data Type Offset"]
+        for header in expected_headers:
+            if header not in output:
+                self.fail(
+                    f"Missing expected header '{header}' in perf report output")
+
+    def check_perf_annotate_headers(self, cmd, check_insn_stat=False):
+        """
+        Checks for expected headers in perf annotate output.
+        """
+        self.run_cmd(f"{cmd} > out")
+        output = self.run_cmd("cat out")
+
+        if check_insn_stat:
+            # First check for Name/opcode, Good, Bad headers
+            expected_insn_headers = ["Name/opcode", "Good", "Bad"]
+            for header in expected_insn_headers:
+                if header not in output:
+                    self.fail(
+                        f"Missing expected header '{header}' in perf annotate insn stat output")
+
+        # Now check for 'offset' and 'size' in each Annotate type block
+        sections = output.split("Annotate type:")
+        for section in sections[1:]:
+            if "offset" not in section or "size" not in section:
+                self.fail(
+                    "Missing 'offset' or 'size' header in perf annotate output")
+
+    def test_datatype_profiling(self):
+        """
+        Test to verify perf data type profiling feature.
+        Steps:
+        1. Verify perf report headers.
+        2. Verify perf annotate data type headers.
+        3. Verify perf annotate instruction stats headers.
+        Repeat above for:
+            a. perf mem record -a sleep 10
+            b. perf record -a -e mem-loads sleep 5
+            c. perf record -c 1 -e mem-stores sleep 5
+        """
+
+        record_cmds = [
+            "perf mem record -a -o /tmp/perf_output.data sleep 10",
+            "perf record -a -e mem-loads -o /tmp/perf_output.data sleep 5",
+            "perf record -c 1 -e mem-stores -o /tmp/perf_output.data sleep 5"
+        ]
+
+        for cmd in record_cmds:
+            self.run_cmd(cmd)
+
+            self.check_perf_report_headers(
+                "perf report -i /tmp/perf_output.data -s symbol,type,typeoff")
+            self.check_perf_annotate_headers(
+                "perf annotate -i /tmp/perf_output.data --data-type")
+            self.check_perf_annotate_headers(
+                "perf annotate -i /tmp/perf_output.data --data-type --insn-stat",
+                check_insn_stat=True)
+
+    def tearDown(self):
+        """
+        tear down function to clear dmesg and data files.
+        """
+        process.run("dmesg -T")
+        self.run_cmd("rm -rf /tmp/perf_output.data")
+        self.run_cmd("rm -rf out")

trace/dawr.py

@@ -52,11 +52,9 @@ def setUp(self):
             shutil.copyfile(self.get_data('dawr_v%d.c' % value),
                             os.path.join(self.teststmpdir,
                                          'dawr_v%d.c' % value))
-        for name in ['dawr_local.c', 'dawr_pointer.c', 'dawr_struct.c', 'dawr_array.c']:
-            shutil.copyfile(self.get_data(name),
-                            os.path.join(self.teststmpdir, name))
-        shutil.copyfile(self.get_data('Makefile'),
-                        os.path.join(self.teststmpdir, 'Makefile'))
+        for fname in ['boundary_check.c', 'dawr_local.c', 'dawr_pointer.c', 'dawr_struct.c', 'dawr_array.c', 'Makefile']:
+            shutil.copyfile(self.get_data(fname),
+                            os.path.join(self.teststmpdir, fname))
         build.make(self.teststmpdir)
         os.chdir(self.teststmpdir)
         self.output_file = "perf.data"
@@ -154,8 +152,9 @@ def test_read_dawr_v3_gdb(self):
                                                     'watchpoint %s: %s'
                                                     % (i, value)]))
         child.sendline('r')
-        return_value.append(child.expect_exact([pexpect.TIMEOUT,
-                                                'not enough available hardware']))
+        return_value.append(
+            child.expect_exact([pexpect.TIMEOUT,
+                               'not enough available hardware']))
         for i in return_value:
             if i == 0:
                 self.fail('Test case failed for 3 variables')
@@ -198,6 +197,22 @@ def test_read_dawr_array_perf(self):
             self.output_file, data[0])
         self.perf_cmd(perf_record)
 
+    def test_dawr_boundary_check(self):
+        """
+        Run dawr_boundary_check to check
+        unaligned 512-byte DAWR boundary condition
+        """
+        output = self.run_test('./boundary_check')
+        data = output.stdout.decode("utf-8")
+
+        expected_msg = "TEST Boundary check PASSED: unaligned_512bytes"
+        if expected_msg not in data:
+            self.fail(
+                f"TEST Boundary check FAILED: unaligned_512bytes.\n"
+                f"Output was:\n{data}")
+        else:
+            self.log.info(expected_msg)
+
     def tearDown(self):
         # Delete the temporary file
         if os.path.isfile("perf.data"):

trace/dawr.py.data/Makefile

@@ -1,9 +1,11 @@
-all : dawr_v1  dawr_v2 dawr_v3
+all : dawr_v1  dawr_v2 dawr_v3 boundary_check
 dawr_v1 : dawr_v1.c
 	gcc -g -o dawr_v1 dawr_v1.c
 dawr_v2 : dawr_v2.c
 	gcc -g -o dawr_v2 dawr_v2.c
 dawr_v3 : dawr_v3.c
 	gcc -g -o dawr_v3 dawr_v3.c
+boundary_check : boundary_check.c
+	gcc -g -o boundary_check boundary_check.c
 clean : 
-	rm dawr_v1 dawr_v2 dawr_v3
+	rm dawr_v1 dawr_v2 dawr_v3 boundary_check

trace/dawr.py.data/boundary_check.c

@@ -0,0 +1,87 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See LICENSE for more details.
+ *
+ * Copyright: 2025 IBM
+ * Author: SACHIN P B  <sachinpb@linux.ibm.com>
+*/
+
+#define _GNU_SOURCE
+#include <linux/perf_event.h>
+#include <linux/hw_breakpoint.h>
+#include <sys/ioctl.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/syscall.h>
+
+#define HW_BREAKPOINT_LEN_512 512
+
+static char c[1024];
+static void multi_dawr_workload(void)
+{
+    volatile char *ptr = c + 8;
+    ptr[0] = 0xAA;
+    ptr[511] = 0xBB;
+}
+
+static int perf_process_event_open(int bp_type, __u64 addr, int len)
+{
+    struct perf_event_attr attr;
+    memset(&attr, 0, sizeof(struct perf_event_attr));
+    attr.type = PERF_TYPE_BREAKPOINT;
+    attr.size = sizeof(struct perf_event_attr);
+    attr.config = 0;
+    attr.bp_type = bp_type;
+    attr.bp_addr = addr;
+    attr.bp_len = len;
+
+    return syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0);
+}
+
+int main()
+{
+    unsigned long long breaks = 0;
+    int fd;
+    __u64 addr = (__u64)&c + 8;
+    size_t res;
+
+    fd = perf_process_event_open(HW_BREAKPOINT_RW, addr, HW_BREAKPOINT_LEN_512);
+    if (fd < 0) {
+        perror("perf_process_event_open");
+        return 1;
+    }
+
+    ioctl(fd, PERF_EVENT_IOC_RESET, 0);
+    ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
+    multi_dawr_workload();
+    ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);
+
+    res = read(fd, &breaks, sizeof(breaks));
+    if (res != sizeof(unsigned long long)) {
+        perror("read failed");
+        close(fd);
+        return 1;
+    }
+
+    close(fd);
+
+    if (breaks != 2) {
+        printf("FAILED: unaligned_512bytes: %llu != 2\n", breaks);
+        return 1;
+    }
+
+    printf("TEST Boundary check PASSED: unaligned_512bytes\n");
+    return 0;
+}