vcl/headless/svpinst.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21 #include <sal/config.h>
  22
  23 #include <mutex>
  24
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <pthread.h>
  29 #include <sys/time.h>
  30 #include <sys/poll.h>
  31
  32 #include <sal/types.h>
  33 #include <sal/log.hxx>
  34
  35 #include <vcl/virdev.hxx>
  36 #include <vcl/inputtypes.hxx>
  37 #include <vcl/lok.hxx>
  38 #if HAVE_FEATURE_UI
  39 # include <vcl/opengl/OpenGLContext.hxx>
  40 #endif
  41
  42 #include <headless/svpinst.hxx>
  43 #include <headless/svpframe.hxx>
  44 #include <headless/svpdummies.hxx>
  45 #include <headless/svpvd.hxx>
  46 #ifdef IOS
  47 #include <quartz/salbmp.h>
  48 #include <quartz/salgdi.h>
  49 #include <quartz/salvd.h>
  50 #else
  51 #include <headless/svpgdi.hxx>
  52 #endif
  53 #include <headless/svpbmp.hxx>
  54
  55 #include <salframe.hxx>
  56 #include <svdata.hxx>
  57 #include <unx/gendata.hxx>
  58 // FIXME: remove when we re-work the svp mainloop
  59 #include <unx/salunxtime.h>
  60 #include <comphelper/lok.hxx>
  61
  62 SvpSalInstance* SvpSalInstance::s_pDefaultInstance = nullptr;
  63
  64 #if !defined(ANDROID) && !defined(IOS)
  65
  66 static void atfork_child()
  67 {
  68     if (SvpSalInstance::s_pDefaultInstance != nullptr)
  69     {
  70         SvpSalInstance::s_pDefaultInstance->CloseWakeupPipe(false);
  71         SvpSalInstance::s_pDefaultInstance->CreateWakeupPipe(false);
  72     }
  73 }
  74
  75 #endif
  76
  77 SvpSalInstance::SvpSalInstance( std::unique_ptr<SalYieldMutex> pMutex )
  78     : SalGenericInstance( std::move(pMutex) )
  79 {
  80     m_aTimeout.tv_sec       = 0;
  81     m_aTimeout.tv_usec      = 0;
  82     m_nTimeoutMS            = 0;
  83
  84     m_MainThread = osl::Thread::getCurrentIdentifier();
  85     CreateWakeupPipe(true);
  86     if( s_pDefaultInstance == nullptr )
  87         s_pDefaultInstance = this;
  88 #if !defined(ANDROID) && !defined(IOS)
  89     pthread_atfork(nullptr, nullptr, atfork_child);
  90 #endif
  91 }
  92
  93 SvpSalInstance::~SvpSalInstance()
  94 {
  95     if( s_pDefaultInstance == this )
  96         s_pDefaultInstance = nullptr;
  97     CloseWakeupPipe(true);
  98 }
  99
 100 void SvpSalInstance::CloseWakeupPipe(bool log)
 101 {
 102     SvpSalYieldMutex *const pMutex(dynamic_cast<SvpSalYieldMutex*>(GetYieldMutex()));
 103     if (!pMutex)
 104         return;
 105     if (pMutex->m_FeedbackFDs[0] != -1)
 106     {
 107         if (log)
 108         {
 109             SAL_INFO("vcl.headless", "CloseWakeupPipe: Closing inherited feedback pipe: [" << pMutex->m_FeedbackFDs[0] << "," << pMutex->m_FeedbackFDs[1] << "]");
 110         }
 111         close (pMutex->m_FeedbackFDs[0]);
 112         close (pMutex->m_FeedbackFDs[1]);
 113         pMutex->m_FeedbackFDs[0] = pMutex->m_FeedbackFDs[1] = -1;
 114     }
 115 }
 116
 117 void SvpSalInstance::CreateWakeupPipe(bool log)
 118 {
 119     SvpSalYieldMutex *const pMutex(dynamic_cast<SvpSalYieldMutex*>(GetYieldMutex()));
 120     if (!pMutex)
 121         return;
 122     if (pipe (pMutex->m_FeedbackFDs) == -1)
 123     {
 124         if (log)
 125         {
 126             SAL_WARN("vcl.headless", "Could not create feedback pipe: " << strerror(errno));
 127             std::abort();
 128         }
 129     }
 130     else
 131     {
 132         if (log)
 133         {
 134             SAL_INFO("vcl.headless", "CreateWakeupPipe: Created feedback pipe: [" << pMutex->m_FeedbackFDs[0] << "," << pMutex->m_FeedbackFDs[1] << "]");
 135         }
 136
 137         int flags;
 138
 139         // set close-on-exec descriptor flag.
 140         if ((flags = fcntl (pMutex->m_FeedbackFDs[0], F_GETFD)) != -1)
 141         {
 142             flags |= FD_CLOEXEC;
 143             (void) fcntl(pMutex->m_FeedbackFDs[0], F_SETFD, flags);
 144         }
 145         if ((flags = fcntl (pMutex->m_FeedbackFDs[1], F_GETFD)) != -1)
 146         {
 147             flags |= FD_CLOEXEC;
 148             (void) fcntl(pMutex->m_FeedbackFDs[1], F_SETFD, flags);
 149         }
 150
 151         // retain the default blocking I/O for feedback pipe
 152     }
 153 }
 154
 155 void SvpSalInstance::TriggerUserEventProcessing()
 156 {
 157     Wakeup();
 158 }
 159
 160 #ifndef NDEBUG
 161 static bool g_CheckedMutex = false;
 162 #endif
 163
 164 void SvpSalInstance::Wakeup(SvpRequest const request)
 165 {
 166 #ifndef NDEBUG
 167     if (!g_CheckedMutex)
 168     {
 169         assert(dynamic_cast<SvpSalYieldMutex*>(GetYieldMutex()) != nullptr
 170             && "This SvpSalInstance function requires use of SvpSalYieldMutex");
 171         g_CheckedMutex = true;
 172     }
 173 #endif
 174
 175     ImplSVData* pSVData = ImplGetSVData();
 176
 177     if (pSVData->mpWakeCallback && pSVData->mpPollClosure)
 178         pSVData->mpWakeCallback(pSVData->mpPollClosure);
 179
 180     SvpSalYieldMutex *const pMutex(static_cast<SvpSalYieldMutex*>(GetYieldMutex()));
 181     std::scoped_lock<std::mutex> g(pMutex->m_WakeUpMainMutex);
 182     if (request != SvpRequest::NONE)
 183         pMutex->m_Request = request;
 184     pMutex->m_wakeUpMain = true;
 185     pMutex->m_WakeUpMainCond.notify_one();
 186 }
 187
 188 bool SvpSalInstance::CheckTimeout( bool bExecuteTimers )
 189 {
 190     bool bRet = false;
 191     if( m_aTimeout.tv_sec ) // timer is started
 192     {
 193         timeval aTimeOfDay;
 194         gettimeofday( &aTimeOfDay, nullptr );
 195         if( aTimeOfDay >= m_aTimeout )
 196         {
 197             bRet = true;
 198             if( bExecuteTimers )
 199             {
 200                 // timed out, update timeout
 201                 m_aTimeout = aTimeOfDay;
 202                 m_aTimeout += m_nTimeoutMS;
 203
 204                 osl::Guard< comphelper::SolarMutex > aGuard( GetYieldMutex() );
 205
 206                 // notify
 207                 ImplSVData* pSVData = ImplGetSVData();
 208                 if( pSVData->maSchedCtx.mpSalTimer )
 209                     pSVData->maSchedCtx.mpSalTimer->CallCallback();
 210             }
 211         }
 212     }
 213     return bRet;
 214 }
 215
 216 SalFrame* SvpSalInstance::CreateChildFrame( SystemParentData* /*pParent*/, SalFrameStyleFlags nStyle )
 217 {
 218     return new SvpSalFrame( this, nullptr, nStyle );
 219 }
 220
 221 SalFrame* SvpSalInstance::CreateFrame( SalFrame* pParent, SalFrameStyleFlags nStyle )
 222 {
 223     return new SvpSalFrame( this, pParent, nStyle );
 224 }
 225
 226 void SvpSalInstance::DestroyFrame( SalFrame* pFrame )
 227 {
 228     delete pFrame;
 229 }
 230
 231 SalObject* SvpSalInstance::CreateObject( SalFrame*, SystemWindowData*, bool )
 232 {
 233     return new SvpSalObject;
 234 }
 235
 236 void SvpSalInstance::DestroyObject( SalObject* pObject )
 237 {
 238     delete pObject;
 239 }
 240
 241 #ifndef IOS
 242
 243 std::unique_ptr<SalVirtualDevice> SvpSalInstance::CreateVirtualDevice(SalGraphics* pGraphics,
 244                                                        long &nDX, long &nDY,
 245                                                        DeviceFormat eFormat,
 246                                                        const SystemGraphicsData* pGd)
 247 {
 248     SvpSalGraphics *pSvpSalGraphics = dynamic_cast<SvpSalGraphics*>(pGraphics);
 249     assert(pSvpSalGraphics);
 250 #ifndef ANDROID
 251     // tdf#127529 normally pPreExistingTarget is null and we are a true virtualdevice drawing to a backing buffer.
 252     // Occasionally, for canvas/slideshow, pPreExistingTarget is pre-provided as a hack to use the vcl drawing
 253     // apis to render onto a preexisting cairo surface. The necessity for that precedes the use of cairo in vcl proper
 254     cairo_surface_t* pPreExistingTarget = pGd ? static_cast<cairo_surface_t*>(pGd->pSurface) : nullptr;
 255 #else
 256     //ANDROID case
 257     (void)pGd;
 258     cairo_surface_t* pPreExistingTarget = nullptr;
 259 #endif
 260     std::unique_ptr<SalVirtualDevice> pNew(new SvpSalVirtualDevice(eFormat, pSvpSalGraphics->getSurface(), pPreExistingTarget));
 261     pNew->SetSize( nDX, nDY );
 262     return pNew;
 263 }
 264
 265 cairo_surface_t* get_underlying_cairo_surface(const VirtualDevice& rDevice)
 266 {
 267     return static_cast<SvpSalVirtualDevice*>(rDevice.mpVirDev.get())->GetSurface();
 268 }
 269
 270 #endif
 271
 272 SalTimer* SvpSalInstance::CreateSalTimer()
 273 {
 274     return new SvpSalTimer( this );
 275 }
 276
 277 SalSystem* SvpSalInstance::CreateSalSystem()
 278 {
 279     return new SvpSalSystem();
 280 }
 281
 282 std::shared_ptr<SalBitmap> SvpSalInstance::CreateSalBitmap()
 283 {
 284 #ifdef IOS
 285     return std::make_shared<QuartzSalBitmap>();
 286 #else
 287     return std::make_shared<SvpSalBitmap>();
 288 #endif
 289 }
 290
 291 void SvpSalInstance::ProcessEvent( SalUserEvent aEvent )
 292 {
 293     aEvent.m_pFrame->CallCallback( aEvent.m_nEvent, aEvent.m_pData );
 294     if( aEvent.m_nEvent == SalEvent::Resize )
 295     {
 296         // this would be a good time to post a paint
 297         const SvpSalFrame* pSvpFrame = static_cast<const SvpSalFrame*>( aEvent.m_pFrame);
 298         pSvpFrame->PostPaint();
 299     }
 300 #ifndef NDEBUG
 301     if (!g_CheckedMutex)
 302     {
 303         assert(dynamic_cast<SvpSalYieldMutex*>(GetYieldMutex()) != nullptr
 304             && "This SvpSalInstance function requires use of SvpSalYieldMutex");
 305         g_CheckedMutex = true;
 306     }
 307 #endif
 308     SvpSalYieldMutex *const pMutex(static_cast<SvpSalYieldMutex*>(GetYieldMutex()));
 309     pMutex->m_NonMainWaitingYieldCond.set();
 310 }
 311
 312 SvpSalYieldMutex::SvpSalYieldMutex()
 313 {
 314 #ifndef IOS
 315     m_FeedbackFDs[0] = m_FeedbackFDs[1] = -1;
 316 #endif
 317 }
 318
 319 SvpSalYieldMutex::~SvpSalYieldMutex()
 320 {
 321 }
 322
 323 void SvpSalYieldMutex::doAcquire(sal_uInt32 const nLockCount)
 324 {
 325     SvpSalInstance *const pInst = static_cast<SvpSalInstance *>(GetSalData()->m_pInstance);
 326     if (pInst && pInst->IsMainThread())
 327     {
 328         if (m_bNoYieldLock)
 329             return;
 330
 331         do
 332         {
 333             SvpRequest request = SvpRequest::NONE;
 334             {
 335                 std::unique_lock<std::mutex> g(m_WakeUpMainMutex);
 336                 if (m_aMutex.tryToAcquire()) {
 337                     // if there's a request, the other thread holds m_aMutex
 338                     assert(m_Request == SvpRequest::NONE);
 339                     m_wakeUpMain = false;
 340                     break;
 341                 }
 342                 m_WakeUpMainCond.wait(g, [this]() { return m_wakeUpMain; });
 343                 m_wakeUpMain = false;
 344                 std::swap(m_Request, request);
 345             }
 346             if (request != SvpRequest::NONE)
 347             {
 348                 // nested Yield on behalf of another thread
 349                 assert(!m_bNoYieldLock);
 350                 m_bNoYieldLock = true;
 351                 bool const bEvents = pInst->DoYield(false, request == SvpRequest::MainThreadDispatchAllEvents);
 352                 m_bNoYieldLock = false;
 353                 write(m_FeedbackFDs[1], &bEvents, sizeof(bool));
 354             }
 355         }
 356         while (true);
 357     }
 358     else
 359     {
 360         m_aMutex.acquire();
 361     }
 362     ++m_nCount;
 363     SalYieldMutex::doAcquire(nLockCount - 1);
 364 }
 365
 366 sal_uInt32 SvpSalYieldMutex::doRelease(bool const bUnlockAll)
 367 {
 368     SvpSalInstance *const pInst = static_cast<SvpSalInstance *>(GetSalData()->m_pInstance);
 369     if (pInst && pInst->IsMainThread())
 370     {
 371         if (m_bNoYieldLock)
 372             return 1;
 373         else
 374             return SalYieldMutex::doRelease(bUnlockAll);
 375     }
 376     sal_uInt32 nCount;
 377     {
 378         // read m_nCount before doRelease
 379         bool const isReleased(bUnlockAll || m_nCount == 1);
 380         nCount = comphelper::SolarMutex::doRelease( bUnlockAll );
 381
 382         if (isReleased)
 383         {
 384             if (vcl::lok::isUnipoll())
 385             {
 386                 if (pInst)
 387                     pInst->Wakeup(SvpRequest::NONE);
 388             }
 389             else
 390             {
 391                 std::scoped_lock<std::mutex> g(m_WakeUpMainMutex);
 392                 m_wakeUpMain = true;
 393                 m_WakeUpMainCond.notify_one();
 394             }
 395         }
 396     }
 397     return nCount;
 398 }
 399
 400 bool SvpSalYieldMutex::IsCurrentThread() const
 401 {
 402     if (GetSalData()->m_pInstance->IsMainThread() && m_bNoYieldLock)
 403     {
 404         return true;
 405     }
 406     else
 407     {
 408         return SalYieldMutex::IsCurrentThread();
 409     }
 410 }
 411
 412 bool SvpSalInstance::IsMainThread() const
 413 {
 414     return osl::Thread::getCurrentIdentifier() == m_MainThread;
 415 }
 416
 417 void SvpSalInstance::updateMainThread()
 418 {
 419     if (!IsMainThread())
 420     {
 421         m_MainThread = osl::Thread::getCurrentIdentifier();
 422         ImplGetSVData()->mnMainThreadId = osl::Thread::getCurrentIdentifier();
 423     }
 424 }
 425
 426 bool SvpSalInstance::DoYield(bool bWait, bool bHandleAllCurrentEvents)
 427 {
 428 #ifndef NDEBUG
 429     if (!g_CheckedMutex)
 430     {
 431         assert(dynamic_cast<SvpSalYieldMutex*>(GetYieldMutex()) != nullptr
 432             && "This SvpSalInstance function requires use of SvpSalYieldMutex");
 433         g_CheckedMutex = true;
 434     }
 435 #endif
 436
 437     // first, process current user events
 438     bool bEvent = DispatchUserEvents(bHandleAllCurrentEvents);
 439     if (!bHandleAllCurrentEvents && bEvent)
 440         return true;
 441
 442     bEvent = CheckTimeout() || bEvent;
 443
 444     SvpSalYieldMutex *const pMutex(static_cast<SvpSalYieldMutex*>(GetYieldMutex()));
 445
 446     if (IsMainThread())
 447     {
 448         if (bWait && ! bEvent)
 449         {
 450             int nTimeoutMS = 0;
 451             if (m_aTimeout.tv_sec) // Timer is started.
 452             {
 453                 timeval Timeout;
 454                 // determine remaining timeout.
 455                 gettimeofday (&Timeout, nullptr);
 456                 if (m_aTimeout > Timeout)
 457                 {
 458                     int nTimeoutMicroS = m_aTimeout.tv_usec - Timeout.tv_usec;
 459                     nTimeoutMS = (m_aTimeout.tv_sec - Timeout.tv_sec) * 1000
 460                                + nTimeoutMicroS / 1000;
 461                     if ( nTimeoutMicroS % 1000 )
 462                         nTimeoutMS += 1;
 463                 }
 464             }
 465             else
 466                 nTimeoutMS = -1; // wait until something happens
 467
 468             ImplSVData* pSVData = ImplGetSVData();
 469             sal_uInt32 nAcquireCount = ReleaseYieldMutexAll();
 470
 471             if (pSVData->mpPollCallback)
 472             {
 473                 // Poll for events from the LOK client.
 474                 if (nTimeoutMS < 0)
 475                     nTimeoutMS = 5000;
 476
 477                 // External poll.
 478                 if (pSVData->mpPollClosure != nullptr &&
 479                     pSVData->mpPollCallback(pSVData->mpPollClosure, nTimeoutMS * 1000 /* us */) < 0)
 480                     pSVData->maAppData.mbAppQuit = true;
 481             }
 482             else
 483             {
 484                 std::unique_lock<std::mutex> g(pMutex->m_WakeUpMainMutex);
 485                 // wait for doRelease() or Wakeup() to set the condition
 486                 if (nTimeoutMS == -1)
 487                 {
 488                     pMutex->m_WakeUpMainCond.wait(g,
 489                             [pMutex]() { return pMutex->m_wakeUpMain; });
 490                 }
 491                 else
 492                 {
 493                     pMutex->m_WakeUpMainCond.wait_for(g,
 494                             std::chrono::milliseconds(nTimeoutMS),
 495                             [pMutex]() { return pMutex->m_wakeUpMain; });
 496                 }
 497                 // here no need to check m_Request because Acquire will do it
 498             }
 499             AcquireYieldMutex( nAcquireCount );
 500         }
 501         else if (bEvent)
 502         {
 503             pMutex->m_NonMainWaitingYieldCond.set(); // wake up other threads
 504         }
 505     }
 506     else // !IsMainThread()
 507     {
 508         Wakeup(bHandleAllCurrentEvents
 509                 ? SvpRequest::MainThreadDispatchAllEvents
 510                 : SvpRequest::MainThreadDispatchOneEvent);
 511
 512         bool bDidWork(false);
 513         // blocking read (for synchronisation)
 514         auto const nRet = read(pMutex->m_FeedbackFDs[0], &bDidWork, sizeof(bool));
 515         assert(nRet == 1); (void) nRet;
 516         if (!bDidWork && bWait)
 517         {
 518             // block & release YieldMutex until the main thread does something
 519             pMutex->m_NonMainWaitingYieldCond.reset();
 520             sal_uInt32 nAcquireCount = ReleaseYieldMutexAll();
 521             pMutex->m_NonMainWaitingYieldCond.wait();
 522             AcquireYieldMutex( nAcquireCount );
 523         }
 524     }
 525
 526     return bEvent;
 527 }
 528
 529 bool SvpSalInstance::AnyInput( VclInputFlags nType )
 530 {
 531     if( nType & VclInputFlags::TIMER )
 532         return CheckTimeout( false );
 533     return false;
 534 }
 535
 536 OUString SvpSalInstance::GetConnectionIdentifier()
 537 {
 538     return OUString();
 539 }
 540
 541 void SvpSalInstance::StopTimer()
 542 {
 543     m_aTimeout.tv_sec   = 0;
 544     m_aTimeout.tv_usec  = 0;
 545     m_nTimeoutMS        = 0;
 546 }
 547
 548 void SvpSalInstance::StartTimer( sal_uInt64 nMS )
 549 {
 550     timeval aPrevTimeout (m_aTimeout);
 551     gettimeofday (&m_aTimeout, nullptr);
 552
 553     m_nTimeoutMS  = nMS;
 554     m_aTimeout    += m_nTimeoutMS;
 555
 556     if ((aPrevTimeout > m_aTimeout) || (aPrevTimeout.tv_sec == 0))
 557     {
 558         // Wakeup from previous timeout (or stopped timer).
 559         Wakeup();
 560     }
 561 }
 562
 563 void SvpSalInstance::AddToRecentDocumentList(const OUString&, const OUString&, const OUString&)
 564 {
 565 }
 566
 567 std::shared_ptr<vcl::BackendCapabilities> SvpSalInstance::GetBackendCapabilities()
 568 {
 569     auto pBackendCapabilities = SalInstance::GetBackendCapabilities();
 570     pBackendCapabilities->mbSupportsBitmap32 = true;
 571     return pBackendCapabilities;
 572 }
 573
 574 //obviously doesn't actually do anything, it's just a nonfunctional stub
 575
 576 #if HAVE_FEATURE_UI
 577
 578 class SvpOpenGLContext : public OpenGLContext
 579 {
 580     GLWindow m_aGLWin;
 581 private:
 582     virtual const GLWindow& getOpenGLWindow() const override { return m_aGLWin; }
 583     virtual GLWindow& getModifiableOpenGLWindow() override { return m_aGLWin; }
 584 };
 585
 586 OpenGLContext* SvpSalInstance::CreateOpenGLContext()
 587 {
 588     return new SvpOpenGLContext;
 589 }
 590
 591 #else
 592
 593 class SvpOpenGLContext
 594 {
 595 };
 596
 597 OpenGLContext* SvpSalInstance::CreateOpenGLContext()
 598 {
 599     return nullptr;
 600 }
 601
 602
 603 #endif
 604
 605 SvpSalTimer::~SvpSalTimer()
 606 {
 607 }
 608
 609 void SvpSalTimer::Stop()
 610 {
 611     m_pInstance->StopTimer();
 612 }
 613
 614 void SvpSalTimer::Start( sal_uInt64 nMS )
 615 {
 616     m_pInstance->StartTimer( nMS );
 617 }
 618
 619 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */