qlockfile.cpp

Go to the documentation of this file.

// Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2017 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qlockfile.h"
#include "qlockfile_p.h"
 
#include <QtCore/qthread.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qdeadlinetimer.h>
#include <QtCore/qdatetime.h>
#include <QtCore/qfileinfo.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
namespace {
struct LockFileInfo
{
    qint64 pid;
    QString appname;
    QString hostname;
    QByteArray hostid;
    QByteArray bootid;
};
}
 
static bool getLockInfo_helper(const QString &fileName, LockFileInfo *info);
 
static QString machineName()
{
#ifdef Q_OS_WIN
    // we don't use QSysInfo because it tries to do name resolution
    return qEnvironmentVariable("COMPUTERNAME");
#else
    return QSysInfo::machineHostName();
#endif
}
 
QLockFile::QLockFile(const QString &fileName)
    : d_ptr(new QLockFilePrivate(fileName))
{
}
 
QLockFile::~QLockFile()
{
    unlock();
}
 
QString QLockFile::fileName() const
{
    return d_ptr->fileName;
}
 
void QLockFile::setStaleLockTime(int staleLockTime)
{
    setStaleLockTime(std::chrono::milliseconds{staleLockTime});
}
 
void QLockFile::setStaleLockTime(std::chrono::milliseconds staleLockTime)
{
    Q_D(QLockFile);
    d->staleLockTime = staleLockTime;
}
 
int QLockFile::staleLockTime() const
{
    return int(staleLockTimeAsDuration().count());
}
 
std::chrono::milliseconds QLockFile::staleLockTimeAsDuration() const
{
    Q_D(const QLockFile);
    return d->staleLockTime;
}
 
bool QLockFile::isLocked() const
{
    Q_D(const QLockFile);
    return d->isLocked;
}
 
bool QLockFile::lock()
{
    return tryLock(std::chrono::milliseconds::max());
}
 
bool QLockFile::tryLock(int timeout)
{
    return tryLock(std::chrono::milliseconds{ timeout });
}
 
bool QLockFile::tryLock(std::chrono::milliseconds timeout)
{
    using namespace std::chrono_literals;
    using Msec = std::chrono::milliseconds;
 
    Q_D(QLockFile);
 
    QDeadlineTimer timer(timeout < 0ms ? Msec::max() : timeout);
 
    Msec sleepTime = 100ms;
    while (true) {
        d->lockError = d->tryLock_sys();
        switch (d->lockError) {
        case NoError:
            d->isLocked = true;
            return true;
        case PermissionError:
        case UnknownError:
            return false;
        case LockFailedError:
            if (!d->isLocked && d->isApparentlyStale()) {
                if (Q_UNLIKELY(QFileInfo(d->fileName).lastModified(QTimeZone::UTC) > QDateTime::currentDateTimeUtc()))
                    qInfo("QLockFile: Lock file '%ls' has a modification time in the future", qUtf16Printable(d->fileName));
                // Stale lock from another thread/process
                // Ensure two processes don't remove it at the same time
                QLockFile rmlock(d->fileName + ".rmlock"_L1);
                if (rmlock.tryLock()) {
                    if (d->isApparentlyStale() && d->removeStaleLock())
                        continue;
                }
            }
            break;
        }
 
        auto remainingTime = std::chrono::duration_cast<Msec>(timer.remainingTimeAsDuration());
        if (remainingTime == 0ms)
            return false;
 
        if (sleepTime > remainingTime)
            sleepTime = remainingTime;
 
        QThread::sleep(sleepTime);
        if (sleepTime < 5s)
            sleepTime *= 2;
    }
    // not reached
    return false;
}
 
bool QLockFile::getLockInfo(qint64 *pid, QString *hostname, QString *appname) const
{
    Q_D(const QLockFile);
    LockFileInfo info;
    if (!getLockInfo_helper(d->fileName, &info))
        return false;
    if (pid)
        *pid = info.pid;
    if (hostname)
        *hostname = info.hostname;
    if (appname)
        *appname = info.appname;
    return true;
}
 
QByteArray QLockFilePrivate::lockFileContents() const
{
    // Use operator% from the fast builder to avoid multiple memory allocations.
    return QByteArray::number(QCoreApplication::applicationPid()) % '\n'
            % processNameByPid(QCoreApplication::applicationPid()).toUtf8() % '\n'
            % machineName().toUtf8() % '\n'
            % QSysInfo::machineUniqueId() % '\n'
            % QSysInfo::bootUniqueId() % '\n';
}
 
static bool getLockInfo_helper(const QString &fileName, LockFileInfo *info)
{
    QFile reader(fileName);
    if (!reader.open(QIODevice::ReadOnly | QIODevice::Text))
        return false;
 
    QByteArray pidLine = reader.readLine();
    pidLine.chop(1);
    if (pidLine.isEmpty())
        return false;
    QByteArray appNameLine = reader.readLine();
    appNameLine.chop(1);
    QByteArray hostNameLine = reader.readLine();
    hostNameLine.chop(1);
 
    // prior to Qt 5.10, only the lines above were recorded
    QByteArray hostId = reader.readLine();
    hostId.chop(1);
    QByteArray bootId = reader.readLine();
    bootId.chop(1);
 
    bool ok;
    info->appname = QString::fromUtf8(appNameLine);
    info->hostname = QString::fromUtf8(hostNameLine);
    info->hostid = hostId;
    info->bootid = bootId;
    info->pid = pidLine.toLongLong(&ok);
    return ok && info->pid > 0;
}
 
bool QLockFilePrivate::isApparentlyStale() const
{
    LockFileInfo info;
    if (getLockInfo_helper(fileName, &info)) {
        bool sameHost = info.hostname.isEmpty() || info.hostname == machineName();
        if (!info.hostid.isEmpty()) {
            // Override with the host ID, if we know it.
            QByteArray ourHostId = QSysInfo::machineUniqueId();
            if (!ourHostId.isEmpty())
                sameHost = (ourHostId == info.hostid);
        }
 
        if (sameHost) {
            if (!info.bootid.isEmpty()) {
                // If we've rebooted, then the lock is definitely stale.
                if (info.bootid != QSysInfo::bootUniqueId())
                    return true;
            }
            if (!isProcessRunning(info.pid, info.appname))
                return true;
        }
    }
 
    const QDateTime lastMod = QFileInfo(fileName).lastModified(QTimeZone::UTC);
    using namespace std::chrono;
    const milliseconds age{lastMod.msecsTo(QDateTime::currentDateTimeUtc())};
    return staleLockTime > 0ms && abs(age) > staleLockTime;
}
 
bool QLockFile::removeStaleLockFile()
{
    Q_D(QLockFile);
    if (d->isLocked) {
        qWarning("removeStaleLockFile can only be called when not holding the lock");
        return false;
    }
    return d->removeStaleLock();
}
 
QLockFile::LockError QLockFile::error() const
{
    Q_D(const QLockFile);
    return d->lockError;
}
 
QT_END_NAMESPACE