Refactor tracepoint handling in eBPF code generation, switch to regular tracepoint.

Author: congwang-mk

src/ebpf_c_codegen.ml

@@ -3347,18 +3347,11 @@ let generate_c_function ctx ir_func =
     | Some Ast.StructOps -> sprintf "SEC(\"struct_ops/%s\")" ir_func.func_name  (* struct_ops functions use their name in the section *)
     | Some Ast.Kprobe when ir_func.is_main -> "SEC(\"kprobe\")"  (* Always use kprobe section for kprobe functions *)
     | Some Ast.Tracepoint when ir_func.is_main -> 
-        (* For tracepoint functions, generate specific SEC based on function name *)
+        (* For tracepoint functions, generate specific SEC based on target *)
         (match ir_func.func_target with
          | Some target -> 
-             (* If we have the target, convert KernelScript format to raw tracepoint format *)
-             if String.contains target '/' then
-               (* For raw tracepoints, extract just the event name (part after slash) *)
-               let parts = String.split_on_char '/' target in
-               (match parts with
-                | [_category; event] -> sprintf "SEC(\"raw_tracepoint/%s\")" event
-                | _ -> sprintf "SEC(\"raw_tracepoint/%s\")" target)
-             else
-               sprintf "SEC(\"raw_tracepoint/%s\")" target
+             (* Convert KernelScript "category/event" format to regular tracepoint SEC format *)
+             sprintf "SEC(\"tracepoint/%s\")" target
          | None ->
              (* This should not happen now that we properly pass targets through *)
              failwith "Tracepoint function is missing target information")

src/userspace_codegen.ml

@@ -3297,15 +3297,25 @@ static int add_attachment(int prog_fd, const char *target, uint32_t flags,
             
             return 0;
         }
