Cannot access PMU counters on c8g.metal-24x instance

[ashtonsix]

Created c8g.metal-24x instance but not working:

Documentation says c8g.metal-24x has pmu access here:

aws-graviton-getting-started/perfrunbook/debug_hw_perf.md

Lines 17 to 35 in c5c4679

	## How to Collect PMU counters
	Not all instance sizes support PMU event collection. Generally
	instance sizes which have an entire dedicated socket have full access
	to all PMU events, and smaller instance sizes of the newer generations
	have a reduced set of events suitable for most profiling needs. For
	older generations smaller instance sizes may not support any PMU event
	collection. The table below captures these details:
	|Instance Family | Minimum Size for Full PMU Event Support | Basic Support at Smaller Sizes
	|------|------------|------|
	|*8g | 24xlarge | yes |
	|*7a | 24xlarge | yes |
	|*7g | 16xlarge | yes |
	|*7i | 24xlarge | yes |
	|*6a | 24xlarge | no |
	|*6g | 16xlarge | yes |
	|*6i | 16xlarge | no |
	|*5 | c5.9xlarge, *5.12xlarge | no

Do not see "pmu" in feature list for /proc/cpuinfo

$ cat /proc/cpuinfo
processor       : 95
BogoMIPS        : 2000.00
Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm jscvt fcma lrcpc dcpop sha3 asimddp sha512 sve asimdfhm dit uscat ilrcpc flagm ssbs sb paca pacg dcpodp sve2 sveaes svepmull svebitperm svesha3 flagm2 frint svei8mm svebf16 i8mm bf16 dgh rng bti
CPU implementer : 0x41
CPU architecture: 8
CPU variant     : 0x0
CPU part        : 0xd4f
CPU revision    : 1

Need to identify which method for zero-extending from 8-bit to 32-bit values is fastest on Neoverse V2 cores (like Graviton4).

My code fails with Illegal instruction with PMU_ENABLED (first run without PMU is dummy to make sure no crash without flag).

➜  /benchmark make clean && make && make run 
rm -rf build
cc -O3 -march=armv8.2-a -c src/main.cpp -o build/main.o
cc -O3 -march=armv8.2-a -c src/impl.S -o build/impl.o
cc -O3 -march=armv8.2-a -o build/benchmark build/main.o build/impl.o -static
./build/benchmark
Warming up option A...
Warming up option B...
Warming up option C...
Warming up option D...
Warming up option E...
Running 1000000 iterations per option...

Average Cycles Per Call:
Option A (st4):     0.00 cycles (theoretical: 6.0)
Option B (uxtl):    0.00 cycles (theoretical: 3.0)
Option C (zip):     0.00 cycles (theoretical: 1.5)
Option D (tbl):     0.00 cycles (theoretical: 2.0)
Option E (hybrid):  0.00 cycles (theoretical: 1.25)

Performance Ranking (best to worst):
1. Option A (st4): 0.00 cycles (0.00× theoretical)
2. Option B (uxtl): 0.00 cycles (0.00× theoretical)
3. Option C (zip): 0.00 cycles (0.00× theoretical)
4. Option D (tbl): 0.00 cycles (0.00× theoretical)
5. Option E (hybrid): 0.00 cycles (0.00× theoretical)
➜  /benchmark make clean && make pmu && make run
rm -rf build
cc -O3 -march=armv8.2-a -DPMU_ENABLED -c src/main.cpp -o build/main.o
cc -O3 -march=armv8.2-a -DPMU_ENABLED -c src/impl.S -o build/impl.o
cc -O3 -march=armv8.2-a -DPMU_ENABLED -o build/benchmark build/main.o build/impl.o -static
./build/benchmark
make: *** [Makefile:31: run] Illegal instruction (core dumped)

I access PMU like this:

