Update the KVM API to add extra argument to backend_response

Author: fwsGonzo

Diff for: go/build.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -e
 
-pushd example
+pushd goexample
 go build
 popd
 

Diff for: go/goexample/goexample.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"strings"
 
 	"varnish"
@@ -52,6 +53,6 @@ func main() {
 
 	varnish.StorageRegister("my_storage", my_storage)
 
-	fmt.Println("Go Compute Example ready")
+	fmt.Println("Go Compute Example ready (", os.Args[2], ")")
 	varnish.WaitForRequests()
 }

Diff for: go/varnish/kvm_api.c

@@ -5,7 +5,7 @@
 extern void go_backend_response(int16_t status,
     const char *ctype, size_t ctlen, const uint8_t *data, size_t datalen)
 {
-    backend_response(status, ctype, ctlen, data, datalen);
+    sys_backend_response(status, ctype, ctlen, data, datalen, NULL);
 }
 
 extern long go_set_cacheable(bool cached, float ttl, float grace, float keep)
@@ -60,19 +60,27 @@ asm(".global wait_for_requests\n"
 	"	mov $0x10001, %eax\n"
 	"	out %eax, $0\n");
 
+asm(".global wait_for_requests_paused\n"
+	".type wait_for_requests_paused, @function\n"
+	"wait_for_requests_paused:\n"
+	"	mov $0x10002, %eax\n"
+	"	out %eax, $0\n"
+	"	ret\n");
+
 asm(".global sys_set_cacheable\n"
 	".type sys_set_cacheable, @function\n"
 	"sys_set_cacheable:\n"
 	"	mov $0x10005, %eax\n"
 	"	out %eax, $0\n"
 	"	ret\n");
 
-asm(".global backend_response\n"
-	".type backend_response, @function\n"
-	"backend_response:\n"
+asm(".global sys_backend_response\n"
+	".type sys_backend_response, @function\n"
+	"sys_backend_response:\n"
 	".cfi_startproc\n"
 	"	mov $0x10010, %eax\n"
 	"	out %eax, $0\n"
+	"	ret\n"
 	".cfi_endproc\n");
 
 asm(".global begin_streaming_response\n"

Diff for: javascript/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.0.2)
+cmake_minimum_required (VERSION 3.5)
 project (qjs_app C)
 
 set(JSFILE "src/my.js" CACHE STRING "JavaScript source file")

Diff for: kvm_api.h

@@ -115,13 +115,43 @@ extern void wait_for_requests_paused(struct backend_request* req);
  *  	backend_response(200, ctype, strlen(ctype), cont, strlen(cont));
  *  }
  **/
+struct ResponseHeader {
+	const char *field;
+	size_t      field_len;
+};
+struct BackendResponseExtra {
+	const struct ResponseHeader *headers;
+	uint16_t num_headers;
+	bool cached;
+	float ttl;
+	float grace;
+	float keep;
+	uint64_t reserved[4]; /* Reserved for future use. */
+};
 extern void __attribute__((used))
-backend_response(int16_t status, const void *t, size_t, const void *c, size_t);
+sys_backend_response(int16_t status, const void *t, size_t, const void *c, size_t,
+	const struct BackendResponseExtra *extra);
+
+static inline void
+backend_response(int16_t status, const void *t, size_t tlen, const void *c, size_t clen) {
+	sys_backend_response(status, t, tlen, c, clen, NULL);
+}
 
 static inline void
 backend_response_str(int16_t status, const char *ctype, const char *content)
 {
-	backend_response(status, ctype, __builtin_strlen(ctype), content, __builtin_strlen(content));
+	sys_backend_response(status, ctype, __builtin_strlen(ctype), content, __builtin_strlen(content), NULL);
+}
+
+/**
+ * @brief Create a response that includes HTTP headers, a status code, a body and
+ * a content type. The response is sent back to the client (or cached in Varnish).
+ */
+static inline void
+backend_response_extra(int16_t status, const void *t, size_t tlen, const void *c, size_t clen,
+	const struct BackendResponseExtra *extra)
+{
+	sys_backend_response(status, t, tlen, c, clen, extra);
 }
 
 /**
@@ -150,8 +180,8 @@ static const int REQ      = 0;
 static const int RESP     = 1;
 static const int REQUEST  = REQ;
 static const int RESPONSE = RESP;
-static const int BEREQ    = 4;
-static const int BERESP   = 5;
+static const int BEREQ    = 0;
+static const int BERESP   = 1;
 static const unsigned HTTP_FMT_SIZE = 4096; /* Most header fields fit. */
 
 extern long
@@ -782,9 +812,9 @@ asm(".global sys_set_cacheable\n"
 	"	out %eax, $0\n"
 	"	ret\n");
 
