File indexing completed on 2024-11-10 04:57:33

 /*
     SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "config-kwin.h"
 
 #include "wayland/shmclientbuffer.h"
 #include "wayland/display.h"
 #include "wayland/shmclientbuffer_p.h"
 
 #include <drm_fourcc.h>
 #include <fcntl.h>
 #include <mutex>
 #include <signal.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 
 namespace KWin
 {
 
 static constexpr int s_version = 1;
 
 static constexpr uint32_t s_formats[] = {
     WL_SHM_FORMAT_ARGB8888,
     WL_SHM_FORMAT_XRGB8888,
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
     WL_SHM_FORMAT_ARGB2101010,
     WL_SHM_FORMAT_XRGB2101010,
     WL_SHM_FORMAT_ABGR2101010,
     WL_SHM_FORMAT_XBGR2101010,
     WL_SHM_FORMAT_ABGR16161616,
     WL_SHM_FORMAT_XBGR16161616,
 #endif
 };
 
 class ShmSigbusData
 {
 public:
     ShmPool *pool = nullptr;
     int accessCount = 0;
 };
 
 static thread_local ShmSigbusData sigbusData;
 static struct sigaction prevSigbusAction;
 
 static uint32_t shmFormatToDrmFormat(uint32_t shmFormat)
 {
     switch (shmFormat) {
     case WL_SHM_FORMAT_ARGB8888:
         return DRM_FORMAT_ARGB8888;
     case WL_SHM_FORMAT_XRGB8888:
         return DRM_FORMAT_XRGB8888;
     default:
         return shmFormat; // other wl_shm formats match the drm formats
     }
 }
 
 ShmPool::ShmPool(ShmClientBufferIntegration *integration, wl_client *client, int id, uint32_t version, FileDescriptor &&fd, MemoryMap &&mapping)
     : QtWaylandServer::wl_shm_pool(client, id, version)
     , integration(integration)
     , mapping(std::move(mapping))
     , fd(std::move(fd))
 {
 #if HAVE_MEMFD
     const int seals = fcntl(this->fd.get(), F_GET_SEALS);
     if (seals != -1) {
         struct stat statbuf;
         if ((seals & F_SEAL_SHRINK) && fstat(this->fd.get(), &statbuf) >= 0) {
             sigbusImpossible = statbuf.st_size >= this->mapping.size();
         }
     }
 #endif
 }
 
 void ShmPool::ref()
 {
     ++refCount;
 }
 
 void ShmPool::unref()
 {
     --refCount;
     if (refCount == 0) {
         delete this;
     }
 }
 
 void ShmPool::shm_pool_destroy_resource(Resource *resource)
 {
     unref();
 }
 
 void ShmPool::shm_pool_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void ShmPool::shm_pool_create_buffer(Resource *resource, uint32_t id, int32_t offset, int32_t width, int32_t height, int32_t stride, uint32_t format)
 {
     if (std::find(std::begin(s_formats), std::end(s_formats), format) == std::end(s_formats)) {
         wl_resource_post_error(resource->handle,
                                WL_SHM_ERROR_INVALID_FORMAT,
                                "invalid format 0x%x",
                                format);
         return;
     }
 
     if (offset < 0 || width <= 0 || height <= 0 || stride < width
         || INT32_MAX / stride < height || offset > mapping.size() - stride * height) {
         wl_resource_post_error(resource->handle,
                                WL_SHM_ERROR_INVALID_STRIDE,
                                "invalid width, height or stride (%dx%d, %u)",
                                width, height, stride);
         return;
     }
 
     ShmAttributes attributes{
         .fd = fd.duplicate(),
         .stride = stride,
         .offset = offset,
         .size = QSize(width, height),
         .format = shmFormatToDrmFormat(format),
     };
 
     new ShmClientBuffer(this, std::move(attributes), resource->client(), id);
 }
 
 void ShmPool::shm_pool_resize(Resource *resource, int32_t size)
 {
     if (size < mapping.size()) {
         wl_resource_post_error(resource->handle, WL_SHM_ERROR_INVALID_FD, "shrinking pool invalid");
         return;
     }
 
     auto remapping = MemoryMap(size, PROT_READ | PROT_WRITE, MAP_SHARED, fd.get(), 0);
     if (remapping.isValid()) {
         mapping = std::move(remapping);
     } else {
         wl_resource_post_error(resource->handle, WL_SHM_ERROR_INVALID_FD, "failed to map shm pool with the new size");
     }
 }
 
 void ShmClientBuffer::buffer_destroy_resource(wl_resource *resource)
 {
     if (ShmClientBuffer *buffer = ShmClientBuffer::get(resource)) {
         buffer->m_resource = nullptr;
         buffer->drop();
     }
 }
 
 void ShmClientBuffer::buffer_destroy(wl_client *client, wl_resource *resource)
 {
     wl_resource_destroy(resource);
 }
 
 const struct wl_buffer_interface ShmClientBuffer::implementation = {
     .destroy = buffer_destroy,
 };
 
 ShmClientBuffer::ShmClientBuffer(ShmPool *pool, ShmAttributes attributes, wl_client *client, uint32_t id)
     : m_shmPool(pool)
     , m_shmAttributes(std::move(attributes))
 {
     m_shmPool->ref();
 
     connect(this, &GraphicsBuffer::released, [this]() {
         wl_buffer_send_release(m_resource);
     });
 
     m_resource = wl_resource_create(client, &wl_buffer_interface, 1, id);
     wl_resource_set_implementation(m_resource, &implementation, this, buffer_destroy_resource);
 }
 
 ShmClientBuffer::~ShmClientBuffer()
 {
     m_shmPool->unref();
 }
 
 QSize ShmClientBuffer::size() const
 {
     return m_shmAttributes.size;
 }
 
 bool ShmClientBuffer::hasAlphaChannel() const
 {
     return alphaChannelFromDrmFormat(m_shmAttributes.format);
 }
 
 const ShmAttributes *ShmClientBuffer::shmAttributes() const
 {
     return &m_shmAttributes;
 }
 
 ShmClientBuffer *ShmClientBuffer::get(wl_resource *resource)
 {
     if (wl_resource_instance_of(resource, &wl_buffer_interface, &implementation)) {
         return static_cast<ShmClientBuffer *>(wl_resource_get_user_data(resource));
     }
     return nullptr;
 }
 
 static void sigbusHandler(int signum, siginfo_t *info, void *context)
 {
     auto reraise = [&]() {
         if (prevSigbusAction.sa_flags & SA_SIGINFO) {
             prevSigbusAction.sa_sigaction(signum, info, context);
         } else {
             prevSigbusAction.sa_handler(signum);
         }
     };
 
     const ShmPool *pool = sigbusData.pool;
     if (!pool) {
         reraise();
         return;
     }
 
     const uchar *addr = static_cast<uchar *>(info->si_addr);
     const uchar *mappingStart = static_cast<uchar *>(pool->mapping.data());
     if (addr < mappingStart || addr >= mappingStart + pool->mapping.size()) {
         reraise();
         return;
     }
 
     // Replace the faulty mapping with a new one that's filled with zeros.
     if (mmap(pool->mapping.data(), pool->mapping.size(), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0) == MAP_FAILED) {
         reraise();
         return;
     }
 }
 
 GraphicsBuffer::Map ShmClientBuffer::map(MapFlags flags)
 {
     if (!m_shmPool->sigbusImpossible) {
         // A SIGBUS signal may be emitted if the backing file is shrinked and we access now
         // removed pages. Install a signal handler to handle this case. Note that if the
         // backing file has F_SEAL_SHRINK seal, then we don't need to do anything.
 
         static std::once_flag sigbusOnce;
         std::call_once(sigbusOnce, []() {
             struct sigaction action;
             memset(&action, 0, sizeof(action));
             sigemptyset(&action.sa_mask);
             action.sa_sigaction = sigbusHandler;
             action.sa_flags = SA_SIGINFO | SA_NODEFER;
             sigaction(SIGBUS, &action, &prevSigbusAction);
         });
 
         Q_ASSERT(!sigbusData.pool || sigbusData.pool == m_shmPool);
         sigbusData.pool = m_shmPool;
         ++sigbusData.accessCount;
     }
 
     return Map{
         .data = reinterpret_cast<uchar *>(m_shmPool->mapping.data()) + m_shmAttributes.offset,
         .stride = uint32_t(m_shmAttributes.stride),
     };
 }
 
 void ShmClientBuffer::unmap()
 {
     if (m_shmPool->sigbusImpossible) {
         return;
     }
 
     Q_ASSERT(sigbusData.accessCount > 0);
     --sigbusData.accessCount;
     if (sigbusData.accessCount == 0) {
         sigbusData.pool = nullptr;
     }
 }
 
 ShmClientBufferIntegrationPrivate::ShmClientBufferIntegrationPrivate(Display *display, ShmClientBufferIntegration *q)
     : QtWaylandServer::wl_shm(*display, s_version)
     , q(q)
 {
 }
 
 void ShmClientBufferIntegrationPrivate::shm_bind_resource(Resource *resource)
 {
     for (const uint32_t &format : s_formats) {
         send_format(resource->handle, format);
     }
 }
 
 void ShmClientBufferIntegrationPrivate::shm_create_pool(Resource *resource, uint32_t id, int32_t fd, int32_t size)
 {
     FileDescriptor fileDescriptor{fd};
 
     if (size <= 0) {
         wl_resource_post_error(resource->handle, error_invalid_stride, "invalid size (%d)", size);
         return;
     }
 
     auto mapping = MemoryMap(size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (!mapping.isValid()) {
         wl_resource_post_error(resource->handle, error_invalid_fd, "failed to map shm pool");
         return;
     }
 
     new ShmPool(q, resource->client(), id, resource->version(), std::move(fileDescriptor), std::move(mapping));
 }
 
 ShmClientBufferIntegration::ShmClientBufferIntegration(Display *display)
     : QObject(display)
     , d(new ShmClientBufferIntegrationPrivate(display, this))
 {
 }
 
 ShmClientBufferIntegration::~ShmClientBufferIntegration()
 {
 }
 
 } // namespace KWin
 
 #include "moc_shmclientbuffer_p.cpp"
 
 #include "moc_shmclientbuffer.cpp"