// Initialize performance counter
static void init_perfcounter(void) {
  // Enable user-mode access to performance counters
  asm volatile("msr pmuserenr_el0, %0" : : "r"((uint64_t)1));
  // Enable performance counter
  asm volatile("msr pmcntenset_el0, %0" : : "r"((uint64_t)(1 << 31)));
  // Clear overflow flags
  asm volatile("msr pmovsclr_el0, %0" : : "r"((uint64_t)0xffffffff));
}

and like:

.section .rodata
.align 4
.Ltbl_zext:
    .byte 0, 16, 16, 16, 1, 16, 16, 16, 2, 16, 16, 16, 3, 16, 16, 16
    .byte 4, 16, 16, 16, 5, 16, 16, 16, 6, 16, 16, 16, 7, 16, 16, 16
    .byte 8, 16, 16, 16, 9, 16, 16, 16, 10, 16, 16, 16, 11, 16, 16, 16
    .byte 12, 16, 16, 16, 13, 16, 16, 16, 14, 16, 16, 16, 15, 16, 16, 16

.text

//-----------------------------------------------------------------------------
// Option D: Using tbl (2 cycles theoretical)
//-----------------------------------------------------------------------------
.align 4
_Z18benchmark_option_d12__Uint8x16_tPv:
    // Input bytes are already in q0

    // Load lookup tables into private registers (v20-v23)
    adrp x3, .Ltbl_zext
    add x3, x3, :lo12:.Ltbl_zext
    ld1 {v20.16b, v21.16b, v22.16b, v23.16b}, [x3]

    // DSB to ensure table load is complete before starting measurement
    dsb sy
    
    // Start cycle counter
#ifdef PMU_ENABLED
    mrs x2, pmccntr_el0
#endif
    
.rept 12
    // Use table lookups to zero-extend
    tbl v1.16b, {v0.16b}, v21.16b
    tbl v2.16b, {v0.16b}, v22.16b
    tbl v3.16b, {v0.16b}, v23.16b
    tbl v4.16b, {v0.16b}, v20.16b
    
    // Store results
    stp q4, q1, [x0]
    stp q2, q3, [x0, #32]
.endr
    
    // End cycle counter
#ifdef PMU_ENABLED
    mrs x0, pmccntr_el0
    sub x0, x0, x2
#else
    mov x0, #0
#endif
    ret

Please help. Thank you.

[ashtonsix]

Commenting to call for the attention of @geoffreyblake and @AGSaidi, because noticing some issues in this repository take one week to recieve response.

[ashtonsix]

I tried AI-generated script to enable PMU access, but every attempt ends with an "Illegal instruction" error. Reboot instance and run again does not change outcome.

setup.sh

#!/bin/bash

echo "Comprehensive PMU Access Enablement Script for ARM"
echo "Specifically for enabling 'mrs x2, pmccntr_el0' instruction"

# Must run as root
if [ "$(id -u)" -ne 0 ]; then
  echo "This script must be run as root. Try 'sudo $0'"
  exit 1
fi

# 1. Enable user-mode access to PMU via sysctl
echo "Setting kernel parameters for PMU access..."
echo 1 > /proc/sys/kernel/perf_event_paranoid
echo 0 > /proc/sys/kernel/kptr_restrict
echo "kernel.perf_event_paranoid=1" >> /etc/sysctl.conf
echo "kernel.kptr_restrict=0" >> /etc/sysctl.conf
sysctl -p

# 2. Enable PMU access via kernel module parameters
echo "Configuring kernel module parameters..."
if lsmod | grep -q "^arm_pmu"; then
  echo "ARM PMU module is loaded"
else
  echo "Loading ARM PMU module..."
  modprobe arm_pmu
fi

# Set module parameters if possible
if [ -d "/sys/module/arm_pmu/parameters" ]; then
  for param in /sys/module/arm_pmu/parameters/*; do
    if [ -f "$param" ]; then
      echo "Setting parameter $param to 1"
      echo 1 > "$param" 2>/dev/null || echo "Failed to set $param"
    fi
  done
fi

# 3. Enable CPU performance counters in PMUSERENR_EL0 register
echo "Attempting to enable user-mode PMU access via kernel module..."
cat > /tmp/enable_pmu.c << EOF
#include <linux/module.h>
#include <linux/kernel.h>
#include <asm/hwcap.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("PMU Access Script");
MODULE_DESCRIPTION("Enable PMU access for userspace");

static int __init enable_pmu_init(void) {
    u64 val;
    printk(KERN_INFO "Enabling PMU access for userspace\n");
    
    /* Read PMUSERENR_EL0 */
    asm volatile("mrs %0, pmuserenr_el0" : "=r" (val));
    printk(KERN_INFO "PMUSERENR_EL0 before: 0x%llx\n", val);
    
    /* Set all bits to enable full access */
    val |= 0xF;  /* Enable all bits */
    
    /* Write back PMUSERENR_EL0 */
    asm volatile("msr pmuserenr_el0, %0" : : "r" (val));
    
    /* Read again to verify */
    asm volatile("mrs %0, pmuserenr_el0" : "=r" (val));
    printk(KERN_INFO "PMUSERENR_EL0 after: 0x%llx\n", val);
    
    /* Now enable the PMU counters */
    asm volatile("mrs %0, pmcr_el0" : "=r" (val));
    printk(KERN_INFO "PMCR_EL0 before: 0x%llx\n", val);
    
    /* Enable all counters */
    val |= 1;  /* Set the enable bit */
    
    /* Write back PMCR_EL0 */
    asm volatile("msr pmcr_el0, %0" : : "r" (val));
    
    return 0;
}

