File indexing completed on 2024-05-19 03:56:18

 /*
  *    This file is part of the KDE project.
  *
  *    SPDX-FileCopyrightText: 2010 Michael Pyne <mpyne@kde.org>
  *    SPDX-License-Identifier: LGPL-2.0-only
  */
 
 #include "ksdclock_p.h"
 
 #include "kcoreaddons_debug.h"
 
 #include <memory>
 
 /**
  * This is a method to determine the best lock type to use for a
  * shared cache, based on local support. An identifier to the appropriate
  * SharedLockId is returned, which can be passed to createLockFromId().
  */
 SharedLockId findBestSharedLock()
 {
     // We would prefer a process-shared capability that also supports
     // timeouts. Failing that, process-shared is preferred over timeout
     // support. Failing that we'll go thread-local
     bool timeoutsSupported = false;
     bool pthreadsProcessShared = false;
     bool semaphoresProcessShared = false;
 
 #ifdef KSDC_TIMEOUTS_SUPPORTED
     timeoutsSupported = ::sysconf(_SC_TIMEOUTS) >= 200112L;
 #endif
 
 // Now that we've queried timeouts, try actually creating real locks and
 // seeing if there's issues with that.
 #ifdef KSDC_THREAD_PROCESS_SHARED_SUPPORTED
     {
         pthread_mutex_t tempMutex;
         std::unique_ptr<KSDCLock> tempLock;
         if (timeoutsSupported) {
 #ifdef KSDC_TIMEOUTS_SUPPORTED
             tempLock = std::make_unique<pthreadTimedLock>(tempMutex);
 #endif
         } else {
             tempLock = std::make_unique<pthreadLock>(tempMutex);
         }
 
         tempLock->initialize(pthreadsProcessShared);
     }
 #endif // KSDC_THREAD_PROCESS_SHARED_SUPPORTED
 
     // Our first choice is pthread_mutex_t for compatibility.
     if (timeoutsSupported && pthreadsProcessShared) {
         return LOCKTYPE_MUTEX;
     }
 
 #ifdef KSDC_SEMAPHORES_SUPPORTED
     {
         sem_t tempSemaphore;
         std::unique_ptr<KSDCLock> tempLock;
         if (timeoutsSupported) {
             tempLock = std::make_unique<semaphoreTimedLock>(tempSemaphore);
         } else {
             tempLock = std::make_unique<semaphoreLock>(tempSemaphore);
         }
 
         tempLock->initialize(semaphoresProcessShared);
     }
 #endif // KSDC_SEMAPHORES_SUPPORTED
 
     if (timeoutsSupported && semaphoresProcessShared) {
         return LOCKTYPE_SEMAPHORE;
     } else if (pthreadsProcessShared) {
         return LOCKTYPE_MUTEX;
     } else if (semaphoresProcessShared) {
         return LOCKTYPE_SEMAPHORE;
     }
 
     // Fallback to a dumb-simple but possibly-CPU-wasteful solution.
     return LOCKTYPE_SPINLOCK;
 }
 
 KSDCLock *createLockFromId(SharedLockId id, SharedLock &lock)
 {
     switch (id) {
 #ifdef KSDC_THREAD_PROCESS_SHARED_SUPPORTED
     case LOCKTYPE_MUTEX:
 #ifdef KSDC_TIMEOUTS_SUPPORTED
         if (::sysconf(_SC_TIMEOUTS) >= 200112L) {
             return new pthreadTimedLock(lock.mutex);
         }
 #endif
         return new pthreadLock(lock.mutex);
 
         break;
 #endif // KSDC_THREAD_PROCESS_SHARED_SUPPORTED
 
 #ifdef KSDC_SEMAPHORES_SUPPORTED
     case LOCKTYPE_SEMAPHORE:
 #ifdef KSDC_TIMEOUTS_SUPPORTED
         if (::sysconf(_SC_SEMAPHORES) >= 200112L) {
             return new semaphoreTimedLock(lock.semaphore);
         }
 #endif
         return new semaphoreLock(lock.semaphore);
 
         break;
 #endif // KSDC_SEMAPHORES_SUPPORTED
 
     case LOCKTYPE_SPINLOCK:
         return new simpleSpinLock(lock.spinlock);
         break;
 
     default:
         qCCritical(KCOREADDONS_DEBUG) << "Creating shell of a lock!";
         return new KSDCLock;
     }
 }