gecko-dev/widget/nsShmImage.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsShmImage.h"

#ifdef MOZ_HAVE_SHMIMAGE
#  include "mozilla/X11Util.h"
#  include "mozilla/gfx/gfxVars.h"
#  include "mozilla/ipc/SharedMemory.h"
#  include "gfxPlatform.h"
#  include "nsPrintfCString.h"
#  include "nsTArray.h"

#  include <dlfcn.h>
#  include <errno.h>
#  include <string.h>
#  include <sys/ipc.h>
#  include <sys/shm.h>

extern "C" {
#  include <X11/ImUtil.h>
}

using namespace mozilla::ipc;
using namespace mozilla::gfx;

nsShmImage::nsShmImage(Display* aDisplay, Drawable aWindow, Visual* aVisual,
                       unsigned int aDepth)
    : mDisplay(aDisplay),
      mConnection(XGetXCBConnection(aDisplay)),
      mWindow(aWindow),
      mVisual(aVisual),
      mDepth(aDepth),
      mFormat(mozilla::gfx::SurfaceFormat::UNKNOWN),
      mSize(0, 0),
      mStride(0),
      mPixmap(XCB_NONE),
      mGC(XCB_NONE),
      mRequestPending(false),
      mShmSeg(XCB_NONE),
      mShmId(-1),
      mShmAddr(nullptr) {
  mozilla::PodZero(&mSyncRequest);
}

nsShmImage::~nsShmImage() { DestroyImage(); }

// If XShm isn't available to our client, we'll try XShm once, fail,
// set this to false and then never try again.
static bool gShmAvailable = true;
bool nsShmImage::UseShm() { return gShmAvailable; }

bool nsShmImage::CreateShmSegment() {
  size_t size = SharedMemory::PageAlignedSize(mStride * mSize.height);

#  if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
  static mozilla::LazyLogModule sPledgeLog("SandboxPledge");
  MOZ_LOG(sPledgeLog, mozilla::LogLevel::Debug,
          ("%s called when pledged, returning false\n", __func__));
  return false;
#  endif
  mShmId = shmget(IPC_PRIVATE, size, IPC_CREAT | 0600);
  if (mShmId == -1) {
    return false;
  }
  mShmAddr = (uint8_t*)shmat(mShmId, nullptr, 0);
  mShmSeg = xcb_generate_id(mConnection);

  // Mark the handle removed so that it will destroy the segment when unmapped.
  shmctl(mShmId, IPC_RMID, nullptr);

  if (mShmAddr == (void*)-1) {
    // Since mapping failed, the segment is already destroyed.
    mShmId = -1;

    nsPrintfCString warning("shmat(): %s (%d)\n", strerror(errno), errno);
    NS_WARNING(warning.get());
    return false;
  }

#  ifdef DEBUG
  struct shmid_ds info;
  if (shmctl(mShmId, IPC_STAT, &info) < 0) {
    return false;
  }

  MOZ_ASSERT(size <= info.shm_segsz, "Segment doesn't have enough space!");
#  endif

  return true;
}

void nsShmImage::DestroyShmSegment() {
  if (mShmId != -1) {
    shmdt(mShmAddr);
    mShmId = -1;
  }
}

static bool gShmInitialized = false;
static bool gUseShmPixmaps = false;

bool nsShmImage::InitExtension() {
  if (gShmInitialized) {
    return gShmAvailable;
  }

  gShmInitialized = true;

  // Bugs 1397918, 1293474 - race condition in libxcb fixed upstream as of
  // version 1.11. Since we can't query libxcb's version directly, the only
  // other option is to check for symbols that were added after 1.11.
  // xcb_discard_reply64 was added in 1.11.1, so check for existence of
  // that to verify we are using a version of libxcb with the bug fixed.
  // Otherwise, we can't risk using libxcb due to aforementioned crashes.
  if (!dlsym(RTLD_DEFAULT, "xcb_discard_reply64")) {
    gShmAvailable = false;
    return false;
  }

  const xcb_query_extension_reply_t* extReply;
  extReply = xcb_get_extension_data(mConnection, &xcb_shm_id);
  if (!extReply || !extReply->present) {
    gShmAvailable = false;
    return false;
  }

  xcb_shm_query_version_reply_t* shmReply = xcb_shm_query_version_reply(
      mConnection, xcb_shm_query_version(mConnection), nullptr);

  if (!shmReply) {
    gShmAvailable = false;
    return false;
  }

  gUseShmPixmaps = shmReply->shared_pixmaps &&
                   shmReply->pixmap_format == XCB_IMAGE_FORMAT_Z_PIXMAP;

  free(shmReply);

  return true;
}