static void __exit enable_pmu_exit(void) {
    printk(KERN_INFO "PMU access module unloaded\n");
}

module_init(enable_pmu_init);
module_exit(enable_pmu_exit);
EOF

echo "Compiling and installing kernel module..."
cd /tmp
apt-get update
apt-get install -y build-essential linux-headers-$(uname -r)
make -C /lib/modules/$(uname -r)/build M=/tmp modules
insmod /tmp/enable_pmu.ko

# 4. Directly enable via /dev/cpu interface if available
echo "Checking for /dev/cpu interface..."
if [ -d "/dev/cpu" ]; then
  echo "Setting permissions for /dev/cpu..."
  chmod -R a+rw /dev/cpu
else
  echo "/dev/cpu interface not available"
fi

# 5. Create a test program to check if PMU access is enabled
echo "Creating test program for 'mrs x2, pmccntr_el0' instruction..."
cat > /tmp/test_pmu.S << EOF
.global _start
_start:
    // Enable user-mode access to PMU counters if we're in privileged mode
    mrs x0, CurrentEL
    cmp x0, #0
    beq skip_enable  // If already in EL0, skip

    // If we're in EL1 or higher, enable user-mode access
    mov x0, #1
    msr pmuserenr_el0, x0

skip_enable:
    // Enable the PMU
    mrs x0, pmcr_el0
    orr x0, x0, #1
    msr pmcr_el0, x0
    
    // Enable the cycle counter specifically
    mov x0, #0x80000000
    msr pmcntenset_el0, x0
    
    // Try to read the cycle counter
    mrs x2, pmccntr_el0
    
    // Exit with success
    mov x0, #0
    mov x8, #93  // exit syscall
    svc #0
EOF

echo "Compiling test program..."
apt-get install -y gcc
gcc -nostdlib /tmp/test_pmu.S -o /tmp/test_pmu

echo "Setting executable permissions..."
chmod +x /tmp/test_pmu

# 6. If we have hwcap utility, check for PMU capability
if command -v getcap >/dev/null 2>&1; then
  echo "Setting capabilities for test program..."
  setcap cap_sys_admin+ep /tmp/test_pmu
fi

