examples/profile: add --sw-event option for software events

A new command line option (`--sw-event`) to address the ENOENT error
that occurs when hardware events are unavailable.

This can be useful when running the profile example in a virtual
machine.

Signed-off-by: fl <[email protected]>

Author: flearc

examples/c/profile.c

@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <getopt.h> 
 #include <unistd.h>
 #include <string.h>
 #include <fcntl.h>
@@ -133,13 +134,17 @@ static int event_handler(void *_ctx, void *data, size_t size)
 
 static void show_help(const char *progname)
 {
-	printf("Usage: %s [-f <frequency>] [-h]\n", progname);
+	printf("Usage: %s [-f <frequency>] [--sw-event] [-h]\n", progname);
+	printf("Options:\n");
+	printf("  -f <frequency>  Sampling frequency [default: 1]\n");
+	printf("  --sw-event      Use software event for triggering stack trace capture\n");
+	printf("  -h              Print help\n");
 }
 
 int main(int argc, char *const argv[])
 {
 	const char *online_cpus_file = "/sys/devices/system/cpu/online";
-	int freq = 1, pid = -1, cpu;
+	int freq = 1, sw_event = 0, pid = -1, cpu;
 	struct profile_bpf *skel = NULL;
 	struct perf_event_attr attr;
 	struct bpf_link **links = NULL;
@@ -149,13 +154,21 @@ int main(int argc, char *const argv[])
 	int argp, i, err = 0;
 	bool *online_mask = NULL;
 
-	while ((argp = getopt(argc, argv, "hf:")) != -1) {
+	static struct option long_options[] = {
+		{"sw-event", no_argument, 0, 's'},
+		{0, 0, 0, 0}
+	};
+
+	while ((argp = getopt_long(argc, argv, "hf:", long_options, NULL)) != -1) {
 		switch (argp) {
 		case 'f':
 			freq = atoi(optarg);
 			if (freq < 1)
 				freq = 1;
 			break;
+		case 's':
+			sw_event = 1;
+			break;
 
 		case 'h':
 		default:
@@ -206,9 +219,9 @@ int main(int argc, char *const argv[])
 	links = calloc(num_cpus, sizeof(struct bpf_link *));
 
 	memset(&attr, 0, sizeof(attr));
-	attr.type = PERF_TYPE_HARDWARE;
+	attr.type = sw_event ? PERF_TYPE_SOFTWARE : PERF_TYPE_HARDWARE;
 	attr.size = sizeof(attr);
-	attr.config = PERF_COUNT_HW_CPU_CYCLES;
+	attr.config = sw_event ? PERF_COUNT_SW_CPU_CLOCK : PERF_COUNT_HW_CPU_CYCLES;
 	attr.sample_freq = freq;
 	attr.freq = 1;
 
@@ -220,7 +233,13 @@ int main(int argc, char *const argv[])
 		/* Set up performance monitoring on a CPU/Core */
 		pefd = perf_event_open(&attr, pid, cpu, -1, PERF_FLAG_FD_CLOEXEC);
 		if (pefd < 0) {
-			fprintf(stderr, "Fail to set up performance monitor on a CPU/Core\n");
+			if (!sw_event && errno == ENOENT) {
+				fprintf(stderr,
+					"Fail to set up performance monitor on a CPU/Core.\n"
+					"Try running the profile example with the `--sw-event` option.\n");
+			} else {
+				fprintf(stderr, "Fail to set up performance monitor on a CPU/Core.\n");
+			}
 			err = -1;
 			goto cleanup;
 		}

examples/rust/profile/src/main.rs

@@ -43,7 +43,7 @@ struct stacktrace_event {
     ustack: [u64; MAX_STACK_DEPTH],
 }
 
-fn init_perf_monitor(freq: u64) -> Result<Vec<i32>, libbpf_rs::Error> {
+fn init_perf_monitor(freq: u64, sw_event: bool) -> Result<Vec<i32>, libbpf_rs::Error> {
     let nprocs = libbpf_rs::num_possible_cpus().unwrap();
     let pid = -1;
     let buf: Vec<u8> = vec![0; mem::size_of::<syscall::perf_event_attr>()];
@@ -52,17 +52,30 @@ fn init_perf_monitor(freq: u64) -> Result<Vec<i32>, libbpf_rs::Error> {
             buf.leak().as_mut_ptr() as *mut syscall::perf_event_attr
         )
     };
-    attr._type = syscall::PERF_TYPE_HARDWARE;
+    attr._type = if sw_event {
+        syscall::PERF_TYPE_SOFTWARE
+    } else {
+        syscall::PERF_TYPE_HARDWARE
+    };
     attr.size = mem::size_of::<syscall::perf_event_attr>() as u32;
-    attr.config = syscall::PERF_COUNT_HW_CPU_CYCLES;
+    attr.config = if sw_event {
+        syscall::PERF_COUNT_SW_CPU_CLOCK
+    } else {
+        syscall::PERF_COUNT_HW_CPU_CYCLES
+    };
     attr.sample.sample_freq = freq;
     attr.flags = 1 << 10; // freq = 1
     (0..nprocs)
         .map(|cpu| {
             let fd = syscall::perf_event_open(attr.as_ref(), pid, cpu as i32, -1, 0) as i32;
             if fd == -1 {
-                Err(libbpf_rs::Error::from(io::Error::last_os_error()))
-                    .context("failed to open perf event")
+                let mut error_context = "Failed to open perf event.";
+                let os_error = io::Error::last_os_error();
+                if !sw_event && os_error.kind() == io::ErrorKind::NotFound {
+                    error_context = "Failed to open perf event.\n\
+                                    Try running the profile example with the `--sw-event` option.";
+                }
+                Err(libbpf_rs::Error::from(os_error)).context(error_context)
             } else {
                 Ok(fd)
             }
@@ -224,6 +237,12 @@ struct Args {
     /// Increase verbosity (can be supplied multiple times).
     #[arg(short = 'v', long = "verbose", global = true, action = ArgAction::Count)]
     verbosity: u8,
+    /// Use software event for triggering stack trace capture.
+    ///
+    /// This can be useful for compatibility reasons if hardware event is not available
+    /// (which could happen in a virtual machine, for example).
+    #[arg(long = "sw-event")]
+    sw_event: bool,
 }
 
 fn main() -> Result<(), libbpf_rs::Error> {
@@ -251,7 +270,7 @@ fn main() -> Result<(), libbpf_rs::Error> {
     let open_skel = skel_builder.open(&mut open_object).unwrap();
     let skel = open_skel.load().unwrap();
 
-    let pefds = init_perf_monitor(freq)?;
+    let pefds = init_perf_monitor(freq, args.sw_event)?;
     let _links = attach_perf_event(&pefds, &skel.progs.profile);
 
     let mut builder = libbpf_rs::RingBufferBuilder::new();

examples/rust/profile/src/syscall.rs

@@ -54,7 +54,9 @@ pub struct perf_event_attr {
 }
 
 pub const PERF_TYPE_HARDWARE: u32 = 0;
+pub const PERF_TYPE_SOFTWARE: u32 = 1;
 pub const PERF_COUNT_HW_CPU_CYCLES: u64 = 0;
+pub const PERF_COUNT_SW_CPU_CLOCK: u64 = 0;
 
 extern "C" {
     fn syscall(number: libc::c_long, ...) -> libc::c_long;