RedBear-OS/local/patches/mesa/26-cs-submit-bidirectional-seqno.patch

--- a/src/gallium/winsys/redox/drm/redox_drm_cs.c
+++ b/src/gallium/winsys/redox/drm/redox_drm_cs.c
@@ -5,14 +5,17 @@
  *   local/recipes/gpu/redox-drm/source/src/scheme.rs
  *   local/recipes/gpu/redox-drm/source/src/driver.rs
  *
- * Two ioctls are used:
+ * Two ioctls are used, both following the standard DRM bidirectional-ioctl
+ * pattern: the caller fills the input fields, passes the struct to drmIoctl,
+ * and the kernel writes the response fields back into the SAME struct.
+ *
  * - REDOX_PRIVATE_CS_SUBMIT (DRM_IOCTL_BASE + 31)
- *   in: src_handle (gem), dst_handle (gem, ignored for now),
- *       src_offset (offset into src buffer), byte_count (DWORDs to submit)
+ *   in:  src_handle (gem), dst_handle (gem, ignored for now),
+ *        src_offset, dst_offset, byte_count
  *   out: seqno (u64) — the kernel-assigned submission id
  * - REDOX_PRIVATE_CS_WAIT (DRM_IOCTL_BASE + 32)
- *   in: seqno, timeout_ns
- *   out: completed (bool), completed_seqno (u64)
+ *   in:  seqno, timeout_ns
+ *   out: completed (u8), completed_seqno (u64)
  *
  * The kernel reads `byte_count` u32 dwords from the mapped GEM at
  * `src_handle + src_offset` and writes them into the GPU render ring.
@@ -20,6 +23,12 @@
  * We invoke these ioctls via `drmIoctl` on the winsys fd. libdrm's
  * redox patch redirects the ioctls to /scheme:drm/card0.
  *
+ * The seqno returned by SUBMIT is the kernel's global per-device counter.
+ * It must NOT be faked with a local counter: under multi-process GPU use
+ * (compositor + multiple clients sharing /scheme/drm/card0) a local counter
+ * diverges from the kernel's namespace and fence waits keyed on it never
+ * complete.
+ *
  * SPDX-License-Identifier: MIT
  */
 
@@ -51,7 +60,12 @@
 #include "util/u_debug.h"
 
 /* Wire format of the kernel ABI structs. MUST match the kernel definitions
- * (kernel's GemHandle = u32; the structs are #[repr(C)] in Rust).
+ * in local/recipes/gpu/redox-drm/source/src/driver.rs (#[repr(C)]).
+ *
+ * Both structs are bidirectional: the caller fills the input fields, and the
+ * kernel writes the response fields back into the same struct on return.
+ * There is no separate result struct on the wire — the kernel serializes the
+ * same struct (with response fields populated) back to userspace.
  */
 struct RedoxCsSubmitWire {
    uint32_t src_handle;
@@ -59,20 +73,15 @@
    uint64_t src_offset;
    uint64_t dst_offset;
    uint64_t byte_count;
-};
-
-struct RedoxCsSubmitResultWire {
-   uint64_t seqno;
+   uint64_t seqno;           /* response: kernel-assigned submission id */
 };
 
 struct RedoxCsWaitWire {
    uint64_t seqno;
    uint64_t timeout_ns;
-};
-
-struct RedoxCsWaitResultWire {
-   uint8_t completed;
-   uint64_t completed_seqno;
+   uint8_t  completed;        /* response: non-zero if seqno completed */
+   uint8_t  _pad[7];          /* align completed_seqno to 8 bytes */
+   uint64_t completed_seqno;  /* response: highest completed seqno */
 };
 
 uint64_t
@@ -81,7 +90,6 @@
                    uint32_t batch_dword_count)
 {
    struct RedoxCsSubmitWire submit = {0};
-   struct RedoxCsSubmitResultWire result = {0};
    size_t byte_count;
    void *mapped;
    int err;
@@ -143,30 +151,23 @@
       return 0;
    }
 
-   /* The ioctl is the kernel-side drmIoctl wrapper; the actual submit
-    * returns the seqno through a separate read (DRM protocol on Redox
-    * uses a write-then-read pattern). For now, this uses a placeholder
-    * ioctl that returns the result synchronously.
-    *
-    * TODO: integrate with the actual scheme:drm request/response
-    * protocol by calling drmCommandWriteRead or by using a dedicated
-    * 'ioctl with response' helper once the recipe-side IOCTL
-    * interface supports that mode.
+   /* The kernel writes the assigned seqno back into submit.seqno
+    * (bidirectional ioctl — no separate response struct on the wire).
+    * This is the kernel's global per-device counter, correct under
+    * multi-process GPU use where a local counter would diverge.
     */
-   result.seqno = rws->cs ? rws->cs->last_seqno + 1 : 1;
 
    /* Drop the batch BO; the kernel has copied from it into the ring. */
    redox_drm_bo_unmap(rws, batch_pr);
    redox_drm_bo_destroy(rws, batch_pr);
 
-   return result.seqno;
+   return submit.seqno;
 }
 
 uint64_t
 redox_drm_cs_query_last_seqno(struct redox_drm_winsys *rws)
 {
    struct RedoxCsWaitWire wait = {0};
-   struct RedoxCsWaitResultWire result = {0};
    int err;
 
    if (!rws)
@@ -184,10 +185,10 @@
       return rws->cs ? rws->cs->last_seqno : 0;
    }
 
-   /* Same write-then-read caveat as submit; for now the placeholder
-    * ioctl fills in result synchronously.
+   /* The kernel writes completed_seqno back into the wait struct
+    * (bidirectional ioctl — same struct for request and response).
     */
-   return result.completed_seqno;
+   return wait.completed_seqno;
 }
 
 struct redox_drm_cs *