let program = {|

@struct_ops("tcp_congestion_ops")

struct MyTcpCong {

init: u32,

release: u32

}

fn main() -> i32 {

var tcp_ops = MyTcpCong { init: 1, release: 2 }

var result = register(tcp_ops)

return result

}

|} in

let ast = Parse.parse_string program in

(* Check that we have the expected declarations *)

check int "Number of declarations" 2 (List.length ast);

(* Check that the first declaration is a struct with @struct_ops attribute *)

(match List.hd ast with

| StructDecl struct_def ->

check string "Struct name" "MyTcpCong" struct_def.struct_name;

(match struct_def.struct_attributes with

| [AttributeWithArg (attr_name, attr_param)] ->

check string "Attribute name" "struct_ops" attr_name;

check string "Attribute parameter" "tcp_congestion_ops" attr_param

| _ -> fail "Expected single struct_ops attribute")

let program = {|

struct RegularStruct {

field1: u32,

field2: u64

}

fn main() -> i32 {

let instance = RegularStruct { field1: 1, field2: 2 }

return 0

}

|} in

let ast = Parse.parse_string program in

(* Check that the struct has no attributes *)

(match List.hd ast with

| StructDecl struct_def ->

check string "Struct name" "RegularStruct" struct_def.struct_name;

check int "No attributes" 0 (List.length struct_def.struct_attributes)

let program = {|

@struct_ops("tcp_congestion_ops")

impl MyTcpCong {

fn slow_start(sk: *u8) -> u32 {

return 1

}

fn cong_avoid(sk: *u8, ack: u32, acked: u32) -> void {

// Implementation

}

name: "my_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(MyTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

(* Type checking should succeed *)

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let program = {|

struct RegularStruct {

field1: u32,

field2: u64

}

fn main() -> i32 {

var instance = RegularStruct { field1: 1, field2: 2 }

var result = register(instance)

return result

}

|} in

let ast = Parse.parse_string program in

(* Type checking should fail *)

try

let _ = Type_checker.type_check_and_annotate_ast ast in

fail "register() with regular struct should fail type checking"

with

| Type_checker.Type_error (msg, _) ->

check bool "Error message mentions struct_ops requirement" true

(try ignore (Str.search_forward (Str.regexp "struct_ops") msg 0); true with Not_found -> false)

let program = {|

@struct_ops("tcp_congestion_ops")

impl TcpOps {

fn init(sk: *u8) -> u32 {

return 1

}

fn release(sk: *u8) -> void {

// Release implementation

}

name: "tcp_ops",

owner: null,

}

@struct_ops("bpf_iter_ops")

impl IterOps {

fn init_seq() -> u32 {

return 3

}

fn fini_seq() -> void {

// Cleanup implementation

}

name: "iter_ops",

owner: null,

}

fn main() -> i32 {

var result1 = register(TcpOps)

var result2 = register(IterOps)

return result1 + result2

}

|} in

let ast = Parse.parse_string program in

(* Both impl blocks should be parsed correctly *)

let impl_count = List.fold_left (fun acc decl ->

match decl with

| ImplBlock impl_block ->

if List.length impl_block.impl_attributes > 0 then acc + 1 else acc

| _ -> acc

) 0 ast in

check int "Number of struct_ops" 2 impl_count;

(* Type checking should succeed *)

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let program = {|

@struct_ops("tcp_congestion_ops")

impl MyTcpCong {

fn init(sk: *u8) -> u32 {

return 1

}

fn release(sk: *u8) -> void {

// Release implementation

}

name: "my_tcp_cong",

owner: null,

}

@xdp fn xdp_prog(ctx: *xdp_md) -> xdp_action {

return 2

}

fn main() -> i32 {

var result = register(MyTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let symbol_table = Symbol_table.build_symbol_table ast in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

(* Check that struct_ops are collected in IR *)

check bool "IR contains struct_ops declarations" true (List.length (Ir.get_struct_ops_declarations ir) > 0);

(* Check the struct_ops declaration details *)

(match (Ir.get_struct_ops_declarations ir) with

| [declaration] ->

check string "Struct ops name" "MyTcpCong" declaration.ir_struct_ops_name;

check string "Kernel struct name" "tcp_congestion_ops" declaration.ir_kernel_struct_name

| _ -> fail "Expected exactly one struct_ops declaration in IR");

(* With impl blocks, the functions become individual eBPF programs *)

check bool "IR contains impl block programs" true (List.length (Ir.get_programs ir) >= 2); (* init and release functions *)

let program = {|

@struct_ops("tcp_congestion_ops")

impl MyTcpCong {

fn init(sk: *u8) -> u32 {

return 1

}

fn release(sk: *u8) -> void {

// Release implementation

}

name: "my_tcp_cong",

owner: null,

}

@xdp fn xdp_prog(ctx: *xdp_md) -> xdp_action {

return 2

}

fn main() -> i32 {

var result = register(MyTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

let symbol_table = Symbol_table.build_symbol_table ast_with_structs in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast_with_structs in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

(* Generate eBPF C code *)

let (c_code, _) = Ebpf_c_codegen.compile_multi_to_c_with_analysis ir in

(* Basic generation checks *)

check bool "eBPF code generation completed" true (String.length c_code > 0);

(* Check for struct_ops section annotations *)

check bool "Contains struct_ops sections" true

(try ignore (Str.search_forward (Str.regexp "SEC(\"struct_ops") c_code 0); true with Not_found -> false);

(* Kernel struct definitions from .kh headers should NOT be emitted (vmlinux.h provides them) *)

(* Check that struct_ops instance is properly generated *)

check bool "Contains struct_ops instance definition" true

(try ignore (Str.search_forward (Str.regexp "SEC(\"\\.struct_ops\")") c_code 0); true with Not_found -> false);

check bool "Instance has correct struct type" true

let program = {|

@struct_ops("tcp_congestion_ops")

impl MyTcpCong {

fn init(sk: *u8) -> u32 {

return 1

}

fn release(sk: *u8) -> void {

// Release implementation

}

name: "my_tcp_cong",

owner: null,

}

@xdp fn xdp_prog(ctx: *xdp_md) -> xdp_action {

return 2

}

fn main() -> i32 {

var result = register(MyTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let symbol_table = Symbol_table.build_symbol_table ast in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

(* Generate userspace C code *)

let userspace_code = match ir.userspace_program with

| Some userspace_prog ->

Userspace_codegen.generate_complete_userspace_program_from_ir userspace_prog (Ir.get_global_maps ir) ir "test"

| None -> ""

in

(* Check that struct_ops registration code is generated *)

check bool "Contains struct_ops registration" true

(try ignore (Str.search_forward (Str.regexp "bpf_map__attach_struct_ops") userspace_code 0); true with Not_found -> false);

(* Check that struct_ops setup is included *)

check bool "Contains struct_ops setup" true

(try ignore (Str.search_forward (Str.regexp "MyTcpCong") userspace_code 0); true with Not_found -> false);

check bool "Contains memlock helper for struct_ops" true

(contains_substr userspace_code "static int bump_memlock_rlimit(void)");

check bool "Contains privilege helper for struct_ops" true

(contains_substr userspace_code "static int ensure_struct_ops_privileges(void)");

check bool "Main calls struct_ops runtime checks" true

(contains_substr userspace_code "if (bump_memlock_rlimit() < 0)" &&

contains_substr userspace_code "if (ensure_struct_ops_privileges() < 0)");

check bool "Contains struct_ops link global" true

(contains_substr userspace_code "static struct bpf_link *MyTcpCong_link = NULL;");

check bool "Contains struct_ops cleanup helper" true

(contains_substr userspace_code "static void cleanup_test(void)");

check bool "Contains wait helper for struct_ops" true

(contains_substr userspace_code "static void wait_for_unregister_request(void)");

check bool "Contains real attach helper for struct_ops" true

(contains_substr userspace_code "int attach_struct_ops_MyTcpCong(void)" &&

contains_substr userspace_code "MyTcpCong_link = bpf_map__attach_struct_ops(map);");

check bool "Contains real detach helper for struct_ops" true

(contains_substr userspace_code "int detach_struct_ops_MyTcpCong(void)" &&

contains_substr userspace_code "bpf_link__destroy(MyTcpCong_link);");

check bool "register() uses attach helper" true

(contains_substr userspace_code "attach_struct_ops_MyTcpCong()");

check bool "Struct_ops load failure includes EPERM hint" true

(contains_substr userspace_code "The kernel rejected BPF loading with EPERM. Make sure you run as root and the kernel supports struct_ops.");

check bool "Main waits for unregister request" true

(contains_substr userspace_code "wait_for_unregister_request();");

check bool "Main detaches struct_ops before exit" true

(contains_substr userspace_code "detach_struct_ops_MyTcpCong();");

check bool "Main registers struct_ops cleanup" true

let program = {|

@struct_ops

struct BadStruct {

field: u32

}

@xdp fn xdp_prog(ctx: *xdp_md) -> xdp_action {

return 2

}

fn main() -> i32 {

return 0

}

|} in

(* The parser accepts @struct_ops as SimpleAttribute *)

let ast = Parse.parse_string program in

(* For now, type checking passes this through - future enhancement could validate struct attributes *)

(* This test documents current behavior and can be enhanced when validation is added *)

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let program = {|

fn main() -> i32 {

var x: u32 = 42

var result = register(x)

return result

}

|} in

let ast = Parse.parse_string program in

(* Type checking should fail *)

try

let _ = Type_checker.type_check_and_annotate_ast ast in

fail "register() with non-struct should fail type checking"

with

| Type_checker.Type_error _ -> ()

let program = {|

@struct_ops("tcp_congestion_ops")

impl OuterImpl {

fn outer_func(sk: *u8) -> u32 {

return 42

}

name: "outer_impl",

owner: null,

}

@struct_ops("bpf_iter_ops")

impl InnerImpl {

fn inner_func() -> u64 {

return 100

}

name: "inner_impl",

owner: null,

}

fn main() -> i32 {

var result1 = register(OuterImpl)

var result2 = register(InnerImpl)

return result1 + result2

}

|} in

let ast = Parse.parse_string program in

(* Type checking should succeed - multiple impl blocks are allowed *)

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let program = {|

@struct_ops("bpf_iter_ops")

struct IterOps {

init_seq: u32,

fini_seq: u32

}

fn main() -> i32 {

var ops = IterOps { init_seq: 1, fini_seq: 2 }

return 0

}

|} in

let ast = Parse.parse_string program in

let symbol_table = Symbol_table.build_symbol_table ast in

(* Check that struct_ops is added to symbol table *)

(match Symbol_table.lookup_symbol symbol_table "IterOps" with

| Some symbol ->

(match symbol.kind with

| TypeDef (StructDef (name, _, _)) -> check string "Struct name in symbol table" "IterOps" name

| _ -> fail "Expected StructDef in symbol table")

let program = {|

@struct_ops("completely_made_up_struct_ops")

impl UnknownImpl {

fn some_func() -> u32 {

return 42

}

name: "unknown_impl",

owner: null,

}

fn main() -> i32 {

var result = register(UnknownImpl)

return result

}

|} in

let ast = Parse.parse_string program in

(* Type checking should fail for unknown struct_ops *)

try

let _ = Type_checker.type_check_and_annotate_ast ast in

fail "Unknown struct_ops name should fail type checking"

with

| Type_checker.Type_error (msg, _) ->

check bool "Error message mentions unknown struct_ops" true

(try ignore (Str.search_forward (Str.regexp "Unknown struct_ops\\|unknown.*struct_ops\\|Invalid struct_ops") msg 0); true with Not_found -> false)

let program = {|

@struct_ops("tcp_congestion_ops")

impl BadTcpCong {

fn ssthresh(sk: *u8) -> void { // WRONG: should return u32

// Implementation

}

name: "bad_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(BadTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

(* Type checking should fail for wrong return type *)

try

let _ = Type_checker.type_check_and_annotate_ast ast_with_structs in

fail "Wrong return type should fail validation"

with

| Type_checker.Type_error (msg, _) ->

check bool "Error message mentions return type mismatch" true

(try ignore (Str.search_forward (Str.regexp "return.*type\\|signature.*mismatch") msg 0); true with Not_found -> false)

let program = {|

@struct_ops("tcp_congestion_ops")

impl BadTcpCong {

fn cong_avoid(sk: *u8) -> void { // WRONG: missing ack and acked parameters

// Implementation

}

name: "bad_tcp_cong",

owner: null,

}

fn main() -> i32 {

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

(* Type checking should fail for missing parameters *)

try

let _ = Type_checker.type_check_and_annotate_ast ast_with_structs in

fail "Missing parameters should fail validation"

with

| Type_checker.Type_error (msg, _) ->

check bool "Error message mentions parameter mismatch" true

(try ignore (Str.search_forward (Str.regexp "parameter.*mismatch\\|signature.*mismatch") msg 0); true with Not_found -> false)

let program = {|

@struct_ops("tcp_congestion_ops")

impl BadTcpCong {

fn ssthresh(sk: *u8, extra: u32) -> u32 { // WRONG: extra parameter

return 16

}

name: "bad_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(BadTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

(* Type checking should fail for extra parameters *)

try

let _ = Type_checker.type_check_and_annotate_ast ast_with_structs in

fail "Extra parameters should fail validation"

with

| Type_checker.Type_error (msg, _) ->

check bool "Error message mentions parameter mismatch" true

(try ignore (Str.search_forward (Str.regexp "parameter.*count\\|signature.*mismatch") msg 0); true with Not_found -> false)

let program = {|

@struct_ops("tcp_congestion_ops")

impl BadTcpCong {

fn cong_avoid(sk: u32, ack: u32, acked: u32) -> void { // WRONG: sk should be *u8, not u32

// Implementation

}

name: "bad_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(BadTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

(* Type checking should fail for wrong parameter type *)

try

let _ = Type_checker.type_check_and_annotate_ast ast_with_structs in

fail "Wrong parameter type should fail validation"

with

| Type_checker.Type_error (msg, _) ->

check bool "Error message mentions parameter type mismatch" true

(try ignore (Str.search_forward (Str.regexp "parameter.*type\\|signature.*mismatch") msg 0); true with Not_found -> false)

let program = {|

@struct_ops("tcp_congestion_ops")

impl IncompleteTcpCong {

// Missing functions are now allowed since most struct_ops functions are optional

name: "incomplete_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(IncompleteTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

(* Type checking should now succeed since functions are optional *)

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast_with_structs in

let program = {|

@struct_ops("tcp_congestion_ops")

impl CorrectTcpCong {

fn ssthresh(sk: *u8) -> u32 { // Correct signature

return 16

}

fn cong_avoid(sk: *u8, ack: u32, acked: u32) -> void { // Correct signature

// Implementation

}

// Only implementing some functions - others are optional

name: "correct_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(CorrectTcpCong)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

(* Type checking should succeed for correct signatures *)

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast_with_structs in

(* Test known struct_ops detection *)

check bool "tcp_congestion_ops is known" true (Struct_ops_registry.is_known_struct_ops "tcp_congestion_ops");

check bool "bpf_iter_ops is known" true (Struct_ops_registry.is_known_struct_ops "bpf_iter_ops");

check bool "unknown_struct_ops is not known" false (Struct_ops_registry.is_known_struct_ops "unknown_struct_ops");

(* Test struct_ops info retrieval *)

(match Struct_ops_registry.get_struct_ops_info "tcp_congestion_ops" with

| Some info ->

check string "tcp_congestion_ops description" "TCP congestion control operations" info.description;

check (option string) "tcp_congestion_ops version" (Some "5.6+") info.kernel_version

| None -> fail "Expected to find tcp_congestion_ops info");

(* Test getting all known struct_ops *)

let all_known = Struct_ops_registry.get_all_known_struct_ops () in

check bool "Contains tcp_congestion_ops" true (List.mem "tcp_congestion_ops" all_known);

let tcp_example = Struct_ops_registry.generate_struct_ops_usage_example "tcp_congestion_ops" in

check bool "TCP example contains register" true

(try ignore (Str.search_forward (Str.regexp "register") tcp_example 0); true with Not_found -> false);

check bool "TCP example contains tcp_congestion_ops" true

(try ignore (Str.search_forward (Str.regexp "tcp_congestion_ops") tcp_example 0); true with Not_found -> false);

let unknown_example = Struct_ops_registry.generate_struct_ops_usage_example "unknown_struct_ops" in

check bool "Unknown example contains register" true

(* Test template generation without BTF file should now error *)

(try

let _ = Btf_parser.generate_struct_ops_template None ["tcp_congestion_ops"] "test_project" in

fail "Expected error when no BTF file is provided"

with

| Failure msg when String.contains msg 'B' && String.contains msg 'T' && String.contains msg 'F' ->

check bool "missing BTF error mentions BTF" true (String.length msg > 0)

| e -> fail ("Expected BTF-related Failure, got: " ^ Printexc.to_string e));

(* Test with invalid BTF file path should also error *)

(try

let _ = Btf_parser.generate_struct_ops_template (Some "/nonexistent/btf") ["tcp_congestion_ops"] "test_project" in

fail "Expected error for non-existent BTF file"

with

| Failure msg when String.contains msg 'B' && String.contains msg 'T' && String.contains msg 'F' ->

check bool "invalid BTF error mentions BTF" true (String.length msg > 0)

(* This test would require setting up temporary directories and running the actual init command *)

(* For now, we'll test the underlying logic *)

(* Test that tcp_congestion_ops is recognized as a struct_ops *)

check bool "tcp_congestion_ops is recognized as struct_ops" true

(Struct_ops_registry.is_known_struct_ops "tcp_congestion_ops");

(* Test that regular program types are still recognized *)

let valid_program_types = ["xdp"; "tc"; "kprobe"; "uprobe"; "tracepoint"; "lsm"; "cgroup_skb"] in

List.iter (fun prog_type ->

check bool (sprintf "%s is valid program type" prog_type) true

(List.mem prog_type valid_program_types)

(* Test verification with non-existent BTF file *)

(match Struct_ops_registry.verify_struct_ops_against_btf "/non/existent/btf" "tcp_congestion_ops" [("init", "u32")] with

| Error msg ->

check bool "Error message contains expected text" true

(String.contains msg 'B' && String.contains msg 'T' && String.contains msg 'F')

| Ok () -> fail "Expected error for non-existent BTF file");

(* Test extraction from non-existent BTF file *)

let definitions = Struct_ops_registry.extract_struct_ops_from_btf "/non/existent/btf" ["tcp_congestion_ops"] in

(* Create mock BTF type info *)

let mock_btf_type = {

Btf_binary_parser.name = "tcp_congestion_ops";

kind = "struct";

size = Some 64;

members = Some [

("init", "void*");

("cong_avoid", "void*");

("set_state", "void*");

("name", "char*");

];

kernel_defined = true;

} in

(* Test struct_ops definition generation *)

(match Struct_ops_registry.generate_struct_ops_definition mock_btf_type with

| Some definition ->

check bool "Definition contains @struct_ops attribute" true

(try ignore (Str.search_forward (Str.regexp "@struct_ops") definition 0); true with Not_found -> false);

check bool "Definition contains struct name" true

(try ignore (Str.search_forward (Str.regexp "tcp_congestion_ops") definition 0); true with Not_found -> false);

check bool "Definition contains init field" true

(try ignore (Str.search_forward (Str.regexp "init:") definition 0); true with Not_found -> false);

check bool "Definition contains cong_avoid field" true

(try ignore (Str.search_forward (Str.regexp "cong_avoid:") definition 0); true with Not_found -> false)

let program = {|

// This struct should NOT be included in eBPF code - it's userspace-only

struct Args {

enable_debug: u32,

interface: str(16),

}

// This struct should be included in eBPF code - it's referenced by struct_ops

@struct_ops("tcp_congestion_ops")

impl TcpOps {

fn ssthresh(sk: *u8) -> u32 {

return 16

}

fn cong_avoid(sk: *u8, ack: u32, acked: u32) -> void {

// Implementation

}

name: "test_tcp_ops",

owner: null,

}

// This config struct should be included - it's used by eBPF programs

config network_config {

max_packet_size: u32 = 1500,

enable_logging: bool = true,

}

@xdp fn packet_filter(ctx: *xdp_md) -> xdp_action {

return 1

}

fn main(args: Args) -> i32 {

if (args.enable_debug > 0) {

var result = register(TcpOps)

return result

}

return 0

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

let symbol_table = Symbol_table.build_symbol_table ast_with_structs in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast_with_structs in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

(* Generate eBPF C code *)

let (c_code, _) = Ebpf_c_codegen.compile_multi_to_c_with_analysis ir in

(* Check that all structs are included in eBPF code *)

check bool "Args struct should be in eBPF code (all structs included)" true

(contains_substr c_code "struct Args");

(* Check that struct_ops-referenced structs ARE included in eBPF code *)

check bool "tcp_congestion_ops struct should be in eBPF code (kernel struct)" true

(contains_substr c_code "struct tcp_congestion_ops");

(* Check that config structs ARE included in eBPF code *)

check bool "network_config struct should be in eBPF code (used by eBPF programs)" true

(contains_substr c_code "struct network_config");

(* Verify that eBPF code compiles without missing struct definition errors *)

check bool "eBPF code generation completed without errors" true (String.length c_code > 0);

(* Additional verification: check that string literals are handled properly *)

(* String literals should be embedded directly in the code, not as struct types *)

check bool "String literals are handled properly" true

let program = {|

@struct_ops("tcp_congestion_ops")

impl minimal_congestion_control {

fn ssthresh(sk: *u8) -> u32 {

return 16

}

fn cong_avoid(sk: *u8, ack: u32, acked: u32) -> void {

// Implementation

}

owner: null,

}

@xdp fn test_prog(ctx: *xdp_md) -> xdp_action {

return 1

}

fn main() -> i32 {

var result = register(minimal_congestion_control)

return result

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

let symbol_table = Symbol_table.build_symbol_table ast_with_structs in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast_with_structs in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

(* Generate eBPF C code *)

let (c_code, _) = Ebpf_c_codegen.compile_multi_to_c_with_analysis ir in

(* The key test: verify that tcp_congestion_ops struct is complete and usable *)

check bool "Contains complete tcp_congestion_ops struct definition" true

(contains_substr c_code "struct tcp_congestion_ops");

(* Check that the struct_ops instance can be instantiated (key thing that was failing) *)

check bool "Contains struct_ops instance instantiation" true

(contains_substr c_code "minimal_congestion_control" && contains_substr c_code "struct tcp_congestion_ops");

(* Verify SEC annotations are present *)

check bool "Contains .struct_ops section" true

(contains_substr c_code "SEC(\".struct_ops\")");

(* Verify the compiler synthesizes a safe default name when omitted *)

check bool "Contains synthesized tcp_congestion_ops name" true

(contains_substr c_code ".name = \"minimal_cc\"");

(* Verify individual function SEC annotations *)

check bool "Contains struct_ops function sections" true

let program = {|

@struct_ops("tcp_congestion_ops")

impl minimal_congestion_control {

fn ssthresh(sk: *u8) -> u32 {

return 16

}

fn undo_cwnd(sk: *u8) -> u32 {

return ssthresh(sk)

}

}

|} in

let ast = Parse.parse_string program in

let ast_with_structs = ast @ Test_utils.StructOps.builtin_ast in

let symbol_table = Symbol_table.build_symbol_table ast_with_structs in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast_with_structs in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

let (c_code, _) = Ebpf_c_codegen.compile_multi_to_c_with_analysis ir in

check bool "struct_ops direct call emitted" true

(contains_substr c_code "ssthresh(sk)");

check bool "struct_ops tail call not emitted" false

(* Simple case: var result = register(MyTcpCong); return result *)

let program_simple = {|

@struct_ops("tcp_congestion_ops")

impl MyTcpCong {

fn init(sk: *u8) -> u32 { return 0 }

fn release(sk: *u8) -> void {}

name: "my_tcp_cong",

owner: null,

}

fn main() -> i32 {

var result = register(MyTcpCong)

return result

}

|} in

let ast = Parse.parse_string program_simple in

let symbol_table = Symbol_table.build_symbol_table ast in

let (typed_ast, _) = Type_checker.type_check_and_annotate_ast ast in

let ir = Ir_generator.generate_ir typed_ast symbol_table "test" in

let userspace_code = match ir.userspace_program with

| Some p -> Userspace_codegen.generate_complete_userspace_program_from_ir

p (Ir.get_global_maps ir) ir "test"

| None -> ""

in

(* The lifecycle code should use the correctly-prefixed C variable throughout *)

check bool "lifecycle uses var_result for attach status check" true

(contains_substr userspace_code "if (var_result != 0)");

check bool "lifecycle calls detach_struct_ops_MyTcpCong" true

(contains_substr userspace_code "var_result = detach_struct_ops_MyTcpCong()");

check bool "lifecycle returns var_result at the end" true

(contains_substr userspace_code "return var_result;");

check bool "register result stored via prefixed var_result, not bare result" true