-asm(".global backend_response\n"
-	".type backend_response, @function\n"
-	"backend_response:\n"
+asm(".global sys_backend_response\n"
+	".type sys_backend_response, @function\n"
+	"sys_backend_response:\n"
 	".cfi_startproc\n"
 	"	mov $0x10010, %eax\n"
 	"	out %eax, $0\n"

Diff for: nelua/env/main.c

@@ -1,2 +1,5 @@
 #include "kvm_api.h"
 
+void backend_response1(int16_t status, const char *t, size_t tlen, const char *c, size_t clen) {
+	sys_backend_response(status, t, tlen, c, clen, NULL);
+}

Diff for: nelua/varnish.nelua

@@ -14,7 +14,7 @@ global varnish.set: function(field: string)
 local function register_func(id: cint, func: function(cstring, cstring)): void <cimport>
 end
 
-local function backend_response(status: cint, ct: cstring, ctlen: cint, cont: cstring, contlen: cint): void <cimport>
+local function backend_response1(status: cint, ct: cstring, ctlen: cint, cont: cstring, contlen: cint): void <cimport>
 end
 
 local backend_get: function(string, string)
@@ -28,7 +28,7 @@ varnish.set_backend_get = function(func: function(string, string))
 end
 
 varnish.response = function(status: integer, content_type: string, content: string)
-    backend_response(status, content_type, #content_type, content, #content)
+    backend_response1(status, content_type, #content_type, content, #content)
 end
 
 local function sys_http_set(id: cint, f: cstring, l: cint): void <cimport>

Diff for: rust/api/varnish.rs

@@ -5,10 +5,13 @@ use core::ffi::CStr;
 use core::ffi::c_char;
 
 /** HTTP **/
+#[allow(dead_code)]
 pub static REQ:  u8 = 0;
+#[allow(dead_code)]
 pub static RESP: u8 = 1;
 
 #[inline]
+#[allow(dead_code)]
 pub fn log(field: &str) -> i32
 {
 	let mut result = 0x7F000;
@@ -23,6 +26,7 @@ pub fn log(field: &str) -> i32
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn append(hp: u8, field: &str) -> i32
 {
 	let mut result = 0x10020;
@@ -38,6 +42,7 @@ pub fn append(hp: u8, field: &str) -> i32
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn set_cacheable(cached: bool, ttl: f32, grace: f32, keep: f32)
 {
 	unsafe {
@@ -52,6 +57,7 @@ pub fn set_cacheable(cached: bool, ttl: f32, grace: f32, keep: f32)
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn backend_response(status: u16, ctype: &str, data: &[u8])
 {
 	unsafe {
@@ -61,12 +67,46 @@ pub fn backend_response(status: u16, ctype: &str, data: &[u8])
 			in("rsi") ctype.as_ptr(),
 			in("rdx") ctype.len(),
 			in("rcx") data.as_ptr(),
-			in("r8")  data.len()
+			in("r8")  data.len(),
+			in("r9")  0 // Extra data
+		);
+	}
+}
+
+#[allow(dead_code)]
+pub struct ResponseHeader {
+	pub data: *const u8,
+	pub len: usize,
+}
+#[allow(dead_code)]
+pub struct ExtraResponseData {
+	pub headers: *const ResponseHeader,
+	pub num_headers: usize,
+	pub cached: bool,
+	pub ttl: f32,
+	pub grace: f32,
+	pub keep: f32,
+}
+
+#[inline]
+#[allow(dead_code)]
+pub fn backend_response_full(status: u16, ctype: &str, data: &[u8], extra: &ExtraResponseData)
+{
+	unsafe {
+		asm!("out 0x0, eax",
+			in("eax") 0x10010,
+			in("rdi") status,
+			in("rsi") ctype.as_ptr(),
+			in("rdx") ctype.len(),
+			in("rcx") data.as_ptr(),
+			in("r8")  data.len(),
+			in("r9")  extra as *const ExtraResponseData
 		);
 	}
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn backend_response_str(status: u16, ctype: &str, data: &str)
 {
 	backend_response(status, ctype, data.as_bytes());
@@ -135,6 +175,7 @@ pub fn set_backend_post(cb: PostHandler)
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn wait_for_requests() -> !
 {
 	unsafe {
@@ -159,6 +200,7 @@ struct backend_request {
 	size_t         content_len;
 };
 */
+#[allow(dead_code)]
 pub struct Request {
 	pub method: *const c_char,
 	pub url: *const c_char,
@@ -173,24 +215,30 @@ pub struct Request {
 }
 
 impl Request {
+	#[allow(dead_code)]
 	pub fn method(&self) -> &str {
 		unsafe { CStr::from_ptr(self.method).to_str().unwrap() }
 	}
+	#[allow(dead_code)]
 	pub fn url(&self) -> &str {
 		unsafe { CStr::from_ptr(self.url).to_str().unwrap() }
 	}
+	#[allow(dead_code)]
 	pub fn arg(&self) -> &str {
 		unsafe { CStr::from_ptr(self.arg).to_str().unwrap() }
 	}
+	#[allow(dead_code)]
 	pub fn content_type(&self) -> &str {
 		unsafe { CStr::from_ptr(self.content_type).to_str().unwrap() }
 	}
+	#[allow(dead_code)]
 	pub fn content(&self) -> &[u8] {
 		unsafe { std::slice::from_raw_parts(self.content, self.content_len) }
 	}
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn wait_for_requests_paused() -> Request
 {
 	unsafe {
@@ -206,6 +254,7 @@ pub fn wait_for_requests_paused() -> Request
 /** Debugging and introspection **/
 
 #[inline]
+#[allow(dead_code)]
 pub fn breakpoint()
 {
 	unsafe {

Diff for: rust/static/src/main.rs

@@ -1,4 +1,5 @@
 mod varnish;
+use crate::varnish::*;
 
 fn on_get(_url: &str, _arg: &str)
 {
@@ -26,7 +27,24 @@ fn main()
 			let mut resp : String = "Hello, world! URL=".to_string();
 			resp.push_str(&request.url());
 
-			varnish::backend_response_str(200, "text/plain", &resp);
+			let header1 = ResponseHeader {
+				data: "X-Header: Header value".as_ptr(),
+				len: "X-Header: Header value".len(),
+			};
+			let header2 = ResponseHeader {
+				data: "X-Header2: Header value".as_ptr(),
+				len: "X-Header2: Header value".len(),
+			};
+			let headers = [header1, header2];
+			let extra = ExtraResponseData {
+				headers: headers.as_ptr(),
+				num_headers: headers.len(),
+				cached: false,
+				ttl: 10.0,
+				grace: 0.0,
+				keep: 0.0,
+			};
+			varnish::backend_response_full(200, "text/plain", resp.as_bytes(), &extra);
 		}
 	}
 }