-        case BPF_PROG_TYPE_RAW_TRACEPOINT: {
-            // For raw tracepoint programs, target should be just the event name (e.g., "sched_switch")
-            // Extract event name from "category:event" format if needed
+        case BPF_PROG_TYPE_TRACEPOINT: {
+            // For regular tracepoint programs, target should be in "category:event" format (e.g., "sched:sched_switch")
+            // Split into category and event name for attachment
             
-            char *event_name = target;
-            char *colon_pos = strchr(target, ':');
+            // Make a copy of target since we need to modify it
+            char target_copy[256];
+            strncpy(target_copy, target, sizeof(target_copy) - 1);
+            target_copy[sizeof(target_copy) - 1] = '\0';
+            
+            char *category = target_copy;
+            char *event_name = NULL;
+            char *colon_pos = strchr(target_copy, ':');
             if (colon_pos) {
-                // Skip past the colon to get just the event name
+                // Null-terminate category and get event name
+                *colon_pos = '\0';
                 event_name = colon_pos + 1;
+            } else {
+                fprintf(stderr, "Invalid tracepoint target format: '%s'. Expected 'category:event'\n", target);
+                return -1;
             }
             
             // Get the bpf_program struct from the object and file descriptor
@@ -3314,7 +3324,7 @@ static int add_attachment(int prog_fd, const char *target, uint32_t flags,
             // Find the program object corresponding to this fd
             // We need to get the program from the skeleton object
             if (!obj) {
-                fprintf(stderr, "eBPF skeleton not loaded for raw tracepoint attachment\n");
+                fprintf(stderr, "eBPF skeleton not loaded for tracepoint attachment\n");
                 return -1;
             }
 
@@ -3329,21 +3339,21 @@ static int add_attachment(int prog_fd, const char *target, uint32_t flags,
                 return -1;
             }
 
-            // Use libbpf's high-level raw tracepoint attachment API with just the event name
-            struct bpf_link *link = bpf_program__attach_raw_tracepoint(prog, event_name);
+            // Use libbpf's high-level tracepoint attachment API with category and event name
+            struct bpf_link *link = bpf_program__attach_tracepoint(prog, category, event_name);
             if (!link) {
-                fprintf(stderr, "Failed to attach raw tracepoint to '%s': %s\n", event_name, strerror(errno));
+                fprintf(stderr, "Failed to attach tracepoint to '%s:%s': %s\n", category, event_name, strerror(errno));
                 return -1;
             }
             
-            // Store raw tracepoint attachment for later cleanup
-            if (add_attachment(prog_fd, target, flags, link, 0, BPF_PROG_TYPE_RAW_TRACEPOINT) != 0) {
+            // Store tracepoint attachment for later cleanup
+            if (add_attachment(prog_fd, target, flags, link, 0, BPF_PROG_TYPE_TRACEPOINT) != 0) {
                 // If storage fails, destroy link and return error
                 bpf_link__destroy(link);
                 return -1;
             }
             
-            printf("Raw tracepoint attached to: %s\n", event_name);
+            printf("Tracepoint attached to: %s:%s\n", category, event_name);
             
             return 0;
         }
@@ -3388,12 +3398,12 @@ static int add_attachment(int prog_fd, const char *target, uint32_t flags,
             }
             break;
         }
-        case BPF_PROG_TYPE_RAW_TRACEPOINT: {
+        case BPF_PROG_TYPE_TRACEPOINT: {
             if (entry->link) {
                 bpf_link__destroy(entry->link);
-                printf("Raw tracepoint detached from: %s\n", entry->target);
+                printf("Tracepoint detached from: %s\n", entry->target);
             } else {
-                fprintf(stderr, "Invalid raw tracepoint link for program fd %d\n", prog_fd);
+                fprintf(stderr, "Invalid tracepoint link for program fd %d\n", prog_fd);
             }
             break;
         }

tests/test_tracepoint.ml

@@ -220,11 +220,11 @@ fn sched_switch_handler(ctx: *trace_event_raw_sched_switch) -> i32 {
 let test_multiple_tracepoint_targets _ =
   (* Test various tracepoint targets to ensure they all work correctly *)
   let test_cases = [
-    ("sched/sched_switch", "SEC(\"raw_tracepoint/sched_switch\")");
-    ("net/netif_rx", "SEC(\"raw_tracepoint/netif_rx\")");
-    ("syscalls/sys_enter_read", "SEC(\"raw_tracepoint/sys_enter_read\")");
-    ("syscalls/sys_exit_write", "SEC(\"raw_tracepoint/sys_exit_write\")");
-    ("irq/irq_handler_entry", "SEC(\"raw_tracepoint/irq_handler_entry\")");
+    ("sched/sched_switch", "SEC(\"tracepoint/sched/sched_switch\")");
+    ("net/netif_rx", "SEC(\"tracepoint/net/netif_rx\")");
+    ("syscalls/sys_enter_read", "SEC(\"tracepoint/syscalls/sys_enter_read\")");
+    ("syscalls/sys_exit_write", "SEC(\"tracepoint/syscalls/sys_exit_write\")");
+    ("irq/irq_handler_entry", "SEC(\"tracepoint/irq/irq_handler_entry\")");
   ] in
 
   List.iter (fun (target, expected_sec) ->
@@ -255,34 +255,34 @@ fn sched_switch_handler(ctx: *trace_event_raw_sched_switch) -> i32 {
   let c_code = generate_c_multi_program ir_multi_prog in
 
   (* Ensure correct SEC() is generated *)
-  check bool "Should generate correct SEC(raw_tracepoint/sched_switch)" true
-    (Str.search_forward (Str.regexp_string "SEC(\"raw_tracepoint/sched_switch\")") c_code 0 >= 0);
+  check bool "Should generate correct SEC(tracepoint/sched/sched_switch)" true
+    (Str.search_forward (Str.regexp_string "SEC(\"tracepoint/sched/sched_switch\")") c_code 0 >= 0);
 
   (* Ensure buggy SEC() is NOT generated *)
-  check bool "Should NOT generate buggy SEC(raw_tracepoint/sched_sched)" true
+  check bool "Should NOT generate any raw_tracepoint SEC format" true
     (try 
-       let _ = Str.search_forward (Str.regexp_string "SEC(\"raw_tracepoint/sched_sched\")") c_code 0 in
-       false  (* Found the buggy pattern - test should fail *)
+       let _ = Str.search_forward (Str.regexp_string "SEC(\"raw_tracepoint/") c_code 0 in
+       false  (* Found raw_tracepoint - test should fail *)
      with Not_found -> 
-       true   (* Didn't find the buggy pattern - test should pass *)
+       true   (* No raw_tracepoint found - test should pass *)
     )
 
 (* 4. Code Generation Tests *)
-let test_raw_tracepoint_section_name_generation _ =
-  (* Test correct raw tracepoint section name generation *)
+let test_tracepoint_section_name_generation _ =
+  (* Test correct tracepoint section name generation *)
   let source = "@tracepoint(\"sched/sched_switch\")
 fn sched_switch_handler(ctx: *trace_event_raw_sched_switch) -> i32 {
     return 0
 }" in
   let ast = parse_string source in
   let typed_ast = type_check_ast ast in
   let symbol_table = Kernelscript.Symbol_table.build_symbol_table typed_ast in
-  let ir_multi_prog = generate_ir typed_ast symbol_table "test_raw_tracepoint" in
+  let ir_multi_prog = generate_ir typed_ast symbol_table "test_tracepoint" in
   let c_code = generate_c_multi_program ir_multi_prog in
 
-  (* Check that the correct SEC() is generated with just the event name *)
-  check bool "Should contain correct raw_tracepoint/sched_switch section" true
-    (Str.search_forward (Str.regexp_string "SEC(\"raw_tracepoint/sched_switch\")") c_code 0 >= 0)
+  (* Check that the correct SEC() is generated with the full path *)
+  check bool "Should contain correct tracepoint/sched/sched_switch section" true
+    (Str.search_forward (Str.regexp_string "SEC(\"tracepoint/sched/sched_switch\")") c_code 0 >= 0)
 
 let test_tracepoint_ebpf_codegen _ =
   let source = "@tracepoint(\"sched/sched_switch\")
@@ -296,8 +296,8 @@ fn sched_switch_handler(ctx: *trace_event_raw_sched_switch) -> i32 {
   let c_code = generate_c_multi_program ir_multi_prog in
 
   (* Check for tracepoint-specific C code elements *)
-  check bool "Should contain correct raw_tracepoint SEC" true 
-    (Str.search_forward (Str.regexp_string "SEC(\"raw_tracepoint/sched_switch\")") c_code 0 >= 0);
+  check bool "Should contain correct tracepoint SEC" true
+    (Str.search_forward (Str.regexp_string "SEC(\"tracepoint/sched/sched_switch\")") c_code 0 >= 0);
   check bool "Should contain function definition" true
     (String.contains c_code (String.get "sched_switch_handler" 0));
   check bool "Should contain struct parameter" true
@@ -408,8 +408,8 @@ fn sys_enter_open_handler(ctx: *trace_event_raw_sys_enter) -> i32 {
   let c_code = generate_c_multi_program ir_multi_prog in
 
   (* Comprehensive end-to-end validation *)
-  check bool "Contains correct raw_tracepoint section" true
-    (Str.search_forward (Str.regexp_string "SEC(\"raw_tracepoint/sys_enter_open\")") c_code 0 >= 0);
+  check bool "Contains correct tracepoint section" true
+    (Str.search_forward (Str.regexp_string "SEC(\"tracepoint/syscalls/sys_enter_open\")") c_code 0 >= 0);
   check bool "Contains function name" true
     (String.contains c_code (String.get "sys_enter_open_handler" 0));
   check bool "Contains context struct" true
@@ -453,7 +453,7 @@ let ir_generation_tests = [
 ]
 
 let code_generation_tests = [
-  "raw tracepoint section name generation", `Quick, test_raw_tracepoint_section_name_generation;
+  "tracepoint section name generation", `Quick, test_tracepoint_section_name_generation;
   "tracepoint eBPF code generation", `Quick, test_tracepoint_ebpf_codegen;
   "tracepoint includes generation", `Quick, test_tracepoint_includes_generation;
 ]