# 7. Try to directly enable PMU access via sysfs if available
echo "Checking for PMU controls in sysfs..."
if [ -d "/sys/devices/system/cpu/cpu0/cpuidle" ]; then
  echo "Setting CPU idle states to potentially enable PMU access..."
  for state in /sys/devices/system/cpu/cpu*/cpuidle/state*/disable; do
    if [ -f "$state" ]; then
      echo 1 > "$state" 2>/dev/null || echo "Failed to set $state"
    fi
  done
fi

# 8. Check for perf_event_open availability
echo "Checking perf_event_open system call..."
cat > /tmp/enable_pmu_perf.c << EOF
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <linux/perf_event.h>
#include <asm/unistd.h>

static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
                           int cpu, int group_fd, unsigned long flags) {
    return syscall(__NR_perf_event_open, hw_event, pid, cpu, group_fd, flags);
}

int main() {
    struct perf_event_attr pe;
    int fd;
    
    memset(&pe, 0, sizeof(pe));
    pe.type = PERF_TYPE_HARDWARE;
    pe.size = sizeof(pe);
    pe.config = PERF_COUNT_HW_CPU_CYCLES;
    pe.disabled = 1;
    pe.exclude_kernel = 1;
    pe.exclude_hv = 1;
    
    fd = perf_event_open(&pe, 0, -1, -1, 0);
    if (fd == -1) {
        perror("perf_event_open");
        return 1;
    }
    
    ioctl(fd, PERF_EVENT_IOC_RESET, 0);
    ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
    
    printf("Successfully opened perf event for CPU cycles\n");
    
    close(fd);
    return 0;
}
EOF

echo "Compiling and running perf_event_open test..."
gcc /tmp/enable_pmu_perf.c -o /tmp/enable_pmu_perf
/tmp/enable_pmu_perf

# 9. Create a C program that executes the instruction using inline assembly
echo "Creating C program with inline assembly..."
cat > /tmp/test_pmu_inline.c << EOF
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    uint64_t cycles;
    
    printf("Attempting to read PMU cycle counter with mrs x2, pmccntr_el0...\n");
    
    /* Try to enable user-mode access to PMU */
    __asm__ __volatile__("msr pmuserenr_el0, %0" : : "r" (0xFUL));
    
    /* Enable the PMU */
    uint64_t pmcr;
    __asm__ __volatile__("mrs %0, pmcr_el0" : "=r" (pmcr));
    __asm__ __volatile__("msr pmcr_el0, %0" : : "r" (pmcr | 0x1UL));
    
    /* Enable the cycle counter */
    __asm__ __volatile__("msr pmcntenset_el0, %0" : : "r" (0x80000000UL));
    
    /* Read the cycle counter into x2 as requested */
    __asm__ __volatile__("mrs x2, pmccntr_el0");
    
    /* Copy from x2 to our cycles variable */
    __asm__ __volatile__("mov %0, x2" : "=r" (cycles));
    
    printf("Successfully read cycle counter: %lu\n", cycles);
    return 0;
}
EOF

echo "Compiling and running C program with inline assembly..."
gcc /tmp/test_pmu_inline.c -o /tmp/test_pmu_inline
chmod +x /tmp/test_pmu_inline
echo "Running test_pmu_inline:"
/tmp/test_pmu_inline

# 10. Try setting Security Extensions
echo "Configuring Security Extensions..."
cat > /tmp/disable_traps.c << EOF
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    uint64_t mdcr_el2 = 0;
    
    printf("Attempting to disable PMU access traps...\n");
    
    /* Try to read and modify MDCR_EL2 if possible */
    __asm__ __volatile__(
        "mrs %0, mdcr_el2\n"
        : "=r" (mdcr_el2)
        :
        : "memory"
    );
    
    /* Clear TPM bit (bit 6) to disable trapping of Performance Monitor accesses */
    mdcr_el2 &= ~(1UL << 6);
    
    /* Write back MDCR_EL2 */
    __asm__ __volatile__(
        "msr mdcr_el2, %0\n"
        :
        : "r" (mdcr_el2)
        : "memory"
    );
    
    printf("Modified MDCR_EL2 to disable PMU access traps\n");
    return 0;
}
EOF

