eBPF Documentation

AF_XDP (Address Family Express Data Path) is a special socket type, also known as a XSK (XDP Socket), that works in conjunction with an XDP program to perform full or partial kernel bypass. By bypassing the standard Linux network stack, you can significantly increase performance for specific workloads.

Common Use Cases

• Custom protocol implementations: Avoid the overhead of the kernel attempting to process protocols it doesn't understand.
• DDoS protection: Forward complex traffic to user space for analysis when eBPF programs alone cannot handle the required processing logic.
• Application-specific optimization: Implement a custom, lightweight network stack tailored to your specific needs, avoiding the performance cost of the general-purpose Linux network stack.

How it differs from other bypass techniques

Unlike PACKET_MMAP or PF_RING, which require you to handle all traffic and re-implement every protocol necessary for the host to function, AF_XDP allows an XDP program to selectively decide which traffic to pass to the kernel stack and which to bypass to a XSK. This enables bypassing traffic for specific applications, ports, or protocols without disrupting normal host networking.

The smc_hs_ctrl_ops struct ops allows BPF programs to selectively enable or disable SMC (Shared Memory Communications) negotiation for individual TCP connections. This is useful for controlling high-performance socket protocol usage based on runtime information like IP addresses or port numbers.

Workflow

1. Define a struct smc_hs_ctrl instance: Implement the syn_option and synack_option BPF programs and associate them with a named instance.
2. Register the instance: The instance is associated with a network namespace.
3. Activate the controller: Use the sysctl net.smc.hs_ctrl to set the active controller for a network namespace by providing the name of your registered instance.

Inheritance

By default, the controller is associated with its network namespace. If the SMC_HS_CTRL_FLAG_INHERITABLE flag is set, child network namespaces will inherit the controller.

// Example of defining the struct ops
SEC(".struct_ops")
struct smc_hs_ctrl my_smc_hs_ctrl = {
    .name           = "my_ctrl",
    .flags          = 0,
    .syn_option     = (void *)my_syn_option,
    .synack_option  = (void *)my_synack_option,
};

A BPF scheduler implements arbitrary scheduling policies by providing a table of operations defined in struct sched_ext_ops. This structure allows the BPF program to hook into various stages of the task lifecycle, such as waking up, enqueuing, dispatching, and running tasks. A userland scheduling policy can also be implemented by using the BPF scheduler as a shim layer.

struct sched_ext_ops {
    char [name][SCX_OPS_NAME_LEN];
    u32  [dispatch_max_batch];
    u64  [flags];
    u32  [timeout_ms];
    u32  [exit_dump_len];
    u64  [hotplug_seq];

    s32  (*[select_cpu])([struct task_struct] *p, s32 prev_cpu, u64 wake_flags);
    void (*[enqueue])([struct task_struct] *p, u64 enq_flags);
    void (*[dequeue])([struct task_struct] *p, u64 deq_flags);
    void (*[dispatch])(s32 cpu, [struct task_struct] *prev);
    void (*[tick])([struct task_struct] *p);
    void (*[runnable])([struct task_struct] *p, u64 enq_flags);
    void (*[running])([struct task_struct] *p);
    void (*[stopping])([struct task_struct] *p, bool runnable);
    void (*[quiescent])([struct task_struct] *p, u64 deq_flags);
    bool (*[yield])([struct task_struct] *from, [struct task_struct] *to);
    bool (*[core_sched_before])([struct task_struct] *a, [struct task_struct] *b);
    void (*[set_weight])([struct task_struct] *p, u32 weight);
    void (*[set_cpumask])([struct task_struct] *p, const [struct cpumask] *cpumask);
    void (*[update_idle])(s32 cpu, bool idle);
    void (*[cpu_acquire])(s32 cpu, [struct scx_cpu_acquire_args] *args);
    void (*[cpu_release])(s32 cpu, [struct scx_cpu_release_args] *args);
    
    s32  (*[init_task])([struct task_struct] *p, [struct scx_init_task_args] *args);
    void (*[exit_task])([struct task_struct] *p, [struct scx_exit_task_args] *args);
    
    void (*[enable])([struct task_struct] *p);
    void (*[disable])([struct task_struct] *p);
    
    void (*[dump])([struct scx_dump_ctx] *ctx);
    void (*[dump_cpu])([struct scx_dump_ctx] *ctx, s32 cpu, bool idle);
    void (*[dump_task])([struct scx_dump_ctx] *ctx, [struct task_struct] *p);

#ifdef CONFIG_EXT_GROUP_SCHED
    s32  (*[cgroup_init])([struct cgroup] *cgrp, [struct scx_cgroup_init_args] *args);
    void (*[cgroup_exit])([struct cgroup] *cgrp);
    s32  (*[cgroup_prep_move])([struct task_struct] *p, [struct cgroup] *from, [struct cgroup] *to);
    void (*[cgroup_move])([struct task_struct] *p, [struct cgroup] *from, [struct cgroup] *to);
    void (*[cgroup_cancel_move])([struct task_struct] *p, [struct cgroup] *from, [struct cgroup] *to);
    void (*[cgroup_set_weight])([struct cgroup] *cgrp, u32 weight);
#endif

    void (*[cpu_online])(s32 cpu);
    void (*[cpu_offline])(s32 cpu);

    s32  (*[init])(void);
    void (*[exit])([struct scx_exit_info] *info);
};