1. 07 Jun, 2021 1 commit
    • Erik Kurzinger's avatar
      glx: don't create implicit GLXWindow if one already exists · b7a85e44
      Erik Kurzinger authored
      
      
      If a GLXMakeCurrent request specifies an X window as its drawable,
      __glXGetDrawable will implicitly create a GLXWindow for it. However,
      the client may have already explicitly created a GLXWindow for that X
      window. If that happens, two __glXDrawableRes resources will be added
      to the window.
      
      If the explicitly-created GLXWindow is later destroyed by the client,
      DrawableGone will call FreeResourceByType on the X window, but this
      will actually free the resource for the implicitly-created GLXWindow,
      since that one would be at the head of the list.
      
      Then if the X window is destroyed after that, the resource for the
      explicitly-created GLXWindow will be freed. But that GLXWindow was
      already destroyed above. This crashes the server when it tries to call
      the destroyed GLXWindow's destructor. It also means the
      implicitly-created GLXWindow would have been leaked since the
      FreeResourceByType call mentioned above skips calling the destructor.
      
      To fix this, if __glXGetDrawable is given an X window, it should check
      if there is already a GLXWindow associated with it, and only create an
      implicit one if there is not.
      Signed-off-by: Erik Kurzinger's avatarErik Kurzinger <ekurzinger@nvidia.com>
      Reviewed-by: Adam Jackson's avatarAdam Jackson <ajax@redhat.com>
      b7a85e44
  2. 01 Jun, 2021 1 commit
    • Jan Beich's avatar
      meson: provide fallback for *proto dependencies · 8274dd66
      Jan Beich authored
      Meson has a built-in facility to use bundled versions of dependencies
      if system packages are too old. Enable for xorgproto after 8e504d8b:
      
      Run-time dependency xproto found: YES 7.0.33
      Run-time dependency randrproto found: YES 1.6.0
      Run-time dependency renderproto found: YES 0.11.1
      Run-time dependency xextproto found: YES 7.3.0
      Dependency inputproto found: NO found 2.3.2 but need: '>= 2.3.99.1'
      Found CMake: /usr/local/bin/cmake (3.20.2)
      Run-time dependency inputproto found: NO (tried pkgconfig and cmake)
      Looking for a fallback subproject for the dependency inputproto
      
      meson.build:73:0: ERROR: Neither a subproject directory nor a xorgproto.wrap file was found.
      8274dd66
  3. 31 May, 2021 3 commits
  4. 30 May, 2021 23 commits
  5. 27 May, 2021 1 commit
  6. 20 May, 2021 1 commit
    • Erik Kurzinger's avatar
      xwayland/eglstream: flush stream after eglSwapBuffers · 7515c23a
      Erik Kurzinger authored
      When eglSwapBuffers inserts a new frame into a window's stream, there may be a
      delay before the state of the consumer end of the stream is updated to reflect
      this. If the subsequent wl_surface_attach, wl_surface_damage, wl_surface_commit
      calls are received by the compositor before then, it will (typically) re-use
      the previous frame acquired from the stream instead of the latest one.
      
      This can leave the window displaying out-of-date contents, which might never be
      updated thereafter.
      
      To fix this, after calling eglSwapBuffers, xwl_glamor_eglstream_post_damage
      should call eglStreamFlushNV. This call will block until it can be guaranteed
      that the state of the consumer end of the stream has been updated to reflect
      that a new frame is available.
      
      Closes: xorg/xserver#1171
      
      Signed-off-by: Erik Kurzinger's avatarErik Kurzinger <ekurzinger@nvidia.com>
      7515c23a
  7. 18 May, 2021 1 commit
  8. 17 May, 2021 1 commit
  9. 11 May, 2021 8 commits
    • Olivier Fourdan's avatar
      xwayland/eglstream: Set ALU to GXCopy for blitting · 012350e3
      Olivier Fourdan authored
      
      
      The EGLstream backend's post damage function uses a shader and
      glDrawArrays() to copy the data from the glamor's pixmap texture prior
      to do the eglSwapBuffers().
      
      However, glDrawArrays() can be affected by the GL state, and therefore
      not reliably produce the expected copy, causing the content of the
      buffer to be corrupted.
      
      Make sure to set the ALU to GXCopy prior to call glDrawArrays() to get
      the expected result.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Suggested-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      012350e3
    • Olivier Fourdan's avatar
      xwayland/eglstream: Do not always increment pixmap refcnt on commit · d85bfa6a
      Olivier Fourdan authored
      
      
      Currently, the EGLstream backend would increment the pixmap refcount for
      each commit, and decrease that refcount on the wl_buffer release
      callback.
      
      But that's relying on the compositor sending us a release callback for
      each commit, otherwise the pixmap refcount will keep increasing and the
      pixmap will be leaked.
      
      So instead, increment the refcount on the pixmap only when we have not
      received a release notification for the wl_buffer, to avoid increasing
      the pixmap refcount more than once without a corresponding release
      event.
      
      This way, if the pixmap is still in use when released on the X11 side,
      the EGL stream will be kept until the compositor releases it.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Suggested-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      d85bfa6a
    • Olivier Fourdan's avatar
      xwayland/eglstream: Check eglSwapBuffers() · b583395c
      Olivier Fourdan authored
      
      
      EGLstream's post_damage() would unconditionally return success
      regardless of the actual status of the eglSwapBuffers().
      
      Yet, if eglSwapBuffers() fails, we should not post the corresponding
      damage as they wouldn't match the actual content of the buffer.
      
      Use the eglSwapBuffers() return value as the return value for
      post_damage() and do not take a refrence on the pixmap if it fails.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      b583395c
    • Olivier Fourdan's avatar
      xwayland/eglstream: Fix calloc/malloc · a4579997
      Olivier Fourdan authored
      
      
      Use calloc() instead of malloc() like the rest of the code.
      
      Also fix the arguments of calloc() calls to match the definition which
      is calloc(size_t nmemb, size_t size).
      
      This is a cleanup patch, no functional change.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      a4579997
    • Olivier Fourdan's avatar
      xwayland/eglstream: Do not commit without surface · 098e0f52
      Olivier Fourdan authored
      
      
      The EGL surface for the xwl_pixmap is created once the stream is ready
      and valid.
      
      If the pixmap's EGL surface fails, for whatever reason, the xwl_pixmap
      will be unusable and will end up as an invalid wl_buffer.
      
      Make sure we do not allow commits in that case and recreate the
      xwl_pixmap/stream.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      #1156
      098e0f52
    • Olivier Fourdan's avatar
      xwayland/eglstream: Drop the list of pending streams · bee2ebb2
      Olivier Fourdan authored
      
      
      Now that the pending stream is associated with the xwl_pixmap for
      EGLStream and the xwl_pixmap itself is associated to the pixmap, we have
      a reliable way to get to those data from any pending stream.
      
      As a result, the list of pending streams that we keep in the EGLStream
      global structure becomes useless.
      
      So we can drop the pending stream's xwl_pixmap and also the list of
      pending streams altogether, and save us a walk though that list for each
      callback.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Suggested-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      bee2ebb2
    • Olivier Fourdan's avatar
      xwayland/eglstream: Keep a reference to the pixmap · e19bf86c
      Olivier Fourdan authored
      Commit affc4745 - "xwayland: Drop the separate refcount for the
      xwl_pixmap" removed the separate reference counter for the xwl_pixmap
      which holds the EGLStream.
      
      While that works fine for the common case, if the window's pixmap is
      changed before the stream is ready, the older pixmap will be destroyed
      and the xwl_pixmap along with it, even if the compositor is still using
      the stream.
      
      The code that was removed with commit affc4745
      
       was taking care of that
      by increasing the separate reference counter for the xwl_pixmap, but it
      no longer the case.
      
      As a result, we may end up with the EGL stream in the wrong state when
      trying to use it, which will cascade down into all sort of issues.
      
      To avoid the problem, increase the reference count on the pixmap when it
      is marked as invalid in EGLStream's SetWindowPixmap().
      
      This way, the xwl_pixmap and the EGLStream are kept until released by
      the compositor, even when the pixmap changes before stream is ready.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      Fixes: affc4745 xwayland: Drop the separate refcount for the xwl_pixmap
      xorg/xserver#1156
      e19bf86c
    • Olivier Fourdan's avatar
      xwayland/eglstream: Dissociate pending stream from window · cb61ecc7
      Olivier Fourdan authored
      Previously, we would have pending streams associated with top level X11
      windows, keeping temporary accounting for the pending streams before
      they get fully initialized for the xwl_pixmap which would be associated
      with X11 pixmaps.
      
      If the window content changes before the stream is ready, the
      corresponding pending stream would be marked as invalid and the pending
      stream would be eventually removed once the stream becomes ready.
      
      Since commit affc4745
      
       - "xwayland: Drop the separate refcount for the
      xwl_pixmap", we no longer keep a separate reference counter for the
      xwl_pixmap, but rather tie it to the X11 pixmap lifespan. Yet, the
      pending stream would still be associated with the X11 toplevel window.
      
      Dissociate the pending streams from the X11 toplevel window, to keep it
      tied only to the xwl_pixmap so that we can have:
      
       - pixmap <-> xwl_pixmap
       - xwl_pixmap <-> pending stream
      
      Of course, the pending streams remain temporary and get removed as soon
      as the ready callback is triggered, but the pending streams are not
      linked to the X11 window anymore which can change their content, and
      therefore their X11 pixmap at any time.
      Signed-off-by: default avatarOlivier Fourdan <ofourdan@redhat.com>
      Reviewed-by: Michel Dänzer's avatarMichel Dänzer <mdaenzer@redhat.com>
      xorg/xserver#1156
      cb61ecc7