qsharedmemory.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsharedmemory.h"
#include "qsharedmemory_p.h"
 
#include "qtipccommon_p.h"
#include "qsystemsemaphore.h"
 
#include <q20memory.h>
#include <qdebug.h>
#ifdef Q_OS_WIN
#  include <qt_windows.h>
#endif
 
#ifndef MAX_PATH
#  define MAX_PATH PATH_MAX
#endif
 
QT_BEGIN_NAMESPACE
 
#if QT_CONFIG(sharedmemory)
 
using namespace QtIpcCommon;
using namespace Qt::StringLiterals;
 
QSharedMemoryPrivate::~QSharedMemoryPrivate()
{
    destructBackend();
}
 
inline void QSharedMemoryPrivate::constructBackend()
{
    using namespace q20;
    visit([](auto p) { construct_at(p); });
}
 
inline void QSharedMemoryPrivate::destructBackend()
{
    visit([](auto p) { std::destroy_at(p); });
}
 
#if QT_CONFIG(systemsemaphore)
inline QNativeIpcKey QSharedMemoryPrivate::semaphoreNativeKey() const
{
    if (isIpcSupported(IpcType::SharedMemory, QNativeIpcKey::Type::Windows)
            && nativeKey.type() == QNativeIpcKey::Type::Windows) {
        // native keys are plain kernel object names, limited to MAX_PATH
        auto suffix = "_sem"_L1;
        QString semkey = nativeKey.nativeKey();
        semkey.truncate(MAX_PATH - suffix.size() - 1);
        semkey += suffix;
        return { semkey, QNativeIpcKey::Type::Windows };
    }
 
    // System V and POSIX keys appear to operate in different namespaces, so we
    // can just use the same native key
    return nativeKey;
}
#endif
 
QSharedMemory::QSharedMemory(QObject *parent)
    : QSharedMemory(QNativeIpcKey(), parent)
{
}
 
QSharedMemory::QSharedMemory(const QNativeIpcKey &key, QObject *parent)
    : QObject(*new QSharedMemoryPrivate(key.type()), parent)
{
    setNativeKey(key);
}
 
QSharedMemory::QSharedMemory(const QString &key, QObject *parent)
    : QSharedMemory(legacyNativeKey(key), parent)
{
}
 
QSharedMemory::~QSharedMemory()
{
    Q_D(QSharedMemory);
    if (isAttached())
        detach();
    d->cleanHandle();
}
 
void QSharedMemory::setKey(const QString &key)
{
    setNativeKey(legacyNativeKey(key));
}
 
void QSharedMemory::setNativeKey(const QNativeIpcKey &key)
{
    Q_D(QSharedMemory);
    if (key == d->nativeKey && key.isEmpty())
        return;
    if (!isKeyTypeSupported(key.type())) {
        d->setError(KeyError, tr("%1: unsupported key type")
                    .arg("QSharedMemory::setNativeKey"_L1));
        return;
    }
 
    if (isAttached())
        detach();
    d->cleanHandle();
    if (key.type() == d->nativeKey.type()) {
        // we can reuse the backend
        d->nativeKey = key;
    } else {
        // we must recreate the backend
        d->destructBackend();
        d->nativeKey = key;
        d->constructBackend();
    }
}
 
bool QSharedMemoryPrivate::initKey(SemaphoreAccessMode mode)
{
    if (!cleanHandle())
        return false;
#if QT_CONFIG(systemsemaphore)
    const QString legacyKey = QNativeIpcKeyPrivate::legacyKey(nativeKey);
    const QNativeIpcKey semKey = legacyKey.isEmpty()
            ? semaphoreNativeKey()
            : QSystemSemaphore::legacyNativeKey(legacyKey, nativeKey.type());
    systemSemaphore.setNativeKey(semKey, 1, mode);
    if (systemSemaphore.error() != QSystemSemaphore::NoError) {
        QString function = "QSharedMemoryPrivate::initKey"_L1;
        errorString = QSharedMemory::tr("%1: unable to set key on lock (%2)")
                .arg(function, systemSemaphore.errorString());
        switch(systemSemaphore.error()) {
        case QSystemSemaphore::PermissionDenied:
            error = QSharedMemory::PermissionDenied;
            break;
        case QSystemSemaphore::KeyError:
            error = QSharedMemory::KeyError;
            break;
        case QSystemSemaphore::AlreadyExists:
            error = QSharedMemory::AlreadyExists;
            break;
        case QSystemSemaphore::NotFound:
            error = QSharedMemory::NotFound;
            break;
        case QSystemSemaphore::OutOfResources:
            error = QSharedMemory::OutOfResources;
            break;
        case QSystemSemaphore::UnknownError:
        default:
            error = QSharedMemory::UnknownError;
            break;
        }
        return false;
    }
#else
    Q_UNUSED(mode);
#endif
    errorString = QString();
    error = QSharedMemory::NoError;
    return true;
}
 
QString QSharedMemory::key() const
{
    Q_D(const QSharedMemory);
    return QNativeIpcKeyPrivate::legacyKey(d->nativeKey);
}
 
QString QSharedMemory::nativeKey() const
{
    Q_D(const QSharedMemory);
    return d->nativeKey.nativeKey();
}
 
QNativeIpcKey QSharedMemory::nativeIpcKey() const
{
    Q_D(const QSharedMemory);
    return d->nativeKey;
}
 
