SYMBOL INDEX (520 symbols across 84 files)

FILE: librex/include/librex.h
  type bpf_object (line 4) | struct bpf_object
  type rex_obj (line 5) | struct rex_obj
  type rex_obj (line 13) | struct rex_obj
  type bpf_object (line 16) | struct bpf_object
  type rex_obj (line 17) | struct rex_obj

FILE: librex/lib/bindings.h
  type elf_state (line 12) | struct elf_state {
  type bpf_sec_def (line 33) | struct bpf_sec_def {
  type bpf_object_state (line 45) | enum bpf_object_state {
  type bpf_object (line 51) | struct bpf_object {
  type bpf_light_subprog (line 130) | struct bpf_light_subprog
  type bpf_program (line 136) | struct bpf_program {
  type libbpf_map_type (line 210) | enum libbpf_map_type {
  type bpf_map_def (line 218) | struct bpf_map_def {
  type bpf_map (line 226) | struct bpf_map {

FILE: librex/lib/librex.cpp
  function sec_def_matches (line 34) | bool sec_def_matches(const struct bpf_sec_def *sec_def,
  function bpf_sec_def (line 64) | const bpf_sec_def *find_sec_def(std::string_view sec_name) {
  function bpf (line 74) | inline long bpf(__u64 cmd, union bpf_attr *attr, unsigned int size) {
  function align_up_16 (line 78) | inline uint64_t align_up_16(uint64_t val) {
  type map_def (line 87) | struct map_def {
  type rex_map (line 96) | struct rex_map {
    method rex_map (line 103) | rex_map() = delete;
    method rex_map (line 104) | rex_map(const Elf_Data *data, Elf64_Addr base, Elf64_Off off,
    method rex_map (line 120) | rex_map(const rex_map &) = delete;
    method rex_map (line 121) | rex_map(rex_map &&) = delete;
    method rex_map (line 127) | rex_map &operator=(const rex_map &) = delete;
    method rex_map (line 128) | rex_map &operator=(rex_map &&) = delete;
    method create (line 130) | std::optional<int> create() {
    method bpfmap (line 152) | std::optional<bpf_map> bpfmap() {
  type rex_prog (line 176) | struct rex_prog {
    type bpf_sec_def (line 180) | struct bpf_sec_def
    method rex_prog (line 185) | rex_prog() = delete;
    method rex_prog (line 186) | rex_prog(const char *nm, const char *scn_nm, Elf64_Off off)
    method rex_prog (line 191) | rex_prog(const rex_prog &) = delete;
    method rex_prog (line 197) | rex_prog(rex_prog &&other) noexcept
    method rex_prog (line 210) | rex_prog &operator=(const rex_prog &) = delete;
    method rex_prog (line 211) | rex_prog &operator=(rex_prog &&) = delete;
    method bpf_prog (line 213) | std::optional<bpf_program> bpf_prog() {
  type rex_obj (line 234) | struct rex_obj {
    type elf_del (line 236) | struct elf_del {
    type file_map_del (line 240) | struct file_map_del {
      method file_map_del (line 243) | file_map_del() = default;
      method file_map_del (line 244) | explicit file_map_del(size_t sz) : size(sz) {}
    type bpf_obj_del (line 251) | struct bpf_obj_del {
    method rex_obj (line 291) | rex_obj() = delete;
    method rex_obj (line 293) | rex_obj(const rex_obj &) = delete;
    method rex_obj (line 294) | rex_obj(rex_obj &&) = delete;
    method rex_obj (line 297) | rex_obj &operator=(const rex_obj &) = delete;
    method rex_obj (line 298) | rex_obj &operator=(rex_obj &&) = delete;
  type stat (line 309) | struct stat
  function bpf_object (line 749) | bpf_object *rex_obj::bpf_obj() {
  function rex_set_debug (line 796) | [[gnu::visibility("default")]] void rex_set_debug(int val) { debug = val; }
  function rex_obj (line 800) | [[nodiscard, gnu::visibility("default")]] rex_obj *
    type elf_del (line 236) | struct elf_del {
    type file_map_del (line 240) | struct file_map_del {
      method file_map_del (line 243) | file_map_del() = default;
      method file_map_del (line 244) | explicit file_map_del(size_t sz) : size(sz) {}
    type bpf_obj_del (line 251) | struct bpf_obj_del {
    method rex_obj (line 291) | rex_obj() = delete;
    method rex_obj (line 293) | rex_obj(const rex_obj &) = delete;
    method rex_obj (line 294) | rex_obj(rex_obj &&) = delete;
    method rex_obj (line 297) | rex_obj &operator=(const rex_obj &) = delete;
    method rex_obj (line 298) | rex_obj &operator=(rex_obj &&) = delete;
  function bpf_object (line 827) | [[nodiscard, gnu::visibility("default")]] bpf_object *

FILE: rex-macros/src/args.rs
  function parse_string_args (line 14) | pub(crate) fn parse_string_args(

FILE: rex-macros/src/kprobe.rs
  type KprobeFlavor (line 10) | pub enum KprobeFlavor {
    method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type KProbe (line 28) | pub(crate) struct KProbe {
    method parse (line 35) | pub(crate) fn parse(
    method expand (line 47) | pub(crate) fn expand(&self, flavor: KprobeFlavor) -> Result<TokenStrea...

FILE: rex-macros/src/lib.rs
  function rex_xdp (line 23) | pub fn rex_xdp(attrs: TokenStream, item: TokenStream) -> TokenStream {
  function rex_tc (line 35) | pub fn rex_tc(attrs: TokenStream, item: TokenStream) -> TokenStream {
  function rex_kprobe (line 47) | pub fn rex_kprobe(attrs: TokenStream, item: TokenStream) -> TokenStream {
  function rex_uprobe (line 59) | pub fn rex_uprobe(attrs: TokenStream, item: TokenStream) -> TokenStream {
  function rex_tracepoint (line 71) | pub fn rex_tracepoint(attrs: TokenStream, item: TokenStream) -> TokenStr...
  function rex_perf_event (line 83) | pub fn rex_perf_event(attrs: TokenStream, item: TokenStream) -> TokenStr...
  function rex_map (line 95) | pub fn rex_map(_: TokenStream, item: TokenStream) -> TokenStream {

FILE: rex-macros/src/perf_event.rs
  type PerfEvent (line 5) | pub(crate) struct PerfEvent {
    method parse (line 11) | pub(crate) fn parse(
    method expand (line 19) | pub(crate) fn expand(&self) -> Result<TokenStream> {

FILE: rex-macros/src/tc.rs
  type SchedCls (line 5) | pub(crate) struct SchedCls {
    method parse (line 11) | pub(crate) fn parse(_: TokenStream, item: TokenStream) -> Result<Sched...
    method expand (line 23) | pub(crate) fn expand(&self) -> Result<TokenStream> {

FILE: rex-macros/src/tracepoint.rs
  type TracePoint (line 6) | pub(crate) struct TracePoint {
    method parse (line 12) | pub(crate) fn parse(
    method expand (line 20) | pub(crate) fn expand(&self) -> Result<TokenStream> {

FILE: rex-macros/src/xdp.rs
  type Xdp (line 5) | pub(crate) struct Xdp {
    method parse (line 11) | pub(crate) fn parse(_: TokenStream, item: TokenStream) -> Result<Xdp> {
    method expand (line 20) | pub(crate) fn expand(&self) -> Result<TokenStream> {

FILE: rex/build.py
  function prep_uapi_headers (line 70) | def prep_uapi_headers(linux_path, headers, out_dir):
  function parse_cargo_toml (line 82) | def parse_cargo_toml(cargo_toml_path):
  function prep_kernel_headers (line 93) | def prep_kernel_headers(headers, linux_src, linux_obj, out_dir):
  function parse_kconfigs (line 114) | def parse_kconfigs(dot_config_path, kconfigs):
  function main (line 132) | def main(argv):

FILE: rex/build.rs
  function main (line 9) | fn main() -> Result<()> {

FILE: rex/src/base_helper.rs
  function bpf_get_smp_processor_id (line 44) | pub(crate) fn bpf_get_smp_processor_id() -> i32 {
  function bpf_map_lookup_elem (line 48) | pub(crate) fn bpf_map_lookup_elem<'a, const MT: bpf_map_type, K, V>(
  function bpf_map_update_elem (line 72) | pub(crate) fn bpf_map_update_elem<const MT: bpf_map_type, K, V>(
  function bpf_map_delete_elem (line 96) | pub(crate) fn bpf_map_delete_elem<const MT: bpf_map_type, K, V>(
  function bpf_map_push_elem (line 116) | pub(crate) fn bpf_map_push_elem<const MT: bpf_map_type, K, V>(
  function bpf_map_pop_elem (line 138) | pub(crate) fn bpf_map_pop_elem<const MT: bpf_map_type, K, V>(
  function bpf_map_peek_elem (line 160) | pub(crate) fn bpf_map_peek_elem<const MT: bpf_map_type, K, V>(
  function bpf_probe_read_kernel (line 202) | pub(crate) fn bpf_probe_read_kernel<T>(
  function bpf_jiffies64 (line 218) | pub(crate) fn bpf_jiffies64() -> u64 {
  function bpf_get_numa_node_id (line 223) | pub(crate) fn bpf_get_numa_node_id() -> i32 {
  function bpf_ktime_get_ns (line 239) | pub(crate) fn bpf_ktime_get_ns() -> u64 {
  function bpf_ktime_get_boot_ns (line 243) | pub(crate) fn bpf_ktime_get_boot_ns() -> u64 {
  function bpf_ktime_get_coarse_ns (line 247) | pub(crate) fn bpf_ktime_get_coarse_ns() -> u64 {
  function bpf_get_prandom_u32 (line 265) | pub(crate) fn bpf_get_prandom_u32() -> u32 {
  function bpf_snprintf (line 270) | pub(crate) fn bpf_snprintf<const N: usize, const M: usize>(

FILE: rex/src/debug.rs
  function printk (line 7) | pub(crate) unsafe extern "C" fn printk(fmt: &str, mut ap: ...) -> c_int {

FILE: rex/src/ffi.rs
  function bpf_map_lookup_elem (line 18) | pub(crate) fn bpf_map_lookup_elem(map: *mut (), key: *const ()) -> *mut ();
  function bpf_map_update_elem (line 24) | pub(crate) fn bpf_map_update_elem(
  function bpf_map_delete_elem (line 34) | pub(crate) fn bpf_map_delete_elem(map: *mut (), key: *const ()) -> i64;
  function bpf_map_push_elem (line 40) | pub(crate) fn bpf_map_push_elem(
  function bpf_map_pop_elem (line 49) | pub(crate) fn bpf_map_pop_elem(map: *mut (), value: *const ()) -> i64;
  function bpf_map_peek_elem (line 54) | pub(crate) fn bpf_map_peek_elem(map: *mut (), value: *const ()) -> i64;
  function bpf_probe_read_kernel (line 58) | pub(crate) fn bpf_probe_read_kernel(
  function ktime_get_mono_fast_ns (line 65) | pub(crate) fn ktime_get_mono_fast_ns() -> u64;
  function ktime_get_boot_fast_ns (line 68) | pub(crate) fn ktime_get_boot_fast_ns() -> u64;
  function bpf_ktime_get_ns (line 71) | pub(crate) fn bpf_ktime_get_ns() -> u64;
  function bpf_ktime_get_boot_ns (line 74) | pub(crate) fn bpf_ktime_get_boot_ns() -> u64;
  function bpf_ktime_get_coarse_ns (line 77) | pub(crate) fn bpf_ktime_get_coarse_ns() -> u64;
  function get_random_u32 (line 80) | pub(crate) fn get_random_u32() -> u32;
  function bpf_snprintf (line 84) | pub(crate) fn bpf_snprintf(
  function vprintk (line 93) | pub(crate) fn vprintk(fmt: *const c_uchar, args: VaList) -> i32;
  function rex_landingpad (line 98) | pub(crate) fn rex_landingpad() -> !;
  function bpf_spin_lock (line 101) | pub(crate) fn bpf_spin_lock(lock: *mut bpf_spin_lock) -> i64;
  function bpf_spin_unlock (line 104) | pub(crate) fn bpf_spin_unlock(lock: *mut bpf_spin_lock) -> i64;
  function just_return_func (line 107) | pub(crate) fn just_return_func();
  function bpf_get_stackid_pe (line 117) | pub(crate) fn bpf_get_stackid_pe(
  function bpf_perf_prog_read_value (line 129) | pub(crate) fn bpf_perf_prog_read_value(
  function bpf_perf_event_output_tp (line 137) | pub(crate) fn bpf_perf_event_output_tp(
  function bpf_perf_event_read_value (line 149) | pub(crate) fn bpf_perf_event_read_value(
  function bpf_skb_event_output (line 161) | pub(crate) fn bpf_skb_event_output(
  function bpf_xdp_event_output (line 174) | pub(crate) fn bpf_xdp_event_output(
  function bpf_xdp_adjust_head (line 187) | pub(crate) fn bpf_xdp_adjust_head(xdp: *mut xdp_buff, offset: i32) -> i32;
  function bpf_xdp_adjust_tail (line 194) | pub(crate) fn bpf_xdp_adjust_tail(xdp: *mut xdp_buff, offset: i32) -> i32;
  function bpf_clone_redirect (line 201) | pub(crate) fn bpf_clone_redirect(
  function bpf_ringbuf_reserve (line 208) | pub(crate) fn bpf_ringbuf_reserve(
  function bpf_ringbuf_output (line 218) | pub(crate) fn bpf_ringbuf_output(
  function bpf_ringbuf_submit (line 226) | pub(crate) fn bpf_ringbuf_submit(data: *mut (), flags: u64);
  function bpf_ringbuf_discard (line 229) | pub(crate) fn bpf_ringbuf_discard(data: *mut (), flags: u64);
  function bpf_ringbuf_query (line 232) | pub(crate) fn bpf_ringbuf_query(ringbuf: *mut (), flags: u64) -> u64;
  function rex_trace_printk (line 235) | pub(crate) fn rex_trace_printk();
  function bpf_task_from_pid (line 238) | pub(crate) fn bpf_task_from_pid(pid: i32) -> *mut task_struct;
  function bpf_task_release (line 241) | pub(crate) fn bpf_task_release(task: *mut task_struct);

FILE: rex/src/kprobe/kprobe_impl.rs
  type kprobe (line 9) | pub struct kprobe {
    method new (line 16) | pub const unsafe fn new() -> kprobe {
    method convert_ctx (line 26) | pub unsafe fn convert_ctx(&self, ctx: *mut ()) -> &'static mut PtRegs {
    method bpf_override_return (line 34) | pub fn bpf_override_return(&self, regs: &mut PtRegs, rc: u64) -> i32 {
    method bpf_get_current_task (line 40) | pub fn bpf_get_current_task(&self) -> Option<TaskStruct> {

FILE: rex/src/log.rs
  type LogBuf (line 10) | pub(crate) struct LogBuf {
    method new (line 17) | pub(crate) fn new() -> Self {
    method reset (line 27) | pub(crate) fn reset(&mut self) {
  method write_str (line 34) | fn write_str(&mut self, s: &str) -> fmt::Result {
  function rex_trace_printk (line 69) | pub fn rex_trace_printk(args: fmt::Arguments<'_>) -> crate::Result {

FILE: rex/src/map.rs
  type RexMapHandle (line 29) | pub struct RexMapHandle<const MT: bpf_map_type, K, V>
  function new (line 52) | pub const fn new(ms: u32, mf: u32) -> RexMapHandle<MT, K, V> {
  type RexStackTrace (line 71) | pub type RexStackTrace<K, V> = RexMapHandle<BPF_MAP_TYPE_STACK_TRACE, K,...
  type RexPerCPUArrayMap (line 72) | pub type RexPerCPUArrayMap<V> = RexMapHandle<BPF_MAP_TYPE_PERCPU_ARRAY, ...
  type RexPerfEventArray (line 73) | pub type RexPerfEventArray<V> =
  type RexArrayMap (line 75) | pub type RexArrayMap<V> = RexMapHandle<BPF_MAP_TYPE_ARRAY, u32, V>;
  type RexHashMap (line 76) | pub type RexHashMap<K, V> = RexMapHandle<BPF_MAP_TYPE_HASH, K, V>;
  type RexStack (line 77) | pub type RexStack<V> = RexMapHandle<BPF_MAP_TYPE_STACK, (), V>;
  type RexQueue (line 78) | pub type RexQueue<V> = RexMapHandle<BPF_MAP_TYPE_QUEUE, (), V>;
  type RexRingBuf (line 79) | pub type RexRingBuf = RexMapHandle<BPF_MAP_TYPE_RINGBUF, (), ()>;
    method reserve (line 186) | pub fn reserve<'a>(
    method output (line 218) | pub fn output(&'static self, data: &[u8], flags: u64) -> crate::Result {
    method available_bytes (line 237) | pub fn available_bytes(&'static self) -> Option<u64> {
    method size (line 251) | pub fn size(&'static self) -> Option<u64> {
    method consumer_position (line 265) | pub fn consumer_position(&'static self) -> Option<u64> {
    method producer_position (line 279) | pub fn producer_position(&'static self) -> Option<u64> {
  function insert (line 85) | pub fn insert(&'static self, key: &K, value: &V) -> Result {
  function insert_new (line 89) | pub fn insert_new(&'static self, key: &K, value: &V) -> Result {
  function update (line 93) | pub fn update(&'static self, key: &K, value: &V) -> Result {
  function get_mut (line 97) | pub fn get_mut(&'static self, key: &'a K) -> Option<&'a mut V> {
  function delete (line 101) | pub fn delete(&'static self, key: &K) -> Result {
  function insert (line 110) | pub fn insert(&'static self, key: &u32, value: &V) -> Result {
  function get_mut (line 114) | pub fn get_mut(&'static self, key: &'a u32) -> Option<&'a mut V> {
  function delete (line 118) | pub fn delete(&'static self, key: &u32) -> Result {
  function output (line 127) | pub fn output<P: PerfEventStreamer>(
  function push (line 142) | pub fn push(&'static self, value: &V) -> Result {
  function force_push (line 146) | pub fn force_push(&'static self, value: &V) -> Result {
  function pop (line 150) | pub fn pop(&'static self) -> Option<V> {
  function peek (line 154) | pub fn peek(&'static self) -> Option<V> {
  function push (line 163) | pub fn push(&'static self, value: &V) -> Result {
  function force_push (line 167) | pub fn force_push(&'static self, value: &V) -> Result {
  function pop (line 171) | pub fn pop(&'static self) -> Option<V> {
  function peek (line 175) | pub fn peek(&'static self) -> Option<V> {
  type RexRingBufEntry (line 291) | pub struct RexRingBufEntry<'a> {
  function submit (line 307) | pub fn submit(self, flags: u64) {
  function discard (line 325) | pub fn discard(self, flags: u64) {
  method write_str (line 335) | fn write_str(&mut self, s: &str) -> fmt::Result {
  type Target (line 359) | type Target = [u8];
  method deref (line 361) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 367) | fn deref_mut(&mut self) -> &mut Self::Target {
  function drop (line 374) | fn drop(&mut self) {

FILE: rex/src/panic.rs
  constant ENTRIES_SIZE (line 11) | pub(crate) const ENTRIES_SIZE: usize = 64;
  type CleanupFn (line 13) | pub(crate) type CleanupFn = unsafe fn(*mut ()) -> ();
  type CleanupEntry (line 24) | pub(crate) struct CleanupEntry {
    method new (line 33) | pub(crate) fn new(cleanup_fn: CleanupFn, cleanup_arg: *mut ()) -> Self {
    method cleanup (line 43) | pub(crate) unsafe fn cleanup(&self) {
  method default (line 57) | fn default() -> Self {
  type CleanupEntries (line 68) | pub(crate) struct CleanupEntries<'a> {
  function this_cpu_cleanup_entries (line 75) | fn this_cpu_cleanup_entries() -> CleanupEntries<'a> {
  function find_next_emtpy_entry (line 90) | fn find_next_emtpy_entry(&mut self) -> (usize, &mut CleanupEntry) {
  function register_cleanup (line 102) | pub(crate) fn register_cleanup(
  function deregister_cleanup (line 114) | pub(crate) fn deregister_cleanup(idx: usize) {
  function cleanup_all (line 121) | pub(crate) unsafe fn cleanup_all() {
  function __rex_check_stack (line 141) | unsafe fn __rex_check_stack() {
  function __rex_handle_timeout (line 159) | pub(crate) unsafe fn __rex_handle_timeout() -> ! {
  function __rex_handle_stack_overflow (line 164) | unsafe fn __rex_handle_stack_overflow() -> ! {
  function panic (line 170) | fn panic(info: &PanicInfo) -> ! {

FILE: rex/src/per_cpu.rs
  type PerCPURead (line 3) | pub(crate) trait PerCPURead {
    method this_cpu_read (line 4) | unsafe fn this_cpu_read(addr: *const Self) -> Self;
  function this_cpu_read (line 102) | pub(crate) unsafe fn this_cpu_read<T: PerCPURead>(pcp_addr: *const T) ->...
  function this_cpu_ptr (line 110) | pub unsafe fn this_cpu_ptr<T>(pcp_addr: *const T) -> *const T {
  function this_cpu_ptr_mut (line 117) | pub unsafe fn this_cpu_ptr_mut<T>(pcp_addr: *mut T) -> *mut T {

FILE: rex/src/perf_event/perf_event_impl.rs
  type bpf_perf_event_data (line 15) | pub struct bpf_perf_event_data {
    method regs (line 21) | pub fn regs(&self) -> &PtRegs {
    method sample_period (line 26) | pub fn sample_period(&self) -> u64 {
    method addr (line 31) | pub fn addr(&self) -> u64 {
  type perf_event (line 37) | pub struct perf_event {
    method new (line 44) | pub const unsafe fn new() -> perf_event {
    method convert_ctx (line 50) | pub unsafe fn convert_ctx(
    method bpf_perf_prog_read_value (line 57) | pub fn bpf_perf_prog_read_value(
    method bpf_get_stackid_pe (line 71) | pub fn bpf_get_stackid_pe<K, V>(
    method bpf_get_current_task (line 93) | pub fn bpf_get_current_task(&self) -> Option<TaskStruct> {

FILE: rex/src/pt_regs.rs
  type PtRegs (line 8) | pub struct PtRegs {
    method orig_rax (line 51) | pub fn orig_rax(&self) -> u64 {
    method cs (line 56) | pub fn cs(&self) -> u64 {
    method eflags (line 61) | pub fn eflags(&self) -> u64 {
    method ss (line 66) | pub fn ss(&self) -> u64 {

FILE: rex/src/random32.rs
  function bpf_user_rnd_u32 (line 5) | pub(crate) fn bpf_user_rnd_u32() -> u32 {

FILE: rex/src/sched_cls/sched_cls_impl.rs
  type __sk_buff (line 16) | pub struct __sk_buff<'a> {
  function len (line 25) | pub fn len(&self) -> u32 {
  function data_len (line 30) | pub fn data_len(&self) -> u32 {
  function protocol (line 35) | pub fn protocol(&self) -> u16be {
  function priority (line 44) | pub fn priority(&self) -> u32 {
  function ingress_ifindex (line 54) | pub fn ingress_ifindex(&self) -> u32 {
  function ifindex (line 59) | pub fn ifindex(&self) -> u32 {
  function hash (line 72) | pub fn hash(&self) -> u32 {
  function mark (line 78) | pub fn mark(&self) -> u32 {
  function pkt_type (line 84) | pub fn pkt_type(&self) -> u32 {
  function queue_mapping (line 90) | pub fn queue_mapping(&self) -> u16 {
  function vlan_present (line 96) | pub fn vlan_present(&self) -> u32 {
  function vlan_tci (line 102) | pub fn vlan_tci(&self) -> u16 {
  function vlan_proto (line 115) | pub fn vlan_proto(&self) -> u16be {
  function cb (line 128) | pub fn cb(&self) -> [c_char; 20] {
  function tc_classid (line 136) | pub fn tc_classid(&self) -> u32 {
  function tc_index (line 141) | pub fn tc_index(&self) -> u16 {
  function napi_id (line 151) | pub fn napi_id(&self) -> u32 {
  function data_meta (line 157) | pub fn data_meta(&self) -> u32 {
  function sk (line 162) | pub fn sk(&self) -> &'a sock {
  type sched_cls (line 168) | pub struct sched_cls {
    method new (line 175) | pub const unsafe fn new() -> sched_cls {
    method eth_header (line 183) | pub fn eth_header<'b>(
    method udp_header (line 193) | pub fn udp_header<'b>(
    method tcp_header (line 205) | pub fn tcp_header<'b>(
    method ip_header (line 217) | pub fn ip_header<'b>(
    method bpf_clone_redirect (line 229) | pub fn bpf_clone_redirect(
    method convert_ctx (line 259) | pub unsafe fn convert_ctx(&self, ctx: *mut ()) -> __sk_buff<'_> {

FILE: rex/src/spinlock.rs
  type rex_spinlock_guard (line 12) | pub struct rex_spinlock_guard<'a> {
  function new (line 19) | pub fn new(lock: &'a mut bpf_spin_lock) -> Self {
  function panic_cleanup (line 36) | pub(crate) unsafe fn panic_cleanup(lock: *mut ()) {
  method drop (line 45) | fn drop(&mut self) {

FILE: rex/src/task_struct.rs
  constant TOP_OF_KERNEL_STACK_PADDING (line 12) | const TOP_OF_KERNEL_STACK_PADDING: u64 = 0;
  constant PAGE_SHIFT (line 13) | const PAGE_SHIFT: u64 = 12;
  constant PAGE_SIZE (line 14) | const PAGE_SIZE: u64 = 1u64 << PAGE_SHIFT;
  constant THREAD_SIZE_ORDER (line 15) | const THREAD_SIZE_ORDER: u64 = 2;
  constant THREAD_SIZE (line 16) | const THREAD_SIZE: u64 = PAGE_SIZE << THREAD_SIZE_ORDER;
  type TaskStruct (line 18) | pub struct TaskStruct {
    method get_current_task (line 26) | pub(crate) fn get_current_task() -> Option<Self> {
    method get_pid (line 41) | pub fn get_pid(&self) -> i32 {
    method get_tgid (line 46) | pub fn get_tgid(&self) -> i32 {
    method get_utime (line 51) | pub fn get_utime(&self) -> u64 {
    method get_comm (line 58) | pub fn get_comm(&self) -> Result<&CStr, core_ffi::FromBytesUntilNulErr...
    method get_pt_regs (line 66) | pub fn get_pt_regs(&self) -> &'static PtRegs {
  type OwnedTaskStruct (line 78) | pub struct OwnedTaskStruct {
    method from_pid (line 84) | pub fn from_pid(pid: i32) -> Option<Self> {
    method panic_cleanup (line 107) | pub(crate) unsafe fn panic_cleanup(task: *mut ()) {
  type Target (line 115) | type Target = TaskStruct;
  method deref (line 117) | fn deref(&self) -> &Self::Target {
  method drop (line 123) | fn drop(&mut self) {

FILE: rex/src/tracepoint/binding.rs
  type SyscallsEnterOpenCtx (line 3) | pub struct SyscallsEnterOpenCtx {
  type SyscallsEnterOpenatCtx (line 13) | pub struct SyscallsEnterOpenatCtx {
  type SyscallsExitOpenCtx (line 24) | pub struct SyscallsExitOpenCtx {
  type SyscallsExitOpenatCtx (line 32) | pub struct SyscallsExitOpenatCtx {
  type SyscallsEnterDupCtx (line 40) | pub struct SyscallsEnterDupCtx {
  type RawSyscallsEnterCtx (line 48) | pub struct RawSyscallsEnterCtx {
  type RawSyscallsExitCtx (line 56) | pub struct RawSyscallsExitCtx {

FILE: rex/src/tracepoint/tp_impl.rs
  type TracepointContext (line 16) | pub trait TracepointContext {}
  type tracepoint (line 26) | pub struct tracepoint<C: TracepointContext + 'static> {
  function new (line 33) | pub const unsafe fn new() -> tracepoint<C> {
  function convert_ctx (line 39) | pub unsafe fn convert_ctx(&self, ctx: *mut ()) -> &'static C {
  function bpf_get_current_task (line 43) | pub fn bpf_get_current_task(&self) -> Option<TaskStruct> {
  type Context (line 51) | type Context = C;
  method output_event (line 53) | fn output_event<T: Copy + NoRef>(

FILE: rex/src/utils.rs
  type u16be (line 10) | pub struct u16be(pub(crate) u16);
  function from (line 14) | fn from(value: u16be) -> Self {
  type Result (line 24) | pub type Result = core::result::Result<c_int, c_int>;
  type NoRef (line 53) | pub unsafe auto trait NoRef {}
  type AlignedInner (line 63) | enum AlignedInner<RefT, ValT> {
  type Aligned (line 76) | pub struct Aligned<'a, T> {
  function from_ref (line 83) | pub(crate) const fn from_ref(aligned_ref: &'a T) -> Self {
  function from_val (line 92) | pub(crate) const fn from_val(copied_val: T) -> Self {
  type Target (line 102) | type Target = T;
  method deref (line 108) | fn deref(&self) -> &Self::Target {
  type AlignedMut (line 125) | pub struct AlignedMut<'a, T: Copy> {
  function from_ref (line 132) | pub(crate) const fn from_ref(aligned_ref: &'a mut T) -> Self {
  function from_val (line 141) | pub(crate) const fn from_val(
  type Target (line 154) | type Target = T;
  method deref (line 160) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 175) | fn deref_mut(&mut self) -> &mut Self::Target {
  method drop (line 186) | fn drop(&mut self) {
  function convert_slice_to_struct (line 211) | pub fn convert_slice_to_struct<T>(slice: &[c_uchar]) -> Aligned<'_, T>
  function convert_slice_to_struct_mut (line 245) | pub fn convert_slice_to_struct_mut<T>(
  type PerfEventStreamerBase (line 294) | pub trait PerfEventStreamerBase {}
  type PerfEventStreamer (line 301) | pub trait PerfEventStreamer: sealed::PerfEventStreamerBase {
    method output_event (line 303) | fn output_event<T: Copy + NoRef>(
  type PerfEventMaskedCPU (line 316) | pub struct PerfEventMaskedCPU {
    method current_cpu (line 321) | pub fn current_cpu() -> Self {
    method any_cpu (line 327) | pub fn any_cpu(cpu: u64) -> Self {

FILE: rex/src/xdp/xdp_impl.rs
  method saddr (line 21) | pub fn saddr(&mut self) -> &mut u32 {
  method daddr (line 25) | pub fn daddr(&mut self) -> &mut u32 {
  function compute_ip_checksum (line 31) | pub fn compute_ip_checksum(ip_header: &mut iphdr) -> u16 {
  type xdp_md (line 49) | pub struct xdp_md<'a> {
  function data_length (line 57) | pub fn data_length(&self) -> usize {
  function data_meta (line 62) | pub fn data_meta(&self) -> usize {
  function ingress_ifindex (line 67) | pub fn ingress_ifindex(&self) -> u32 {
  function rx_qeueu_index (line 72) | pub fn rx_qeueu_index(&self) -> u32 {
  function egress_ifindex (line 77) | pub fn egress_ifindex(&self) -> u32 {
  type xdp (line 85) | pub struct xdp {
    method new (line 92) | pub const unsafe fn new() -> xdp {
    method convert_ctx (line 103) | pub unsafe fn convert_ctx(&self, ctx: *mut ()) -> xdp_md<'_> {
    method tcp_header (line 117) | pub fn tcp_header<'b>(
    method udp_header (line 129) | pub fn udp_header<'b>(
    method ip_header (line 141) | pub fn ip_header<'b>(&self, ctx: &'b mut xdp_md) -> AlignedMut<'b, iph...
    method eth_header (line 150) | pub fn eth_header<'b>(
    method bpf_xdp_adjust_tail (line 166) | pub fn bpf_xdp_adjust_tail(&self, ctx: &mut xdp_md, offset: i32) -> Re...

FILE: samples/atomic/event-trigger.c
  function main (line 7) | int main(int argc, char *argv[])

FILE: samples/atomic/loader.c
  function main (line 16) | int main(void)

FILE: samples/atomic/src/main.rs
  function rex_prog1 (line 14) | fn rex_prog1(obj: &kprobe, _ctx: &mut PtRegs) -> Result {

FILE: samples/bmc/entry.c
  type bpf_progs_desc (line 26) | struct bpf_progs_desc {
  type bmc_stats (line 34) | struct bmc_stats {
  function libbpf_print_fn (line 48) | static int libbpf_print_fn(enum libbpf_print_level level, const char *fo...
  function write_stats_to_file (line 57) | int write_stats_to_file(char *filename, int map_fd)
  function main (line 102) | int main(int argc, char *argv[])

FILE: samples/bmc/src/main.rs
  constant BMC_MAX_PACKET_LENGTH (line 14) | const BMC_MAX_PACKET_LENGTH: usize = 1500;
  constant BMC_CACHE_ENTRY_COUNT (line 15) | const BMC_CACHE_ENTRY_COUNT: u32 = 3250000;
  constant BMC_MAX_KEY_LENGTH (line 16) | const BMC_MAX_KEY_LENGTH: usize = 230;
  constant BMC_MAX_VAL_LENGTH (line 17) | const BMC_MAX_VAL_LENGTH: usize = 1000;
  constant BMC_MAX_ADDITIONAL_PAYLOAD_BYTES (line 18) | const BMC_MAX_ADDITIONAL_PAYLOAD_BYTES: usize = 53;
  constant BMC_MAX_CACHE_DATA_SIZE (line 19) | const BMC_MAX_CACHE_DATA_SIZE: usize =
  constant BMC_MAX_KEY_IN_PACKET (line 21) | const BMC_MAX_KEY_IN_PACKET: u32 = 30;
  constant FNV_OFFSET_BASIS_32 (line 23) | const FNV_OFFSET_BASIS_32: u32 = 2166136261;
  constant FNV_PRIME_32 (line 24) | const FNV_PRIME_32: u32 = 16777619;
  constant ETH_ALEN (line 25) | const ETH_ALEN: usize = 6;
  constant MEMCACHED_PORT (line 26) | const MEMCACHED_PORT: u16 = 11211;
  type memcached_udp_header (line 29) | pub struct memcached_udp_header {
  type bmc_cache_entry (line 38) | pub struct bmc_cache_entry {
  type memcached_key (line 48) | struct memcached_key {
  type bmc_stats (line 56) | pub struct bmc_stats {
  type parsing_context (line 68) | struct parsing_context {
  function hash_key (line 102) | fn hash_key(
  function write_pkt_reply (line 189) | fn write_pkt_reply(
  function bmc_invalidate_cache (line 278) | fn bmc_invalidate_cache(obj: &xdp, ctx: &mut xdp_md) -> Result {
  function xdp_rx_filter (line 332) | fn xdp_rx_filter(obj: &xdp, ctx: &mut xdp_md) -> Result {
  function bmc_update_cache (line 395) | fn bmc_update_cache(
  function xdp_tx_filter (line 469) | fn xdp_tx_filter(obj: &sched_cls, skb: &mut __sk_buff) -> Result {

FILE: samples/electrode/entry.c
  type bpf_progs_desc (line 25) | struct bpf_progs_desc {
  type bpf_object (line 33) | struct bpf_object
  type bpf_object_load_attr (line 34) | struct bpf_object_load_attr
  type bpf_program (line 35) | struct bpf_program
  type rlimit (line 44) | struct rlimit
  type bpf_progs_desc (line 52) | struct bpf_progs_desc
  function libbpf_print_fn (line 57) | static int libbpf_print_fn(enum libbpf_print_level level, const char *fo...
  function read_config (line 66) | static void read_config(void)
  function create_object (line 121) | static void create_object(void)
  function add_interrupt (line 146) | static void add_interrupt(void)
  function main (line 188) | int main(int argc, char *argv[])

FILE: samples/electrode/fast_common.h
  type ReplicaStatus (line 33) | enum ReplicaStatus { STATUS_NORMAL, STATUS_VIEW_CHANGE, STATUS_RECOVERING }
  type paxos_configure (line 51) | struct paxos_configure {

FILE: samples/electrode/src/common.rs
  constant ETH_ALEN (line 14) | pub(crate) const ETH_ALEN: usize = 6;
  constant MTU (line 15) | pub(crate) const MTU: u64 = 1500;
  constant MAX_DATA_LEN (line 16) | pub(crate) const MAX_DATA_LEN: usize = 64;
  constant CLUSTER_SIZE (line 18) | pub(crate) const CLUSTER_SIZE: u8 = 3;
  constant FAST_REPLICA_MAX (line 19) | pub(crate) const FAST_REPLICA_MAX: u32 = 100;
  constant NONFRAG_MAGIC (line 20) | pub(crate) const NONFRAG_MAGIC: u32 = 0x20050318;
  constant FRAG_MAGIC (line 21) | pub(crate) const FRAG_MAGIC: u32 = 0x20101010;
  constant MAGIC_LEN (line 23) | pub(crate) const MAGIC_LEN: usize = 4;
  constant REQUEST_TYPE_LEN (line 24) | pub(crate) const REQUEST_TYPE_LEN: usize = 33;
  constant PREPARE_TYPE_LEN (line 25) | pub(crate) const PREPARE_TYPE_LEN: usize = 33;
  constant PREPAREOK_TYPE_LEN (line 26) | pub(crate) const PREPAREOK_TYPE_LEN: usize = 35;
  constant MYPREPAREOK_TYPE_LEN (line 27) | pub(crate) const MYPREPAREOK_TYPE_LEN: usize = 24;
  constant FAST_PAXOS_DATA_LEN (line 29) | pub(crate) const FAST_PAXOS_DATA_LEN: usize = 12;
  constant BROADCAST_SIGN_BIT (line 30) | pub(crate) const BROADCAST_SIGN_BIT: u32 = 1 << 31;
  constant QUORUM_SIZE (line 31) | pub(crate) const QUORUM_SIZE: u32 = (CLUSTER_SIZE as u32 + 1) >> 1;
  constant QUORUM_BITSET_ENTRY (line 32) | pub(crate) const QUORUM_BITSET_ENTRY: u32 = 1024;
  constant PAXOS_PORT (line 34) | pub(crate) const PAXOS_PORT: u16 = 12345;
  constant MAGIC_BITS (line 35) | pub(crate) const MAGIC_BITS: [u8; MAGIC_LEN] = [0x18, 0x03, 0x05, 0x20];
  type ReplicaStatus (line 39) | pub(crate) enum ReplicaStatus {
  type FastProgXdp (line 47) | pub(crate) enum FastProgXdp {
  type FastProgTc (line 59) | pub(crate) enum FastProgTc {
  type PaxosConfigure (line 66) | pub(crate) struct PaxosConfigure {

FILE: samples/electrode/src/main.rs
  function fast_paxos_main (line 34) | fn fast_paxos_main(obj: &xdp, ctx: &mut xdp_md) -> Result {
  function fast_broad_cast_main (line 81) | fn fast_broad_cast_main(obj: &sched_cls, skb: &mut __sk_buff) -> Result {
  function handle_udp_fast_broad_cast (line 121) | fn handle_udp_fast_broad_cast(obj: &sched_cls, skb: &mut __sk_buff) -> R...
  function handle_udp_fast_paxos (line 235) | fn handle_udp_fast_paxos(obj: &xdp, ctx: &mut xdp_md) -> Result {
  function compute_message_type (line 287) | fn compute_message_type(payload: &[u8]) -> FastProgXdp {
  function handle_prepare (line 320) | fn handle_prepare(obj: &xdp, ctx: &mut xdp_md, payload_index: usize) -> ...
  function write_buffer (line 370) | fn write_buffer(obj: &xdp, ctx: &mut xdp_md, payload_index: usize) -> Re...
  function prepare_fast_reply (line 397) | fn prepare_fast_reply(
  function handle_prepare_ok (line 498) | fn handle_prepare_ok(

FILE: samples/electrode/src/maps.rs
  type paxos_quorum (line 9) | pub(crate) struct paxos_quorum {
  type paxos_ctr_state (line 17) | pub(crate) struct paxos_ctr_state {
  type paxos_batch (line 28) | pub(crate) struct paxos_batch {

FILE: samples/error_injector/loader.c
  function main (line 14) | int main(int argc, char *argv[])

FILE: samples/error_injector/src/main.rs
  function err_injector (line 14) | pub fn err_injector(obj: &kprobe, ctx: &mut PtRegs) -> Result {

FILE: samples/error_injector/tests/runtest.py
  function count_bpf_programs (line 11) | def count_bpf_programs():
  function run_loader (line 37) | def run_loader():
  function capture_output (line 47) | def capture_output() -> bool:
  function main (line 69) | def main():

FILE: samples/error_injector/userapp.c
  function main (line 6) | int main(void)

FILE: samples/hello/event-trigger.c
  function main (line 4) | int main(void)

FILE: samples/hello/loader.c
  function main (line 16) | int main(void)

FILE: samples/hello/src/main.rs
  function rex_prog1 (line 10) | fn rex_prog1(

FILE: samples/hello/tests/runtest.py
  function count_bpf_programs (line 10) | def count_bpf_programs():
  function run_loader (line 36) | def run_loader():
  function trigger_prog (line 46) | def trigger_prog():
  function capture_output (line 53) | def capture_output() -> bool:
  function main (line 79) | def main():

FILE: samples/map_bench/event-trigger.c
  function main (line 7) | int main(int argc, char *argv[])

FILE: samples/map_bench/loader.c
  function main (line 16) | int main(void)

FILE: samples/map_bench/src/main.rs
  function rex_prog1 (line 19) | fn rex_prog1(obj: &kprobe, _ctx: &mut PtRegs) -> Result {

FILE: samples/map_test/event-trigger.c
  function main (line 4) | int main(void)

FILE: samples/map_test/loader.c
  function main (line 16) | int main(void)

FILE: samples/map_test/src/main.rs
  function map_test1 (line 17) | fn map_test1(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function map_test2 (line 65) | fn map_test2(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function rex_prog1 (line 95) | fn rex_prog1(

FILE: samples/map_test/tests/runtest.py
  function count_bpf_programs (line 10) | def count_bpf_programs():
  function run_loader (line 36) | def run_loader():
  function trigger_prog (line 46) | def trigger_prog():
  function capture_output (line 53) | def capture_output() -> bool:
  function main (line 82) | def main():

FILE: samples/map_test_2/event-trigger.c
  function main (line 4) | int main(void)

FILE: samples/map_test_2/loader.c
  function main (line 16) | int main(void)

FILE: samples/map_test_2/src/main.rs
  function map_test_hash (line 28) | fn map_test_hash(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function map_test_array (line 76) | fn map_test_array(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function map_test_stack (line 103) | fn map_test_stack(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function map_test_queue (line 135) | fn map_test_queue(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function map_test_ringbuf (line 168) | fn map_test_ringbuf(obj: &tracepoint<SyscallsEnterDupCtx>) -> Result {
  function rex_prog1 (line 203) | fn rex_prog1(

FILE: samples/map_test_2/tests/runtest.py
  function count_bpf_programs (line 10) | def count_bpf_programs():
  function run_loader (line 36) | def run_loader():
  function trigger_prog (line 46) | def trigger_prog():
  function capture_output (line 53) | def capture_output() -> bool:
  function main (line 91) | def main():

FILE: samples/recursive/event-trigger.c
  function main (line 7) | int main(int argc, char *argv[])

FILE: samples/recursive/loader.c
  function main (line 17) | int main(void)

FILE: samples/recursive/src/main.rs
  function rex_recursive (line 17) | fn rex_recursive(obj: &kprobe, ctx: &mut PtRegs) -> Result {
  function calculate_tail_fib (line 49) | fn calculate_tail_fib(n: u32) {

FILE: samples/spinlock_cleanup_benchmark/loader.c
  function main (line 23) | int main(int __unused argc, char **argv)

FILE: samples/spinlock_cleanup_benchmark/src/main.rs
  type MapEntry (line 14) | struct MapEntry {
  function rex_prog1 (line 23) | fn rex_prog1(obj: &xdp, _: &mut xdp_md) -> Result {

FILE: samples/spinlock_test/event-trigger.c
  function main (line 4) | int main(void)

FILE: samples/spinlock_test/loader.c
  function main (line 15) | int main(void)

FILE: samples/spinlock_test/src/main.rs
  type MapEntry (line 14) | struct MapEntry {
  function test1 (line 22) | fn test1(obj: &tracepoint<SyscallsEnterDupCtx>) {
  function test2 (line 31) | fn test2(obj: &tracepoint<SyscallsEnterDupCtx>) {
  function rex_prog1 (line 42) | fn rex_prog1(

FILE: samples/startup_overhead_benchmark/event-trigger.c
  function main (line 7) | int main(int argc, char *argv[])

FILE: samples/startup_overhead_benchmark/loader.c
  function main (line 16) | int main(void)

FILE: samples/startup_overhead_benchmark/src/main.rs
  function rex_prog1 (line 11) | fn rex_prog1(_obj: &kprobe, _ctx: &mut PtRegs) -> Result {

FILE: samples/syscount/loader.c
  function sig_handler (line 48) | static void sig_handler(int __unused sig)
  type stats_type_t (line 53) | enum stats_type_t { COUNT_ONLY, SHOW_ERRORS, SHOW_LATENCY, SHOW_BOTH }
  function print_header (line 55) | static void print_header(bool timestamp, enum stats_type_t type)
  type options (line 100) | struct options {
  function print_usage (line 111) | static void print_usage(const char *prog_name)
  function parse_options (line 127) | static struct options parse_options(int argc, char *argv[])
  function main (line 188) | int main(int argc, char *argv[])

FILE: samples/syscount/src/main.rs
  function trace_syscall_enter (line 24) | fn trace_syscall_enter(
  function trace_syscall_exit (line 62) | fn trace_syscall_exit(

FILE: samples/xdp_test/entry.c
  type bpf_progs_desc (line 23) | struct bpf_progs_desc {
  function main (line 33) | int main(int argc, char *argv[])

FILE: samples/xdp_test/src/main.rs
  function xdp_rx_filter (line 15) | fn xdp_rx_filter(obj: &xdp, ctx: &mut xdp_md) -> Result {
  function xdp_tx_filter (line 35) | fn xdp_tx_filter(obj: &sched_cls, skb: &mut __sk_buff) -> Result {

FILE: samples/xdp_test/tests/runtest.py
  function count_bpf_programs (line 11) | def count_bpf_programs():
  function generate_traffic (line 35) | def generate_traffic():
  function get_trace_log (line 59) | def get_trace_log():
  function test_xdp_program (line 77) | def test_xdp_program():
  function main (line 165) | def main():

FILE: scripts/sanity_tests/run_tests.py
  function main (line 32) | def main():

FILE: tools/memcached_benchmark/bench.py
  class MemcachedCtx (line 12) | class MemcachedCtx:
    method __init__ (line 13) | def __init__(self, start, stop):
    method __enter__ (line 17) | def __enter__(self):
    method __exit__ (line 20) | def __exit__(self, *args):
  function increase_fd_limit (line 23) | def increase_fd_limit(new_limit):
  function run_bench (line 38) | def run_bench():
  function run_vanilla (line 47) | def run_vanilla(nr_threads):
  function run_bpf (line 59) | def run_bpf(nr_threads):
  function run_rust (line 71) | def run_rust(nr_threads):
  function main (line 83) | def main():

FILE: tools/memcached_benchmark/src/cli.rs
  type Cli (line 7) | pub(crate) struct Cli {
  type Commands (line 13) | pub(crate) enum Commands {

FILE: tools/memcached_benchmark/src/dict.rs
  constant SEED (line 15) | const SEED: u64 = 12312;
  function generate_random_str (line 18) | pub(crate) fn generate_random_str(len: usize) -> String {
  function generate_memcached_test_dict (line 23) | pub(crate) fn generate_memcached_test_dict(
  function generate_test_dict_write_to_disk (line 52) | pub(crate) fn generate_test_dict_write_to_disk(
  function generate_test_entries (line 72) | pub(crate) fn generate_test_entries(
  function test_entries_statistics (line 97) | pub(crate) fn test_entries_statistics(

FILE: tools/memcached_benchmark/src/fs.rs
  function write_hashmap_to_file (line 18) | pub(crate) fn write_hashmap_to_file<T: Serialize>(
  function load_bench_entries_from_disk (line 45) | pub(crate) fn load_bench_entries_from_disk(
  function load_test_dict (line 61) | pub(crate) fn load_test_dict(

FILE: tools/memcached_benchmark/src/get_values.rs
  type Protocol (line 21) | pub(crate) enum Protocol {
  type TaskData (line 26) | struct TaskData {
  function wrap_get_command (line 37) | fn wrap_get_command(key: Arc<String>, seq: u16) -> Vec<u8> {
  function socket_task (line 47) | async fn socket_task(
  function get_command_benchmark (line 119) | pub(crate) async fn get_command_benchmark(

FILE: tools/memcached_benchmark/src/main.rs
  type BenchConfig (line 16) | pub struct BenchConfig {
    method get (line 25) | pub fn get() -> &'static BenchConfig {
  constant BUFFER_SIZE (line 47) | const BUFFER_SIZE: usize = 1500;
  constant BENCH_ENTRIES_PATH (line 48) | const BENCH_ENTRIES_PATH: &str = "bench_entries.yml.zst";
  function get_server (line 52) | fn get_server(
  function run_bench (line 69) | fn run_bench() -> Result<()> {
  function main (line 278) | fn main() -> Result<()> {

FILE: tools/memcached_benchmark/src/set_values.rs
  function set_memcached_value (line 12) | pub(super) async fn set_memcached_value(

FILE: tools/memcached_benchmark/tests/benchmark_test.rs
  type ProcessGuard (line 12) | struct ProcessGuard {
  method drop (line 17) | fn drop(&mut self) {
  function test_memcached_benchmark (line 24) | fn test_memcached_benchmark() -> Result<()> {