coredump: enable cgo warnings (open-telemetry#613)

Author: korniltsev

support/ebpf/Makefile

@@ -39,7 +39,6 @@ FLAGS=$(TARGET_FLAGS) -g \
 	-Wall -Wextra -Werror \
 	-Wno-address-of-packed-member \
 	-Wno-unused-label \
-	-Wno-unused-parameter \
 	-Wno-sign-compare \
 	-fno-stack-protector \
 	-D__SOURCE_DATE_EPOCH__=0 \
@@ -81,7 +80,7 @@ bloatcheck: $(TRACER_NAME)
 	python3 bloat-o-meter $(TRACER_NAME).baseline $(TRACER_NAME)
 
 lint:
-	$(CLANG_FORMAT) -Werror --dry-run -style=file *.[ch]
+	$(CLANG_FORMAT) -Werror --dry-run -style=file *.[ch] ../../tools/coredump/*.[ch]
 
 format:
 	$(CLANG_FORMAT) -i -style=file *.[ch]

support/ebpf/bpfdefs.h

@@ -7,6 +7,10 @@
 // with_debug_output is declared in native_stack_trace.ebpf.c
 extern u32 with_debug_output;
 
+// UNUSED is a macro that marks a parameter or variable as intentionally unused.
+// It prevents compiler warnings about unused variables while keeping them in the code.
+#define UNUSED __attribute__((unused))
+
 #if defined(TESTING_COREDUMP)
 
   // BPF_RODATA_VAR declares a global variable in the .rodata section,
@@ -26,6 +30,9 @@ extern u32 with_debug_output;
   #define printt(fmt, ...)      bpf_log(fmt, ##__VA_ARGS__)
   #define DEBUG_PRINT(fmt, ...) bpf_log(fmt, ##__VA_ARGS__)
 
+  // Macro for loop unrolling. Expands to nothing for TESTING_COREDUMP.
+  #define UNROLL
+
 // BPF helpers. Mostly stubs to dispatch the call to Go code with the context ID.
 int bpf_tail_call(void *ctx, bpf_map_def *map, int index);
 unsigned long long bpf_ktime_get_ns(void);
@@ -37,7 +44,7 @@ static inline long bpf_probe_read_user(void *buf, u32 sz, const void *ptr)
   return __bpf_probe_read_user(__cgo_ctx->id, buf, sz, ptr);
 }
 
-static inline long bpf_probe_read_kernel(void *buf, u32 sz, const void *ptr)
+static inline long bpf_probe_read_kernel(UNUSED void *buf, UNUSED u32 sz, UNUSED const void *ptr)
 {
   return -1;
 }
@@ -53,23 +60,29 @@ static inline void *bpf_map_lookup_elem(bpf_map_def *map, const void *key)
   return __bpf_map_lookup_elem(__cgo_ctx->id, map, key);
 }
 
-static inline int bpf_map_update_elem(bpf_map_def *map, const void *key, const void *val, u64 flags)
+static inline int bpf_map_update_elem(
+  UNUSED bpf_map_def *map, UNUSED const void *key, UNUSED const void *val, UNUSED u64 flags)
 {
   return -1;
 }
 
-static inline int bpf_map_delete_elem(bpf_map_def *map, const void *key)
+static inline int bpf_map_delete_elem(UNUSED bpf_map_def *map, UNUSED const void *key)
 {
   return -1;
 }
 
 static inline int bpf_perf_event_output(
-  void *ctx, bpf_map_def *mapdef, unsigned long long flags, void *data, int size)
+  UNUSED void *ctx,
+  UNUSED bpf_map_def *mapdef,
+  UNUSED unsigned long long flags,
+  UNUSED void *data,
+  UNUSED int size)
 {
+
   return 0;
 }
 
-static inline int bpf_get_stackid(void *ctx, bpf_map_def *map, u64 flags)
+static inline int bpf_get_stackid(UNUSED void *ctx, UNUSED bpf_map_def *map, UNUSED u64 flags)
 {
   return -1;
 }
@@ -168,6 +181,15 @@ static long (*bpf_probe_read_kernel)(void *dst, int size, const void *unsafe_ptr
       __attribute__((section(name), used)) _Pragma("GCC diagnostic pop")
   #define EBPF_INLINE __attribute__((__always_inline__))
 
+  #if defined(__clang__)
+    // Macro for loop unrolling. Expands to the appropriate pragma for clang.
+    // Unrolls up to 256 loop iterations.
+    #define UNROLL _Pragma("unroll 256")
+  #else
+    // Macro for loop unrolling. Expands to nothing for gcc.
+    #define UNROLL
+  #endif
+
 #endif // !TESTING_COREDUMP
 
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))

support/ebpf/dotnet_tracer.ebpf.c

@@ -44,8 +44,7 @@ bpf_map_def SEC("maps") dotnet_procs = {
 // currently not Garbage Collected by the runtime. Though, we have submitted also an enhancement
 // request to fix the nibble map format to something sane, and this might get implemented.
 // see: https://github.com/dotnet/runtime/issues/93550
-static EBPF_INLINE ErrorCode
-dotnet_find_code_start(PerCPURecord *record, DotnetProcInfo *vi, u64 pc, u64 *code_start)
+static EBPF_INLINE ErrorCode dotnet_find_code_start(PerCPURecord *record, u64 pc, u64 *code_start)
 {
   // This is an ebpf optimized implementation of EEJitManager::FindMethodCode()
   // https://github.com/dotnet/runtime/blob/v7.0.15/src/coreclr/vm/codeman.cpp#L4115
@@ -107,11 +106,12 @@ dotnet_find_code_start(PerCPURecord *record, DotnetProcInfo *vi, u64 pc, u64 *co
       // convert it from u32 to u64 offset
       int pos64 = (map_elements - 2) / 2;
       u64 val64 = scratch->map64[--pos64];
-#pragma unroll 256
+
       // the loop iterations is number of u64 elements minus two:
       // - the last element special handled earlier
       // - the second last element which is preloaded immediately above
-      for (int i = 0; i < map_elements / 2 - 2; i++) {
+      UNROLL for (int i = 0; i < map_elements / 2 - 2; i++)
+      {
         if (val64 != 0) {
           break;
         }
@@ -146,8 +146,8 @@ dotnet_find_code_start(PerCPURecord *record, DotnetProcInfo *vi, u64 pc, u64 *co
   }
 
   // Decode the code start info from the entry
-#pragma unroll
-  for (int i = 0; i < DOTNET_CODE_NIBBLES_PER_ENTRY; i++) {
+  UNROLL for (int i = 0; i < DOTNET_CODE_NIBBLES_PER_ENTRY; i++)
+  {
     u8 nybble = val & 0xf;
     if (nybble != 0) {
       *code_start = pc_base + pc_delta + (nybble - 1) * DOTNET_CODE_ALIGN;
@@ -177,8 +177,7 @@ push_dotnet(Trace *trace, u64 code_header_ptr, u64 pc_offset, bool return_addres
 }
 
 // Unwind one dotnet frame
-static EBPF_INLINE ErrorCode
-unwind_one_dotnet_frame(PerCPURecord *record, DotnetProcInfo *vi, bool top)
+static EBPF_INLINE ErrorCode unwind_one_dotnet_frame(PerCPURecord *record)
 {
   UnwindState *state = &record->state;
   Trace *trace       = &record->trace;
@@ -241,7 +240,7 @@ unwind_one_dotnet_frame(PerCPURecord *record, DotnetProcInfo *vi, bool top)
   }
 
   // JIT generated code, locate code start
-  ErrorCode error = dotnet_find_code_start(record, vi, pc, &code_start);
+  ErrorCode error = dotnet_find_code_start(record, pc, &code_start);
   if (error != ERR_OK) {
     DEBUG_PRINT("dotnet:  --> code_start failed with %d", error);
     // dotnet_find_code_start incremented the metric already
@@ -305,11 +304,11 @@ static EBPF_INLINE int unwind_dotnet(struct pt_regs *ctx)
   record->ratelimitAction = RATELIMIT_ACTION_FAST;
   increment_metric(metricID_UnwindDotnetAttempts);
 
-#pragma unroll
-  for (int i = 0; i < DOTNET_FRAMES_PER_PROGRAM; i++) {
+  UNROLL for (int i = 0; i < DOTNET_FRAMES_PER_PROGRAM; i++)
+  {
     unwinder = PROG_UNWIND_STOP;
 
-    error = unwind_one_dotnet_frame(record, vi, i == 0);
+    error = unwind_one_dotnet_frame(record);
     if (error) {
       break;
     }

support/ebpf/hotspot_tracer.ebpf.c

@@ -161,8 +161,8 @@ static EBPF_INLINE u64 hotspot_find_codeblob(const UnwindState *state, const Hot
   // Segment map start is put in to the PidPageMapping's file_id.
   segmap_start = (state->text_section_id >> HS_TSID_SEG_MAP_BIT) & HS_TSID_SEG_MAP_MASK;
 
-#pragma unroll
-  for (int i = 0; i < HOTSPOT_SEGMAP_ITERATIONS; i++) {
+  UNROLL for (int i = 0; i < HOTSPOT_SEGMAP_ITERATIONS; i++)
+  {
     if (bpf_probe_read_user(&tag, sizeof(tag), (void *)(segmap_start + segment))) {
       return 0;
     }
@@ -304,7 +304,7 @@ static EBPF_INLINE ErrorCode hotspot_handle_interpreter(
 }
 
 #if defined(__x86_64__)
-static EBPF_INLINE void breadcrumb_fixup(HotspotUnwindInfo *ui)
+static EBPF_INLINE void breadcrumb_fixup(UNUSED HotspotUnwindInfo *ui)
 {
   // Nothing to do: breadcrumbs are not a thing on X86.
 }
@@ -411,8 +411,8 @@ hotspot_handle_prologue(const CodeBlobInfo *cbi, HotspotUnwindInfo *ui, HotspotU
 #endif
 
 #if defined(__x86_64__)
-static EBPF_INLINE bool
-hotspot_handle_epilogue(const CodeBlobInfo *cbi, HotspotUnwindInfo *ui, HotspotUnwindAction *action)
+static EBPF_INLINE bool hotspot_handle_epilogue(
+  UNUSED const CodeBlobInfo *cbi, HotspotUnwindInfo *ui, HotspotUnwindAction *action)
 {
   // On X86, use a heuristic to catch the likely spots of the epilogue.
   #define CODE_CUR 1
@@ -431,8 +431,8 @@ hotspot_handle_epilogue(const CodeBlobInfo *cbi, HotspotUnwindInfo *ui, HotspotU
   // Is 'ret' instruction *possible* in the next 'code' bytes?
   // NOTE: This can find false positives because x86 is variable length
   // instruction set.
-  #pragma unroll
-  for (int i = CODE_CUR + 1; i < sizeof(code); i++) {
+  UNROLL for (int i = CODE_CUR + 1; i < sizeof(code); i++)
+  {
     if (code[i] == 0xc3) {
       goto found_ret;
     }
@@ -530,8 +530,8 @@ hotspot_handle_epilogue(const CodeBlobInfo *cbi, HotspotUnwindInfo *ui, HotspotU
     return false;
   }
 
-  #pragma unroll
-  for (; find_offset < EPI_LOOKBACK - 1; ++find_offset) {
+  UNROLL for (; find_offset < EPI_LOOKBACK - 1; ++find_offset)
+  {
     if (*(u64 *)&window[find_offset] == needle) {
       goto pattern_found;
     }
@@ -574,7 +574,7 @@ pattern_found:;
 
 static EBPF_INLINE ErrorCode hotspot_handle_nmethod(
   const CodeBlobInfo *cbi,
-  Trace *trace,
+  UNUSED Trace *trace,
   HotspotUnwindInfo *ui,
   HotspotProcInfo *ji,
   HotspotUnwindAction *action,
@@ -697,7 +697,7 @@ hotspot_handle_stub_fallback(const CodeBlobInfo *cbi, HotspotUnwindAction *actio
 }
 
 static EBPF_INLINE ErrorCode hotspot_handle_stub(
-  const UnwindState *state,
+  UNUSED const UnwindState *state,
   const CodeBlobInfo *cbi,
   HotspotUnwindInfo *ui,
   HotspotUnwindAction *action)
@@ -940,8 +940,8 @@ static EBPF_INLINE int unwind_hotspot(struct pt_regs *ctx)
 
   int unwinder    = PROG_UNWIND_STOP;
   ErrorCode error = ERR_OK;
-#pragma unroll
-  for (int i = 0; i < HOTSPOT_FRAMES_PER_PROGRAM; i++) {
+  UNROLL for (int i = 0; i < HOTSPOT_FRAMES_PER_PROGRAM; i++)
+  {
     unwinder = PROG_UNWIND_STOP;
     error    = hotspot_unwind_one_frame(record, ji, i == 0);
     if (error) {

support/ebpf/integration_test.ebpf.c

@@ -68,8 +68,8 @@ static EBPF_INLINE void send_sample_traces(void *ctx, u64 pid, s32 kstack)
   trace->comm[3]         = 4;
   trace->stack_len       = MAX_FRAME_UNWINDS;
   trace->kernel_stack_id = kstack;
-#pragma unroll
-  for (u64 i = 0; i < MAX_FRAME_UNWINDS; ++i) {
+  UNROLL for (u64 i = 0; i < MAX_FRAME_UNWINDS; ++i)
+  {
     // NOTE: this init schema eats up a lot of instructions. If we need more
     // space later, we can instead just init `.kind` and a few fields in the
     // start, middle, and end of the trace.

support/ebpf/interpreter_dispatcher.ebpf.c

@@ -140,7 +140,8 @@ bpf_map_def SEC("maps") cl_procs = {
   .max_entries = 128,
 };
 
-static EBPF_INLINE void *get_m_ptr_legacy(struct GoCustomLabelsOffsets *offs, UnwindState *state)
+static EBPF_INLINE void *
+get_m_ptr_legacy(struct GoCustomLabelsOffsets *offs, UNUSED UnwindState *state)
 {
   long res;
 
@@ -174,7 +175,7 @@ static EBPF_INLINE void *get_m_ptr_legacy(struct GoCustomLabelsOffsets *offs, Un
   return m_ptr_addr;
 }
 
-static EBPF_INLINE void *get_m_ptr(struct GoLabelsOffsets *offs, UnwindState *state)
+static EBPF_INLINE void *get_m_ptr(struct GoLabelsOffsets *offs, UNUSED UnwindState *state)
 {
   u64 g_addr     = 0;
   void *tls_base = NULL;

support/ebpf/luajit_tracer.ebpf.c

@@ -393,7 +393,7 @@ walk_luajit_stack(PerCPURecord *record, const LuaJITProcInfo *info, int *next_un
   LJState *L        = &record->luajitUnwindScratch.L;
   TValue *prevframe = record->luajitUnwindState.prevframe;
   TValue *bot       = L->stack + 1;
-#pragma unroll
+
   for (int i = 0; i < FRAMES_PER_WALK_LUAJIT_STACK; i++) {
     TValue *frame = (TValue *)(record->luajitUnwindState.frame);
     if (frame <= bot) {
@@ -582,7 +582,7 @@ static inline __attribute__((__always_inline__)) int unwind_luajit(struct pt_reg
     return -1;
 
   UnwindState *state   = &record->state;
-  int unwinder         = get_next_unwinder_after_interpreter(record);
+  int unwinder         = get_next_unwinder_after_interpreter();
   ErrorCode error      = ERR_OK;
   u32 pid              = record->trace.pid;
   LuaJITProcInfo *info = bpf_map_lookup_elem(&luajit_procs, &pid);

support/ebpf/native_stack_trace.ebpf.c

@@ -191,8 +191,8 @@ static EBPF_INLINE ErrorCode get_stack_delta(UnwindState *state, int *addrDiff,
     // Do the binary search, up to 16 iterations. Deltas are paged to 64kB pages.
     // They can contain at most 64kB deltas even if everything is single byte opcodes.
     int i;
-#pragma unroll
-    for (i = 0; i < 16; i++) {
+    UNROLL for (i = 0; i < 16; i++)
+    {
       if (!bsearch_step(inner_map, &lo, &hi, page_offset)) {
         break;
       }
@@ -357,8 +357,7 @@ static EBPF_INLINE u64 unwind_register_address(UnwindState *state, u64 cfa, u8 o
 // is marked with UNWIND_COMMAND_STOP which marks entry points (main function,
 // thread spawn function, signal handlers, ...).
 #if defined(__x86_64__)
-static EBPF_INLINE ErrorCode
-unwind_one_frame(u64 pid, u32 frame_idx, UnwindState *state, bool *stop)
+static EBPF_INLINE ErrorCode unwind_one_frame(UnwindState *state, bool *stop)
 {
   *stop = false;
 
@@ -452,8 +451,7 @@ unwind_one_frame(u64 pid, u32 frame_idx, UnwindState *state, bool *stop)
   return ERR_OK;
 }
 #elif defined(__aarch64__)
-static EBPF_INLINE ErrorCode
-unwind_one_frame(u64 pid, u32 frame_idx, struct UnwindState *state, bool *stop)
+static EBPF_INLINE ErrorCode unwind_one_frame(struct UnwindState *state, bool *stop)
 {
   *stop = false;
 
@@ -593,8 +591,8 @@ static EBPF_INLINE int unwind_native(struct pt_regs *ctx)
   Trace *trace = &record->trace;
   int unwinder;
   ErrorCode error;
-#pragma unroll
-  for (int i = 0; i < NATIVE_FRAMES_PER_PROGRAM; i++) {
+  UNROLL for (int i = 0; i < NATIVE_FRAMES_PER_PROGRAM; i++)
+  {
     unwinder = PROG_UNWIND_STOP;
 
     // Unwind native code
@@ -620,7 +618,7 @@ static EBPF_INLINE int unwind_native(struct pt_regs *ctx)
 
     // Unwind the native frame using stack deltas. Stop if no next frame.
     bool stop;
-    error = unwind_one_frame(trace->pid, frame_idx, &record->state, &stop);
+    error = unwind_one_frame(&record->state, &stop);
     if (error || stop) {
       break;
     }

support/ebpf/off_cpu.ebpf.c

@@ -20,7 +20,7 @@ bpf_map_def SEC("maps") sched_times = {
 
 // tracepoint__sched_switch serves as entry point for off cpu profiling.
 SEC("tracepoint/sched/sched_switch")
-int tracepoint__sched_switch(void *ctx)
+int tracepoint__sched_switch(UNUSED void *ctx)
 {
   u64 pid_tgid = bpf_get_current_pid_tgid();
   u32 pid      = pid_tgid >> 32;