bool QSharedMemory::create(qsizetype size, AccessMode mode)
{
    Q_D(QSharedMemory);
    QLatin1StringView function = "QSharedMemory::create"_L1;
 
#if QT_CONFIG(systemsemaphore)
    if (!d->initKey(QSystemSemaphore::Create))
        return false;
    QSharedMemoryLocker lock(this);
    if (!d->nativeKey.isEmpty() && !d->tryLocker(&lock, function))
        return false;
#else
    if (!d->initKey({}))
        return false;
#endif
 
    if (size <= 0) {
        d->error = QSharedMemory::InvalidSize;
        d->errorString =
            QSharedMemory::tr("%1: create size is less then 0").arg(function);
        return false;
    }
 
    if (!d->create(size))
        return false;
 
    return d->attach(mode);
}
 
qsizetype QSharedMemory::size() const
{
    Q_D(const QSharedMemory);
    return d->size;
}
 
bool QSharedMemory::attach(AccessMode mode)
{
    Q_D(QSharedMemory);
 
    if (isAttached() || !d->initKey({}))
        return false;
#if QT_CONFIG(systemsemaphore)
    QSharedMemoryLocker lock(this);
    if (!d->nativeKey.isEmpty() && !d->tryLocker(&lock, "QSharedMemory::attach"_L1))
        return false;
#endif
 
    if (isAttached() || !d->handle())
        return false;
 
    return d->attach(mode);
}
 
bool QSharedMemory::isAttached() const
{
    Q_D(const QSharedMemory);
    return (nullptr != d->memory);
}
 
bool QSharedMemory::detach()
{
    Q_D(QSharedMemory);
    if (!isAttached())
        return false;
 
#if QT_CONFIG(systemsemaphore)
    QSharedMemoryLocker lock(this);
    if (!d->nativeKey.isEmpty() && !d->tryLocker(&lock, "QSharedMemory::detach"_L1))
        return false;
#endif
 
    return d->detach();
}
 
void *QSharedMemory::data()
{
    Q_D(QSharedMemory);
    return d->memory;
}
 
const void *QSharedMemory::constData() const
{
    Q_D(const QSharedMemory);
    return d->memory;
}
 
const void *QSharedMemory::data() const
{
    Q_D(const QSharedMemory);
    return d->memory;
}
 
#if QT_CONFIG(systemsemaphore)
bool QSharedMemory::lock()
{
    Q_D(QSharedMemory);
    if (d->lockedByMe) {
        qWarning("QSharedMemory::lock: already locked");
        return true;
    }
    if (d->systemSemaphore.acquire()) {
        d->lockedByMe = true;
        return true;
    }
    const auto function = "QSharedMemory::lock"_L1;
    d->errorString = QSharedMemory::tr("%1: unable to lock").arg(function);
    d->error = QSharedMemory::LockError;
    return false;
}
 
bool QSharedMemory::unlock()
{
    Q_D(QSharedMemory);
    if (!d->lockedByMe)
        return false;
    d->lockedByMe = false;
    if (d->systemSemaphore.release())
        return true;
    const auto function = "QSharedMemory::unlock"_L1;
    d->errorString = QSharedMemory::tr("%1: unable to unlock").arg(function);
    d->error = QSharedMemory::LockError;
    return false;
}
#endif // QT_CONFIG(systemsemaphore)
 
QSharedMemory::SharedMemoryError QSharedMemory::error() const
{
    Q_D(const QSharedMemory);
    return d->error;
}
 
QString QSharedMemory::errorString() const
{
    Q_D(const QSharedMemory);
    return d->errorString;
}
 
void QSharedMemoryPrivate::setUnixErrorString(QLatin1StringView function)
{
    // EINVAL is handled in functions so they can give better error strings
    switch (errno) {
    case EACCES:
        errorString = QSharedMemory::tr("%1: permission denied").arg(function);
        error = QSharedMemory::PermissionDenied;
        break;
    case EEXIST:
        errorString = QSharedMemory::tr("%1: already exists").arg(function);
        error = QSharedMemory::AlreadyExists;
        break;
    case ENOENT:
        errorString = QSharedMemory::tr("%1: doesn't exist").arg(function);
        error = QSharedMemory::NotFound;
        break;
    case EMFILE:
    case ENOMEM:
    case ENOSPC:
        errorString = QSharedMemory::tr("%1: out of resources").arg(function);
        error = QSharedMemory::OutOfResources;
        break;
    default:
        errorString = QSharedMemory::tr("%1: unknown error: %2")
                .arg(function, qt_error_string(errno));
        error = QSharedMemory::UnknownError;
#if defined QSHAREDMEMORY_DEBUG
        qDebug() << errorString << "key" << key << "errno" << errno << EINVAL;
#endif
    }
}
 
bool QSharedMemory::isKeyTypeSupported(QNativeIpcKey::Type type)
{
    if (!isIpcSupported(IpcType::SharedMemory, type))
        return false;
    using Variant = decltype(QSharedMemoryPrivate::backend);
    return Variant::staticVisit(type, [](auto ptr) {
        using Impl = std::decay_t<decltype(*ptr)>;
        return Impl::runtimeSupportCheck();
    });
}
 
QNativeIpcKey QSharedMemory::platformSafeKey(const QString &key, QNativeIpcKey::Type type)
{
    return QtIpcCommon::platformSafeKey(key, IpcType::SharedMemory, type);
}
 
QNativeIpcKey QSharedMemory::legacyNativeKey(const QString &key, QNativeIpcKey::Type type)
{
    return QtIpcCommon::legacyPlatformSafeKey(key, IpcType::SharedMemory, type);
}
 
#endif // QT_CONFIG(sharedmemory)
 
QT_END_NAMESPACE
 
#include "moc_qsharedmemory.cpp"