Remove pow2 limitation, fallback to base buffer if large buffer not found

mmat11 · mmat11 · commit 1e6c404f772d · 2025-09-26T00:06:45.000+02:00
diff --git a/bpf/common/large_buffers.h b/bpf/common/large_buffers.h
@@ -17,6 +17,10 @@ enum {
     // of the maximum payload size as a guard.
     k_large_buf_max_size = 1 << 14, // 16K
     k_large_buf_max_size_mask = k_large_buf_max_size - 1,
+
+    // Maximum size for a large buffer payload.
+    k_large_buf_payload_max_size = 1 << 13, // 8K
+    k_large_buf_payload_max_size_mask = k_large_buf_payload_max_size - 1,
 };
 
 SCRATCH_MEM_SIZED(http_large_buffers, k_large_buf_max_size);
diff --git a/bpf/generictracer/protocol_http.h b/bpf/generictracer/protocol_http.h
@@ -413,12 +413,6 @@ static __always_inline int http_send_large_buffer(http_info_t *req,
         return 0;
     }
 
-    if (!is_pow2(http_buffer_size)) {
-        bpf_dbg_printk("http_send_large_buffer: bug: http_buffer_size is not a power of 2");
-        return -1;
-    }
-    const u32 buf_len_mask = http_buffer_size - 1;
-
     tcp_large_buffer_t *large_buf = (tcp_large_buffer_t *)http_large_buffers_mem();
     if (!large_buf) {
         bpf_dbg_printk("http_send_large_buffer: failed to reserve space for HTTP large buffer");
@@ -436,7 +430,7 @@ static __always_inline int http_send_large_buffer(http_info_t *req,
         bpf_dbg_printk("WARN: http_send_large_buffer: buffer is full, truncating data");
     }
 
-    bpf_probe_read(large_buf->buf, large_buf->len & buf_len_mask, u_buf);
+    bpf_probe_read(large_buf->buf, large_buf->len & k_large_buf_payload_max_size_mask, u_buf);
 
     u32 total_size = sizeof(tcp_large_buffer_t);
     total_size += large_buf->len > sizeof(void *) ? large_buf->len : sizeof(void *);
@@ -524,13 +518,8 @@ int obi_protocol_http(void *ctx) {
             bpf_dbg_printk("No META!");
         }
 
-        if (http_buffer_size > 0) {
-            http_send_large_buffer(info,
-                                   (void *)args->u_buf,
-                                   args->bytes_len,
-                                   args->packet_type,
-                                   k_large_buf_action_init);
-        }
+        http_send_large_buffer(
+            info, (void *)args->u_buf, args->bytes_len, args->packet_type, k_large_buf_action_init);
 
         // we copy some small part of the buffer to the info trace event, so that we can process an event even with
         // incomplete trace info in user space.
diff --git a/bpf/generictracer/protocol_mysql.h b/bpf/generictracer/protocol_mysql.h
@@ -124,12 +124,6 @@ static __always_inline int mysql_read_fixup_buffer(const connection_info_t *conn
                                                    u32 data_len) {
     u8 offset = 0;
 
-    if (!is_pow2(mysql_buffer_size)) {
-        bpf_dbg_printk("mysql_read_fixup_buffer: bug: mysql_buffer_size is not a power of 2");
-        return -1;
-    }
-    const u32 buf_len_mask = mysql_buffer_size - 1;
-
     struct mysql_state_data *state_data = bpf_map_lookup_elem(&mysql_state, conn_info);
     if (state_data != NULL) {
         bpf_probe_read(buf, k_mysql_hdr_without_command_size, (const void *)state_data);
@@ -148,7 +142,7 @@ static __always_inline int mysql_read_fixup_buffer(const connection_info_t *conn
         bpf_dbg_printk("WARN: mysql_read_fixup_buffer: buffer is full, truncating data");
     }
 
-    bpf_probe_read(buf + offset, *buf_len & buf_len_mask, (const void *)data);
+    bpf_probe_read(buf + offset, *buf_len & k_large_buf_payload_max_size_mask, (const void *)data);
 
     return *buf_len;
 }
diff --git a/bpf/generictracer/protocol_postgres.h b/bpf/generictracer/protocol_postgres.h
@@ -53,12 +53,6 @@ static __always_inline int postgres_send_large_buffer(tcp_req_t *req,
                                                       u32 bytes_len,
                                                       u8 packet_type,
                                                       enum large_buf_action action) {
-    if (!is_pow2(postgres_buffer_size)) {
-        bpf_dbg_printk("postgres_send_large_buffer: bug: postgres_buffer_size is not a power of 2");
-        return -1;
-    }
-    const u32 buf_len_mask = postgres_buffer_size - 1;
-
     tcp_large_buffer_t *large_buf = (tcp_large_buffer_t *)postgres_large_buffers_mem();
     if (!large_buf) {
         bpf_dbg_printk(
@@ -76,7 +70,7 @@ static __always_inline int postgres_send_large_buffer(tcp_req_t *req,
         large_buf->len = postgres_buffer_size;
         bpf_dbg_printk("WARN: postgres_send_large_buffer: buffer is full, truncating data");
     }
-    bpf_probe_read(large_buf->buf, large_buf->len & buf_len_mask, u_buf);
+    bpf_probe_read(large_buf->buf, large_buf->len & k_large_buf_payload_max_size_mask, u_buf);
 
     u32 total_size = sizeof(tcp_large_buffer_t);
     total_size += large_buf->len > sizeof(void *) ? large_buf->len : sizeof(void *);
diff --git a/pkg/components/ebpf/common/httpfltr_transform.go b/pkg/components/ebpf/common/httpfltr_transform.go
@@ -86,18 +86,16 @@ func HTTPInfoEventToSpan(parseCtx *EBPFParseContext, event *BPFHTTPInfo) (reques
 		bufHost       string
 		bufPort       int
 		parsedHost    bool
-		requestBuffer []byte
+		requestBuffer = event.Buf[:]
 	)
 
 	if event.HasLargeBuffers == 1 {
 		b, ok := extractTCPLargeBuffer(parseCtx, event.Tp.TraceId, event.Tp.SpanId, packetTypeRequest)
-		if !ok {
+		if ok {
+			requestBuffer = b
+		} else {
 			slog.Debug("missing large buffer for HTTP request", "traceID", event.Tp.TraceId, "spanID", event.Tp.SpanId)
-			return request.Span{}, false, nil
 		}
-		requestBuffer = b
-	} else {
-		requestBuffer = event.Buf[:]
 	}
 
 	// When we can't find the connection info, we signal that through making the
diff --git a/pkg/config/ebpf_tracer.go b/pkg/config/ebpf_tracer.go
@@ -25,6 +25,8 @@ const (
 	ContextPropagationDisabled
 )
 
+const bufferSizeMax = 8192
+
 // EBPFTracer configuration for eBPF programs
 type EBPFTracer struct {
 	// Enables logging of eBPF program events
@@ -103,9 +105,7 @@ type EBPFTracer struct {
 }
 
 // Per-protocol data buffer size in bytes.
-// Min: 128 bytes, Max: 8192 bytes.
-// Valid values: 0, 128, 256, 512, 1024, 2048, 4096, 8192.
-//
+// Max: 8192 bytes.
 // Default: 0 (disabled).
 type EBPFBufferSizes struct {
 	HTTP     uint32 `yaml:"http" env:"OTEL_EBPF_BPF_BUFFER_SIZE_HTTP"`
@@ -116,25 +116,14 @@ type EBPFBufferSizes struct {
 func (c *EBPFTracer) Validate() error {
 	// TODO(matt): validate all the existing attributes
 
-	switch c.BufferSizes.HTTP {
-	case 0, 128, 256, 512, 1024, 2048, 4096, 8192:
-		// valid sizes
-	default:
-		return fmt.Errorf("invalid HTTP buffer size: %d, must be one of 0, 128, 256, 512, 1024, 2048, 4096, 8192", c.BufferSizes.HTTP)
+	if c.BufferSizes.HTTP > bufferSizeMax {
+		return fmt.Errorf("buffer size too large (HTTP): %d, max is %d", c.BufferSizes.HTTP, bufferSizeMax)
 	}
-
-	switch c.BufferSizes.MySQL {
-	case 0, 128, 256, 512, 1024, 2048, 4096, 8192:
-		// valid sizes
-	default:
-		return fmt.Errorf("invalid MySQL buffer size: %d, must be one of 0, 128, 256, 512, 1024, 2048, 4096, 8192", c.BufferSizes.MySQL)
+	if c.BufferSizes.MySQL > bufferSizeMax {
+		return fmt.Errorf("buffer size too large (MySQL): %d, max is %d", c.BufferSizes.MySQL, bufferSizeMax)
 	}
-
-	switch c.BufferSizes.Postgres {
-	case 0, 128, 256, 512, 1024, 2048, 4096, 8192:
-		// valid sizes
-	default:
-		return fmt.Errorf("invalid Postgres buffer size: %d, must be one of 0, 128, 256, 512, 1024, 2048, 4096, 8192", c.BufferSizes.Postgres)
+	if c.BufferSizes.Postgres > bufferSizeMax {
+		return fmt.Errorf("buffer size too large (Postgres): %d, max is %d", c.BufferSizes.Postgres, bufferSizeMax)
 	}
 
 	return nil
