libunit-wasm: Allow uploads larger than 4GiB

Currently Wasm modules are limited to a 32bit address space (until at
least the memory64 work is completed). All the counters etc in the
request structure were u32's. Which matched with the 32bit memory
limitation.

However there is really no need to not allow >4GiB uploads that can be
saved off to disk or some such.

To do this we need to increase the ->content_len & ->total_content_sent
members to u64's and also adjust the return types of
(luw,uwr}_get_http_content_len() and
{luw,uwr}_get_http_total_content_sent() similarly.

However because we need the request structure to have the exact same
layout on 32bit (for Wasm modules) as it does on 64bit we need to re-jig
the order of some of these members and add a four-byte padding member.

Thus the request structure now looks like on 32bit (as shown by
pahole(1))

  struct luw_req {
          u32                        method_off;           /*     0     4 */
          u32                        method_len;           /*     4     4 */
          u32                        version_off;          /*     8     4 */
          u32                        version_len;          /*    12     4 */
          u32                        path_off;             /*    16     4 */
          u32                        path_len;             /*    20     4 */
          u32                        query_off;            /*    24     4 */
          u32                        query_len;            /*    28     4 */
          u32                        remote_off;           /*    32     4 */
          u32                        remote_len;           /*    36     4 */
          u32                        local_addr_off;       /*    40     4 */
          u32                        local_addr_len;       /*    44     4 */
          u32                        local_port_off;       /*    48     4 */
          u32                        local_port_len;       /*    52     4 */
          u32                        server_name_off;      /*    56     4 */
          u32                        server_name_len;      /*    60     4 */
          /* --- cacheline 1 boundary (64 bytes) --- */
          u64                        content_len;          /*    64     8 */
          u64                        total_content_sent;   /*    72     8 */
          u32                        content_sent;         /*    80     4 */
          u32                        content_off;          /*    84     4 */
          u32                        request_size;         /*    88     4 */
          u32                        nr_fields;            /*    92     4 */
          u32                        tls;                  /*    96     4 */
          char                       __pad[4];             /*   100     4 */
          struct luw_hdr_field       fields[];             /*   104     0 */

          /* size: 104, cachelines: 2, members: 25 */
          /* last cacheline: 40 bytes */
  };

and the same structure (taken from Unit) compiled as 64bit

  struct nxt_wasm_request_s {
          uint32_t                   method_off;           /*     0     4 */
          uint32_t                   method_len;           /*     4     4 */
          uint32_t                   version_off;          /*     8     4 */
          uint32_t                   version_len;          /*    12     4 */
          uint32_t                   path_off;             /*    16     4 */
          uint32_t                   path_len;             /*    20     4 */
          uint32_t                   query_off;            /*    24     4 */
          uint32_t                   query_len;            /*    28     4 */
          uint32_t                   remote_off;           /*    32     4 */
          uint32_t                   remote_len;           /*    36     4 */
          uint32_t                   local_addr_off;       /*    40     4 */
          uint32_t                   local_addr_len;       /*    44     4 */
          uint32_t                   local_port_off;       /*    48     4 */
          uint32_t                   local_port_len;       /*    52     4 */
          uint32_t                   server_name_off;      /*    56     4 */
          uint32_t                   server_name_len;      /*    60     4 */
          /* --- cacheline 1 boundary (64 bytes) --- */
          uint64_t                   content_len;          /*    64     8 */
          uint64_t                   total_content_sent;   /*    72     8 */
          uint32_t                   content_sent;         /*    80     4 */
          uint32_t                   content_off;          /*    84     4 */
          uint32_t                   request_size;         /*    88     4 */
          uint32_t                   nfields;              /*    92     4 */
          uint32_t                   tls;                  /*    96     4 */
          char                       __pad[4];             /*   100     4 */
          nxt_wasm_http_field_t      fields[];             /*   104     0 */

          /* size: 104, cachelines: 2, members: 25 */
          /* last cacheline: 40 bytes */
  };

We can see the structures have the same layout, same size and no
padding.

We need the __pad member as otherwise I saw gcc and clang on Alpine
Linux automatically add the 'packed' attribute to the structure which
made the two structures not match.

Link: <https://github.com/WebAssembly/memory64>
Signed-off-by: Andrew Clayton <a.clayton@nginx.com>

1 files changed, 11 insertions, 5 deletions

diff --git a/src/rust/unit-wasm-sys/rusty.rs b/src/rust/unit-wasm-sys/rusty.rs
index 5d1fbad..bf9cd64 100644
--- a/src/rust/unit-wasm-sys/rusty.rs
+++ b/src/rust/unit-wasm-sys/rusty.rs
@@ -95,7 +95,7 @@ pub fn uwr_get_http_server_name(ctx: *const luw_ctx_t) -> &'static str {
     C2S!(luw_get_http_server_name(ctx))
 }
 
-pub fn uwr_get_http_content_len(ctx: *const luw_ctx_t) -> usize {
+pub fn uwr_get_http_content_len(ctx: *const luw_ctx_t) -> u64 {
     unsafe { luw_get_http_content_len(ctx) }
 }
 
@@ -103,7 +103,7 @@ pub fn uwr_get_http_content_sent(ctx: *const luw_ctx_t) -> usize {
     unsafe { luw_get_http_content_sent(ctx) }
 }
 
-pub fn uwr_get_http_total_content_sent(ctx: *const luw_ctx_t) -> usize {
+pub fn uwr_get_http_total_content_sent(ctx: *const luw_ctx_t) -> u64 {
     unsafe { luw_get_http_total_content_sent(ctx) }
 }
 
@@ -115,7 +115,7 @@ pub fn uwr_get_http_content_str(ctx: *const luw_ctx_t) -> &'static str {
     unsafe {
         let slice = slice::from_raw_parts(
             uwr_get_http_content(ctx),
-            uwr_get_http_total_content_sent(ctx),
+            uwr_get_http_total_content_sent(ctx).try_into().unwrap(),
         );
         str::from_utf8(slice).unwrap()
     }
@@ -158,9 +158,15 @@ pub fn uwr_mem_write_str(ctx: *mut luw_ctx_t, src: &str) -> usize {
 pub fn uwr_mem_write_buf(
     ctx: *mut luw_ctx_t,
     src: *const u8,
-    size: usize,
+    size: u64,
 ) -> usize {
-    unsafe { luw_mem_writep_data(ctx, src, size) }
+    /*
+     * We're dealing with a 32bit address space, but we allow
+     * size to come from the output of uwr_get_http_content_len()
+     * which returns a u64 to allow for larger than memory uploads.
+     */
+    let sz = size as usize;
+    unsafe { luw_mem_writep_data(ctx, src, sz) }
 }
 
 pub fn uwr_req_buf_append(ctx: *mut luw_ctx_t, src: *const u8) {