Add support for xqd_compute_runtime_get_heap_mib

See fastly/Viceroy#572

Author: jedisct1

framing.go

@@ -71,6 +71,14 @@ func validateAndApplyFramingMode(headers http.Header, mode FramingHeadersMode, l
 		return FramingHeadersModeAutomatic
 	}
 
-	// Manual mode with valid headers (or no framing headers at all)
+	if !hasContentLength && !hasTransferEncoding {
+		if logger != nil {
+			logger("missing Content-Length and Transfer-Encoding headers, falling back to automatic framing")
+		}
+		filterFramingHeaders(headers)
+		return FramingHeadersModeAutomatic
+	}
+
+	// Manual mode with valid framing headers
 	return FramingHeadersModeManuallyFromHeaders
 }

framing_test.go

@@ -274,12 +274,12 @@ func TestValidateAndApplyFramingMode(t *testing.T) {
 			expectTransferEncoding: false,
 		},
 		{
-			name: "manual mode - no framing headers is valid",
+			name: "manual mode - no framing headers falls back to automatic",
 			headers: http.Header{
 				"Content-Type": []string{"text/plain"},
 			},
 			mode:                   FramingHeadersModeManuallyFromHeaders,
-			expectedMode:           FramingHeadersModeManuallyFromHeaders,
+			expectedMode:           FramingHeadersModeAutomatic,
 			expectContentLength:    false,
 			expectTransferEncoding: false,
 		},

wasmcontext.go

@@ -768,6 +768,9 @@ func (i *Instance) link(store *wasmtime.Store, linker *wasmtime.Linker) {
 	_ = linker.FuncWrap("fastly_compute_runtime", "get_vcpu_ms", safeWrap1(i, "get_vcpu_ms", func(vcpu_time_ms_out int32) int32 {
 		return i.xqd_compute_runtime_get_vcpu_ms(vcpu_time_ms_out)
 	}))
+	_ = linker.FuncWrap("fastly_compute_runtime", "get_heap_mib", safeWrap1(i, "get_heap_mib", func(heap_mib_out int32) int32 {
+		return i.xqd_compute_runtime_get_heap_mib(heap_mib_out)
+	}))
 	_ = linker.FuncWrap("fastly_compute_runtime", "get_sandbox_id", safeWrap3(i, "get_sandbox_id", func(sandbox_id_out int32, sandbox_id_max_len int32, nwritten_out int32) int32 {
 		return i.xqd_compute_runtime_get_sandbox_id(sandbox_id_out, sandbox_id_max_len, nwritten_out)
 	}))
@@ -1150,6 +1153,7 @@ func (i *Instance) linklegacy(store *wasmtime.Store, linker *wasmtime.Linker) {
 
 	// xqd_compute_runtime.go
 	_ = linker.FuncWrap("env", "xqd_compute_runtime_get_vcpu_ms", safeWrap1(i, "xqd_compute_runtime_get_vcpu_ms", func(a int32) int32 { return i.xqd_compute_runtime_get_vcpu_ms(a) }))
+	_ = linker.FuncWrap("env", "xqd_compute_runtime_get_heap_mib", safeWrap1(i, "xqd_compute_runtime_get_heap_mib", func(a int32) int32 { return i.xqd_compute_runtime_get_heap_mib(a) }))
 
 	// xqd_async_io.go
 	_ = linker.FuncWrap("env", "xqd_async_io_select", safeWrap4(i, "xqd_async_io_select", func(a int32, b int32, c int32, d int32) int32 { return i.xqd_async_io_select(a, b, c, d) }))

xqd_compute_runtime.go

@@ -134,6 +134,30 @@ func (i *Instance) xqd_compute_runtime_get_hostname(hostname_out int32, hostname
 	return XqdStatusOK
 }
 
+// xqd_compute_runtime_get_heap_mib returns the current heap usage in mebibytes (2^20 bytes),
+// rounded up to the nearest MiB.
+//
+// Signature: (heap_mib_out: *mut u32) -> fastly_status
+func (i *Instance) xqd_compute_runtime_get_heap_mib(heap_mib_out int32) int32 {
+	i.abilog.Printf("compute_runtime_get_heap_mib: heap_mib_out=%d", heap_mib_out)
+
+	if i.memory == nil {
+		return XqdError
+	}
+
+	const mebibyte uint64 = 1024 * 1024
+	heapBytes := uint64(i.memory.Len())
+	heapMib := (heapBytes + mebibyte - 1) / mebibyte
+	if heapMib > uint64(^uint32(0)) {
+		heapMib = uint64(^uint32(0))
+	}
+
+	i.abilog.Printf("compute_runtime_get_heap_mib: returning %d MiB (%d bytes)", heapMib, heapBytes)
+	i.memory.WriteUint32(heap_mib_out, uint32(heapMib))
+
+	return XqdStatusOK
+}
+
 // xqd_compute_runtime_get_vcpu_ms returns the amount of active CPU time (in milliseconds)
 // that has been consumed by the WebAssembly guest during request processing.
 //