echo "Compiling and running security extension configuration..."
gcc /tmp/disable_traps.c -o /tmp/disable_traps
chmod +x /tmp/disable_traps
echo "Running disable_traps (may fail if not in EL2, which is expected):"
/tmp/disable_traps || echo "Not running in EL2, skipping MDCR_EL2 configuration"

# 11. Create a direct shellcode executor for the PMU access
echo "Creating shellcode PMU access tester..."
cat > /tmp/shellcode_pmu.c << EOF
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/mman.h>
#include <string.h>

int main() {
    // This shellcode enables PMU access and executes the mrs x2, pmccntr_el0 instruction
    unsigned char shellcode[] = {
        0x40, 0x00, 0x38, 0xd5,  // mrs x0, ID_AA64PFR0_EL1 (check if PMU is present)
        0x00, 0x40, 0x00, 0x93,  // asr x0, x0, #16
        0x1f, 0x0c, 0x00, 0x71,  // cmp w0, #3
        0xa0, 0x00, 0x00, 0x54,  // b.eq has_pmu
        0x20, 0x00, 0x80, 0xd2,  // mov x0, #1
        0xe0, 0x03, 0x00, 0xaa,  // mov x0, x0
        0x01, 0x00, 0x00, 0x14,  // b exit
        // has_pmu:
        0x0f, 0x10, 0x18, 0xd5,  // msr PMUSERENR_EL0, xzr
        0x01, 0x00, 0x80, 0xd2,  // mov x1, #0
        0x01, 0x10, 0x18, 0xd5,  // msr PMUSERENR_EL0, x1
        0x00, 0x10, 0x38, 0xd5,  // mrs x0, PMCR_EL0
        0x20, 0x00, 0x00, 0xb2,  // orr x0, x1, #1
        0x00, 0x10, 0x18, 0xd5,  // msr PMCR_EL0, x0
        0x00, 0xe0, 0x9f, 0xd2,  // mov x0, #0x8000000
        0x00, 0xe0, 0x18, 0xd5,  // msr PMCNTENSET_EL0, x0
        0x02, 0xec, 0x3b, 0xd5,  // mrs x2, PMCCNTR_EL0 - THE CRITICAL INSTRUCTION
        0xe0, 0x03, 0x02, 0xaa,  // mov x0, x2
        // exit:
        0xc0, 0x03, 0x5f, 0xd6   // ret
    };
    
    void *exec = mmap(0, sizeof(shellcode), PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    
    if (exec == MAP_FAILED) {
        perror("mmap");
        return 1;
    }
    
    memcpy(exec, shellcode, sizeof(shellcode));
    
    printf("Executing shellcode with mrs x2, pmccntr_el0 instruction...\n");
    uint64_t (*func)(void) = (uint64_t(*)(void))exec;
    uint64_t result = func();
    
    if (result == 1) {
        printf("PMU not available on this processor\n");
    } else {
        printf("Cycle counter value: %lu\n", result);
    }
    
    munmap(exec, sizeof(shellcode));
    return 0;
}
EOF

echo "Compiling and running shellcode PMU access tester..."
gcc /tmp/shellcode_pmu.c -o /tmp/shellcode_pmu
chmod +x /tmp/shellcode_pmu
echo "Running shellcode_pmu:"
/tmp/shellcode_pmu

# 12. Create a reusable shell script for future use
echo "Creating a reusable shell script..."
cat > /usr/local/bin/enable_pmu.sh << EOF
#!/bin/bash
echo "Enabling PMU access and testing 'mrs x2, pmccntr_el0' instruction"

# Set kernel parameters
echo 1 > /proc/sys/kernel/perf_event_paranoid 2>/dev/null || true
echo 0 > /proc/sys/kernel/kptr_restrict 2>/dev/null || true

# Load ARM PMU module if not loaded
if ! lsmod | grep -q "^arm_pmu"; then
  modprobe arm_pmu 2>/dev/null || true
fi

# Compile and run the test program
cat > /tmp/pmu_test.c << 'EOC'
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/mman.h>
#include <string.h>

int main() {
    printf("Enabling PMU access and testing mrs x2, pmccntr_el0...\n");
    
    /* Try all possible ways to enable user-mode PMU access */
    
    /* 1. Try to enable via PMUSERENR_EL0 */
    __asm__ __volatile__("msr pmuserenr_el0, %0" :: "r" (0xFUL));
    
    /* 2. Enable the PMU */
    uint64_t pmcr;
    __asm__ __volatile__("mrs %0, pmcr_el0" : "=r" (pmcr));
    __asm__ __volatile__("msr pmcr_el0, %0" :: "r" (pmcr | 0x1UL));
    
    /* 3. Enable the cycle counter */
    __asm__ __volatile__("msr pmcntenset_el0, %0" :: "r" (0x80000000UL));
    
    /* 4. Try direct execution of mrs x2, pmccntr_el0 */
    uint64_t cycles = 0;
    
    /* THE CRITICAL INSTRUCTION IS HERE */
    __asm__ __volatile__(
        "mrs x2, pmccntr_el0\n"
        "mov %0, x2"
        : "=r" (cycles)
    );
    
    printf("Cycle counter value: %lu\n", cycles);
    return 0;
}
EOC

gcc -O2 /tmp/pmu_test.c -o /tmp/pmu_test 2>/dev/null
if [ $? -ne 0 ]; then
    echo "Failed to compile PMU test program" >&2
    exit 1
fi

chmod +x /tmp/pmu_test
/tmp/pmu_test
EOF

chmod +x /usr/local/bin/enable_pmu.sh

# Try with all possible versions of Linux kernel modules
echo "Attempting to load all possible PMU modules..."
modprobe arm_pmu 2>/dev/null || true
modprobe armv8_pmuv3 2>/dev/null || true
modprobe armv8_pmu 2>/dev/null || true
modprobe pmuv3 2>/dev/null || true

# Finally, run the test to validate PMU access
echo -e "\n===== FINAL TEST FOR PMU ACCESS =====\n"
echo "Running compiled test program..."
/tmp/test_pmu_inline

echo -e "\n===== PMU ACCESS SCRIPT COMPLETED =====\n"
echo "If you're still experiencing 'Illegal instruction' errors, run the helper script:"
echo "  sudo /usr/local/bin/enable_pmu.sh"
echo "You may need to reboot after applying these changes."

stdout

ubuntu@ip-172-31-18-13:~$ sudo bash setup.sh 
Comprehensive PMU Access Enablement Script for ARM
Specifically for enabling 'mrs x2, pmccntr_el0' instruction
Setting kernel parameters for PMU access...
kernel.perf_event_paranoid = 0
kernel.perf_event_paranoid = 0
kernel.perf_event_paranoid = 0
kernel.perf_event_paranoid = 1
kernel.kptr_restrict = 0
kernel.perf_event_paranoid = 1
kernel.kptr_restrict = 0
kernel.perf_event_paranoid = 1
kernel.kptr_restrict = 0
Configuring kernel module parameters...
Loading ARM PMU module...
modprobe: FATAL: Module arm_pmu not found in directory /lib/modules/6.8.0-1021-aws
Attempting to enable user-mode PMU access via kernel module...
Compiling and installing kernel module...
Hit:1 http://eu-west-1.ec2.ports.ubuntu.com/ubuntu-ports noble InRelease
Hit:2 http://eu-west-1.ec2.ports.ubuntu.com/ubuntu-ports noble-updates InRelease                       
Hit:3 http://eu-west-1.ec2.ports.ubuntu.com/ubuntu-ports noble-backports InRelease                     
Hit:5 http://ports.ubuntu.com/ubuntu-ports noble-security InRelease                                    
Hit:4 https://apt.llvm.org/noble llvm-toolchain-noble-19 InRelease   
Hit:6 https://download.docker.com/linux/ubuntu noble InRelease       
Reading package lists... Done
W: http://apt.llvm.org/noble/dists/llvm-toolchain-noble-19/InRelease: Key is stored in legacy trusted.gpg keyring (/etc/apt/trusted.gpg), see the DEPRECATION section in apt-key(8) for details.
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
build-essential is already the newest version (12.10ubuntu1).
linux-headers-6.8.0-1021-aws is already the newest version (6.8.0-1021.23).
0 upgraded, 0 newly installed, 0 to remove and 127 not upgraded.
make: Entering directory '/usr/src/linux-headers-6.8.0-1021-aws'
warning: the compiler differs from the one used to build the kernel
  The kernel was built by: aarch64-linux-gnu-gcc-13 (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0
  You are using:           gcc-13 (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0
scripts/Makefile.build:41: /tmp/Makefile: No such file or directory
make[2]: *** No rule to make target '/tmp/Makefile'.  Stop.
make[1]: *** [/usr/src/linux-headers-6.8.0-1021-aws/Makefile:1925: /tmp] Error 2
make: *** [Makefile:240: __sub-make] Error 2
make: Leaving directory '/usr/src/linux-headers-6.8.0-1021-aws'
insmod: ERROR: could not load module /tmp/enable_pmu.ko: No such file or directory
Checking for /dev/cpu interface...
/dev/cpu interface not available
Creating test program for 'mrs x2, pmccntr_el0' instruction...
Compiling test program...
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
gcc is already the newest version (4:13.2.0-7ubuntu1).
0 upgraded, 0 newly installed, 0 to remove and 127 not upgraded.
Setting executable permissions...
Setting capabilities for test program...
Checking for PMU controls in sysfs...
Checking perf_event_open system call...
Compiling and running perf_event_open test...
Successfully opened perf event for CPU cycles
Creating C program with inline assembly...
Compiling and running C program with inline assembly...
Running test_pmu_inline:
Attempting to read PMU cycle counter with mrs x2, pmccntr_el0...
setup2.sh: line 248:  3435 Illegal instruction     (core dumped) /tmp/test_pmu_inline
Configuring Security Extensions...
Compiling and running security extension configuration...
Running disable_traps (may fail if not in EL2, which is expected):
Attempting to disable PMU access traps...
setup2.sh: line 290:  3444 Illegal instruction     (core dumped) /tmp/disable_traps
Not running in EL2, skipping MDCR_EL2 configuration
Creating shellcode PMU access tester...
Compiling and running shellcode PMU access tester...
Running shellcode_pmu:
Executing shellcode with mrs x2, pmccntr_el0 instruction...
setup2.sh: line 355:  3453 Illegal instruction     (core dumped) /tmp/shellcode_pmu
Creating a reusable shell script...
Attempting to load all possible PMU modules...

===== FINAL TEST FOR PMU ACCESS =====

Running compiled test program...
Attempting to read PMU cycle counter with mrs x2, pmccntr_el0...
setup2.sh: line 433:  3461 Illegal instruction     (core dumped) /tmp/test_pmu_inline

===== PMU ACCESS SCRIPT COMPLETED =====

If you're still experiencing 'Illegal instruction' errors, run the helper script:
  sudo /usr/local/bin/enable_pmu.sh
You may need to reboot after applying these changes.

[geoffreyblake]

Should we expect an AI generated script to be 100% accurate? I haven't had a chance to try @ashtonsix , did this work on C7g.metal and it isn't on C8g?