linux/input: fix abs->rel cursor feedback (output-local coords + seqlock)

- Publish the cursor position relative to the captured output (no desktop
  offset); the consumer compares against touch-port coordinates, which are
  output-relative, so adding the offset mis-anchored the estimate on
  multi-monitor setups.
- Make the feedback read/write consistent with a seqlock so the input path
  never observes a half-updated snapshot (position from one frame, extents
  from another).

Author: danalec

src/input.cpp

@@ -829,23 +829,43 @@ namespace input {
   abs_mouse_sync_estimate(const std::shared_ptr<input_t> &input, bool client_idle, bool sat_x, bool sat_y, float port_w, float port_h) {
     const auto &fb = platf::kms_cursor_feedback();
 
-    const auto seq = fb.seq.load();
+    // Seqlock read: retry while the writer is mid-update, and validate the
+    // sequence is unchanged after snapshotting the fields.
+    std::uint64_t seq;
+    std::int32_t cursor_x;
+    std::int32_t cursor_y;
+    std::int32_t phys_w;
+    std::int32_t phys_h;
+    std::int32_t logical_w;
+    std::int32_t logical_h;
+    for (;;) {
+      seq = fb.seq.load();
+      if (seq & 1) {
+        continue;
+      }
+      cursor_x = fb.x.load();
+      cursor_y = fb.y.load();
+      phys_w = fb.desktop_w.load();
+      phys_h = fb.desktop_h.load();
+      logical_w = fb.logical_w.load();
+      logical_h = fb.logical_h.load();
+      if (seq == fb.seq.load()) {
+        break;
+      }
+    }
+
     if (seq == 0 || seq == input->abs_mouse.seq_last) {
       return;
     }
     input->abs_mouse.seq_last = seq;
 
-    const auto phys_w = static_cast<float>(fb.desktop_w.load());
-    const auto phys_h = static_cast<float>(fb.desktop_h.load());
-    const auto logical_w = static_cast<float>(fb.logical_w.load());
-    const auto logical_h = static_cast<float>(fb.logical_h.load());
-    if (phys_w <= 0.0f || phys_h <= 0.0f || logical_w <= 0.0f || logical_h <= 0.0f) {
+    if (phys_w <= 0 || phys_h <= 0 || logical_w <= 0 || logical_h <= 0) {
       return;
     }
 
-    // Desktop physical pixels -> compositor logical pixels.
-    const auto real_x = static_cast<float>(fb.x.load()) * (logical_w / phys_w);
-    const auto real_y = static_cast<float>(fb.y.load()) * (logical_h / phys_h);
+    // Output-local physical pixels -> compositor logical pixels.
+    const auto real_x = static_cast<float>(cursor_x) * (static_cast<float>(logical_w) / static_cast<float>(phys_w));
+    const auto real_y = static_cast<float>(cursor_y) * (static_cast<float>(logical_h) / static_cast<float>(phys_h));
 
     if (client_idle) {
       input->abs_mouse.host_x = std::clamp(real_x, 0.0f, port_w - 1.0f);

src/platform/common.h

@@ -79,17 +79,23 @@ namespace platf {
   // The KMS backend reads the cursor plane position once per captured frame and
   // publishes it here so the input path can close the loop of the abs->rel
   // mouse conversion (see config: absolute_mouse_as_relative). Coordinates are
-  // in desktop physical pixels; the logical extents allow rescaling to the
-  // compositor's logical space. seq starts at 0 and is bumped on every update,
-  // so consumers can tell fresh values from stale ones.
+  // OUTPUT-LOCAL physical pixels (relative to the captured output, with no
+  // desktop offset); the logical extents allow rescaling to the compositor's
+  // logical space. The consumer compares against touch-port coordinates
+  // (0..port), so the position must stay relative to the output, not the
+  // desktop.
+  //
+  // seq doubles as a seqlock: the writer bumps it to an odd value, publishes
+  // the fields, then bumps it back to an even value. Readers must only consume
+  // a snapshot taken while seq is even and stable across the read.
   struct kms_cursor_feedback_t {
     std::atomic_int32_t x { -1 };
     std::atomic_int32_t y { -1 };
     std::atomic_int32_t desktop_w { 0 };  ///< Physical width of the streamed output.
     std::atomic_int32_t desktop_h { 0 };  ///< Physical height of the streamed output.
     std::atomic_int32_t logical_w { 0 };  ///< Logical width of the streamed output.
     std::atomic_int32_t logical_h { 0 };  ///< Logical height of the streamed output.
-    std::atomic_uint64_t seq { 0 };
+    std::atomic_uint64_t seq { 0 };  ///< Seqlock: odd while writing, even when consistent.
   };
 
   /**

src/platform/linux/kmsgrab.cpp

@@ -1253,12 +1253,14 @@ namespace platf {
 
         // Publish the real cursor position for the abs->rel input conversion
         // (see config: absolute_mouse_as_relative). Cursor-plane CRTC
-        // coordinates are CRTC-local physical pixels; add the output's desktop
-        // offset and publish the output extents so the consumer can rescale
-        // to logical touch-port units.
+        // coordinates are output-local physical pixels (relative to the
+        // captured output, no desktop offset); publish them together with the
+        // output extents so the consumer can rescale to logical touch-port
+        // units. The fields are written under a seqlock (seq odd while writing).
         auto &cursor_fb = platf::kms_cursor_feedback();
-        cursor_fb.x.store(offset_x + *prop_crtc_x);
-        cursor_fb.y.store(offset_y + *prop_crtc_y);
+        cursor_fb.seq.fetch_add(1);
+        cursor_fb.x.store(*prop_crtc_x);
+        cursor_fb.y.store(*prop_crtc_y);
         cursor_fb.desktop_w.store(width);
         cursor_fb.desktop_h.store(height);
         cursor_fb.logical_w.store(logical_width);