widget/nsShmImage.cpp
author Valentin Gosu <valentin.gosu@gmail.com>
Fri, 02 Nov 2018 17:38:37 -0400
changeset 501038 8016d0d1a391f1327a0375fb6d4f20228b2784aa
parent 490825 3ad8c54c6dc8978a3317544bea487cef8860db50
child 508163 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1503725 - Do not deallocate nsThreadShutdownContext when leaking thread. r=erahm, a=RyanVM Sometimes when we call ShutdownWithTimeout on a thread pool, the unresponsive thread that we leak will actually complete before the main thread is done. In that case, the thread will dereference the thread shutdown context, so we must intentionally leak it too. Differential Revision: https://phabricator.services.mozilla.com/D10645

/* -*- 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