bool nsShmImage::CreateImage(const IntSize& aSize) {
  MOZ_ASSERT(mConnection && mVisual);

  if (!InitExtension()) {
    return false;
  }

  mSize = aSize;

  BackendType backend = gfxVars::ContentBackend();

  mFormat = SurfaceFormat::UNKNOWN;
  switch (mDepth) {
    case 32:
      if (mVisual->red_mask == 0xff0000 && mVisual->green_mask == 0xff00 &&
          mVisual->blue_mask == 0xff) {
        mFormat = SurfaceFormat::B8G8R8A8;
      }
      break;
    case 24:
      // Only support the BGRX layout, and report it as BGRA to the compositor.
      // The alpha channel will be discarded when we put the image.
      // Cairo/pixman lacks some fast paths for compositing BGRX onto BGRA, so
      // just report it as BGRX directly in that case.
      if (mVisual->red_mask == 0xff0000 && mVisual->green_mask == 0xff00 &&
          mVisual->blue_mask == 0xff) {
        mFormat = backend == BackendType::CAIRO ? SurfaceFormat::B8G8R8X8
                                                : SurfaceFormat::B8G8R8A8;
      }
      break;
    case 16:
      if (mVisual->red_mask == 0xf800 && mVisual->green_mask == 0x07e0 &&
          mVisual->blue_mask == 0x1f) {
        mFormat = SurfaceFormat::R5G6B5_UINT16;
      }
      break;
  }

  if (mFormat == SurfaceFormat::UNKNOWN) {
    NS_WARNING("Unsupported XShm Image format!");
    gShmAvailable = false;
    return false;
  }

  // Round up stride to the display's scanline pad (in bits) as XShm expects.
  int scanlinePad = _XGetScanlinePad(mDisplay, mDepth);
  int bitsPerPixel = _XGetBitsPerPixel(mDisplay, mDepth);
  int bitsPerLine =
      ((bitsPerPixel * aSize.width + scanlinePad - 1) / scanlinePad) *
      scanlinePad;
  mStride = bitsPerLine / 8;

  if (!CreateShmSegment()) {
    DestroyImage();
    return false;
  }

  xcb_generic_error_t* error;
  xcb_void_cookie_t cookie;

  cookie = xcb_shm_attach_checked(mConnection, mShmSeg, mShmId, 0);

  if ((error = xcb_request_check(mConnection, cookie))) {
    NS_WARNING("Failed to attach MIT-SHM segment.");
    DestroyImage();
    gShmAvailable = false;
    free(error);
    return false;
  }

  if (gUseShmPixmaps) {
    mPixmap = xcb_generate_id(mConnection);
    cookie = xcb_shm_create_pixmap_checked(mConnection, mPixmap, mWindow,
                                           aSize.width, aSize.height, mDepth,
                                           mShmSeg, 0);

    if ((error = xcb_request_check(mConnection, cookie))) {
      // Disable shared pixmaps permanently if creation failed.
      mPixmap = XCB_NONE;
      gUseShmPixmaps = false;
      free(error);
    }
  }

  return true;
}

void nsShmImage::DestroyImage() {
  if (mGC) {
    xcb_free_gc(mConnection, mGC);
    mGC = XCB_NONE;
  }
  if (mPixmap != XCB_NONE) {
    xcb_free_pixmap(mConnection, mPixmap);
    mPixmap = XCB_NONE;
  }
  if (mShmSeg != XCB_NONE) {
    xcb_shm_detach_checked(mConnection, mShmSeg);
    mShmSeg = XCB_NONE;
  }
  DestroyShmSegment();
  // Avoid leaking any pending reply.  No real need to wait but CentOS 6 build
  // machines don't have xcb_discard_reply().
  WaitIfPendingReply();
}

// Wait for any in-flight shm-affected requests to complete.
// Typically X clients would wait for a XShmCompletionEvent to be received,
// but this works as it's sent immediately after the request is sent.
void nsShmImage::WaitIfPendingReply() {
  if (mRequestPending) {
    xcb_get_input_focus_reply_t* reply =
        xcb_get_input_focus_reply(mConnection, mSyncRequest, nullptr);
    free(reply);
    mRequestPending = false;
  }
}

already_AddRefed<DrawTarget> nsShmImage::CreateDrawTarget(
    const mozilla::LayoutDeviceIntRegion& aRegion) {
  WaitIfPendingReply();

  // Due to bug 1205045, we must avoid making GTK calls off the main thread to
  // query window size. Instead we just track the largest offset within the
  // image we are drawing to and grow the image to accomodate it. Since usually
  // the entire window is invalidated on the first paint to it, this should grow
  // the image to the necessary size quickly without many intermediate
  // reallocations.
  IntRect bounds = aRegion.GetBounds().ToUnknownRect();
  IntSize size(bounds.XMost(), bounds.YMost());
  if (size.width > mSize.width || size.height > mSize.height) {
    DestroyImage();
    if (!CreateImage(size)) {
      return nullptr;
    }
  }

  return gfxPlatform::CreateDrawTargetForData(
      reinterpret_cast<unsigned char*>(mShmAddr) + bounds.y * mStride +
          bounds.x * BytesPerPixel(mFormat),
      bounds.Size(), mStride, mFormat);
}

void nsShmImage::Put(const mozilla::LayoutDeviceIntRegion& aRegion) {
  AutoTArray<xcb_rectangle_t, 32> xrects;
  xrects.SetCapacity(aRegion.GetNumRects());

  for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
    const mozilla::LayoutDeviceIntRect& r = iter.Get();
    xcb_rectangle_t xrect = {(short)r.x, (short)r.y, (unsigned short)r.width,
                             (unsigned short)r.height};
    xrects.AppendElement(xrect);
  }

  if (!mGC) {
    mGC = xcb_generate_id(mConnection);
    xcb_create_gc(mConnection, mGC, mWindow, 0, nullptr);
  }

  xcb_set_clip_rectangles(mConnection, XCB_CLIP_ORDERING_YX_BANDED, mGC, 0, 0,
                          xrects.Length(), xrects.Elements());

  if (mPixmap != XCB_NONE) {
    xcb_copy_area(mConnection, mPixmap, mWindow, mGC, 0, 0, 0, 0, mSize.width,
                  mSize.height);
  } else {
    xcb_shm_put_image(mConnection, mWindow, mGC, mSize.width, mSize.height, 0,
                      0, mSize.width, mSize.height, 0, 0, mDepth,
                      XCB_IMAGE_FORMAT_Z_PIXMAP, 0, mShmSeg, 0);
  }

  // Send a request that returns a response so that we don't have to start a
  // sync in nsShmImage::CreateDrawTarget.
  mSyncRequest = xcb_get_input_focus(mConnection);
  mRequestPending = true;

  xcb_flush(mConnection);
}

#endif  // MOZ_HAVE_SHMIMAGE