klockfile.cpp
/*
This file is part of the KDE libraries
Copyright (c) 2004 Waldo Bastian <bastian@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include <klockfile.h>
#include <config.h>
#include <sys/types.h>
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include <signal.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <qfile.h>
#include <qtextstream.h>
#include <kde_file.h>
#include <kapplication.h>
#include <kcmdlineargs.h>
#include <kglobal.h>
#include <ktempfile.h>
// TODO: http://www.spinnaker.de/linux/nfs-locking.html
// TODO: Make regression test
class KLockFile::KLockFilePrivate {
public:
QString file;
int staleTime;
bool isLocked;
bool recoverLock;
bool linkCountSupport;
QTime staleTimer;
KDE_struct_stat statBuf;
int pid;
QString hostname;
QString instance;
QString lockRecoverFile;
};
// 30 seconds
KLockFile::KLockFile(const QString &file)
{
d = new KLockFilePrivate();
d->file = file;
d->staleTime = 30;
d->isLocked = false;
d->recoverLock = false;
d->linkCountSupport = true;
}
KLockFile::~KLockFile()
{
unlock();
delete d;
}
int
KLockFile::staleTime() const
{
return d->staleTime;
}
void
KLockFile::setStaleTime(int _staleTime)
{
d->staleTime = _staleTime;
}
static bool statResultIsEqual(KDE_struct_stat &st_buf1, KDE_struct_stat &st_buf2)
{
#define FIELD_EQ(what) (st_buf1.what == st_buf2.what)
return FIELD_EQ(st_dev) && FIELD_EQ(st_ino) &&
FIELD_EQ(st_uid) && FIELD_EQ(st_gid) && FIELD_EQ(st_nlink);
#undef FIELD_EQ
}
static bool testLinkCountSupport(const QCString &fileName)
{
KDE_struct_stat st_buf;
// Check if hardlinks raise the link count at all?
::link( fileName, fileName+".test" );
int result = KDE_lstat( fileName, &st_buf );
::unlink( fileName+".test" );
return ((result == 0) && (st_buf.st_nlink == 2));
}
static KLockFile::LockResult lockFile(const QString &lockFile, KDE_struct_stat &st_buf, bool &linkCountSupport)
{
QCString lockFileName = QFile::encodeName( lockFile );
int result = KDE_lstat( lockFileName, &st_buf );
if (result == 0)
return KLockFile::LockFail;
KTempFile uniqueFile(lockFile, QString::null, 0644);
uniqueFile.setAutoDelete(true);
if (uniqueFile.status() != 0)
return KLockFile::LockError;
char hostname[256];
hostname[0] = 0;
gethostname(hostname, 255);
hostname[255] = 0;
QCString instanceName = KCmdLineArgs::appName();
(*(uniqueFile.textStream())) << QString::number(getpid()) << endl
<< instanceName << endl
<< hostname << endl;
uniqueFile.close();
QCString uniqueName = QFile::encodeName( uniqueFile.name() );
#ifdef Q_OS_UNIX
// Create lock file
result = ::link( uniqueName, lockFileName );
if (result != 0)
return KLockFile::LockError;
if (!linkCountSupport)
return KLockFile::LockOK;
#else
//TODO for win32
return KLockFile::LockOK;
#endif
KDE_struct_stat st_buf2;
result = KDE_lstat( uniqueName, &st_buf2 );
if (result != 0)
return KLockFile::LockError;
result = KDE_lstat( lockFileName, &st_buf );
if (result != 0)
return KLockFile::LockError;
if (!statResultIsEqual(st_buf, st_buf2) || S_ISLNK(st_buf.st_mode) || S_ISLNK(st_buf2.st_mode))
{
// SMBFS supports hardlinks by copying the file, as a result the above test will always fail
if ((st_buf.st_nlink == 1) && (st_buf2.st_nlink == 1) && (st_buf.st_ino != st_buf2.st_ino))
{
linkCountSupport = testLinkCountSupport(uniqueName);
if (!linkCountSupport)
return KLockFile::LockOK; // Link count support is missing... assume everything is OK.
}
return KLockFile::LockFail;
}
return KLockFile::LockOK;
}
static KLockFile::LockResult deleteStaleLock(const QString &lockFile, KDE_struct_stat &st_buf, bool &linkCountSupport)
{
// This is dangerous, we could be deleting a new lock instead of
// the old stale one, let's be very careful
// Create temp file
KTempFile ktmpFile(lockFile);
if (ktmpFile.status() != 0)
return KLockFile::LockError;
QCString lckFile = QFile::encodeName(lockFile);
QCString tmpFile = QFile::encodeName(ktmpFile.name());
ktmpFile.close();
ktmpFile.unlink();
#ifdef Q_OS_UNIX
// link to lock file
if (::link(lckFile, tmpFile) != 0)
return KLockFile::LockFail; // Try again later
#else
//TODO for win32
return KLockFile::LockOK;
#endif
// check if link count increased with exactly one
// and if the lock file still matches
KDE_struct_stat st_buf1;
KDE_struct_stat st_buf2;
memcpy(&st_buf1, &st_buf, sizeof(KDE_struct_stat));
st_buf1.st_nlink++;
if ((KDE_lstat(tmpFile, &st_buf2) == 0) && statResultIsEqual(st_buf1, st_buf2))
{
if ((KDE_lstat(lckFile, &st_buf2) == 0) && statResultIsEqual(st_buf1, st_buf2))
{
// - - if yes, delete lock file, delete temp file, retry lock
qWarning("WARNING: deleting stale lockfile %s", lckFile.data());
::unlink(lckFile);
::unlink(tmpFile);
return KLockFile::LockOK;
}
}
// SMBFS supports hardlinks by copying the file, as a result the above test will always fail
if (linkCountSupport)
{
linkCountSupport = testLinkCountSupport(tmpFile);
}
if (!linkCountSupport &&
(KDE_lstat(lckFile, &st_buf2) == 0) &&
statResultIsEqual(st_buf, st_buf2))
{
// Without support for link counts we will have a little race condition
qWarning("WARNING: deleting stale lockfile %s", lckFile.data());
::unlink(lckFile);
::unlink(tmpFile);
return KLockFile::LockOK;
}
// Failed to delete stale lock file
qWarning("WARNING: Problem deleting stale lockfile %s", lckFile.data());
::unlink(tmpFile);
return KLockFile::LockFail;
}
KLockFile::LockResult KLockFile::lock(int options)
{
if (d->isLocked)
return KLockFile::LockOK;
KLockFile::LockResult result;
int hardErrors = 5;
int n = 5;
while(true)
{
KDE_struct_stat st_buf;
result = lockFile(d->file, st_buf, d->linkCountSupport);
if (result == KLockFile::LockOK)
{
d->staleTimer = QTime();
break;
}
else if (result == KLockFile::LockError)
{
d->staleTimer = QTime();
if (--hardErrors == 0)
{
break;
}
}
else // KLockFile::Fail
{
if (!d->staleTimer.isNull() && !statResultIsEqual(d->statBuf, st_buf))
d->staleTimer = QTime();
if (!d->staleTimer.isNull())
{
bool isStale = false;
if ((d->pid > 0) && !d->hostname.isEmpty())
{
// Check if hostname is us
char hostname[256];
hostname[0] = 0;
gethostname(hostname, 255);
hostname[255] = 0;
if (d->hostname == hostname)
{
// Check if pid still exists
int res = ::kill(d->pid, 0);
if ((res == -1) && (errno == ESRCH))
isStale = true;
}
}
if (d->staleTimer.elapsed() > (d->staleTime*1000))
isStale = true;
if (isStale)
{
if ((options & LockForce) == 0)
return KLockFile::LockStale;
result = deleteStaleLock(d->file, d->statBuf, d->linkCountSupport);
if (result == KLockFile::LockOK)
{
// Lock deletion successful
d->staleTimer = QTime();
continue; // Now try to get the new lock
}
else if (result != KLockFile::LockFail)
{
return result;
}
}
}
else
{
memcpy(&(d->statBuf), &st_buf, sizeof(KDE_struct_stat));
d->staleTimer.start();
d->pid = -1;
d->hostname = QString::null;
d->instance = QString::null;
QFile file(d->file);
if (file.open(IO_ReadOnly))
{
QTextStream ts(&file);
if (!ts.atEnd())
d->pid = ts.readLine().toInt();
if (!ts.atEnd())
d->instance = ts.readLine();
if (!ts.atEnd())
d->hostname = ts.readLine();
}
}
}
if ((options & LockNoBlock) != 0)
break;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = n*((KApplication::random() % 200)+100);
if (n < 2000)
n = n * 2;
#ifdef Q_OS_UNIX
select(0, 0, 0, 0, &tv);
#else
//TODO for win32
#endif
}
if (result == LockOK)
d->isLocked = true;
return result;
}
bool KLockFile::isLocked() const
{
return d->isLocked;
}
void KLockFile::unlock()
{
if (d->isLocked)
{
::unlink(QFile::encodeName(d->file));
d->isLocked = false;
}
}
bool KLockFile::getLockInfo(int &pid, QString &hostname, QString &appname)
{
if (d->pid == -1)
return false;
pid = d->pid;
hostname = d->hostname;
appname = d->instance;
return true;
}
KLockFile::LockError
The lock could not be acquired due to an error.
Definition: klockfile.h:62
KLockFile::~KLockFile
~KLockFile()
Destroys the object, releasing the lock if held.
Definition: klockfile.cpp:75
KLockFile::LockResult
LockResult
Possible return values of the lock function.
Definition: klockfile.h:48
KLockFile::staleTime
int staleTime() const
Return the time in seconds after which a lock is considered stale The default is 30.
Definition: klockfile.cpp:82
KLockFile::LockFail
The lock could not be acquired because it is held by another process.
Definition: klockfile.h:57
KLockFile::getLockInfo
bool getLockInfo(int &pid, QString &hostname, QString &appname)
Returns the pid, hostname and appname of the process holding the lock after the lock functon has retu...
Definition: klockfile.cpp:368
KLockFile::setStaleTime
void setStaleTime(int _staleTime)
Set the time in seconds after which a lock is considered stale.
Definition: klockfile.cpp:89
KLockFile::LockForce
Automatically remove a lock when a lock is detected that is stale for more than staleTime() seconds...
Definition: klockfile.h:80
KLockFile::lock
LockResult lock(int options=0)
Attempt to acquire the lock.
Definition: klockfile.cpp:240
KLockFile::LockNoBlock
Return immediately, do not wait for the lock to become available.
Definition: klockfile.h:74
KLockFile::LockStale
A stale lock has been detected.
Definition: klockfile.h:67
KCmdLineArgs::appName
static const char * appName()
Get the appname according to argv[0].
Definition: kcmdlineargs.cpp:199
KTempFile
The KTempFile class creates and opens a unique file for temporary use.
Definition: ktempfile.h:55
KLockFile::LockOK
Lock was acquired successfully.
Definition: klockfile.h:52
KApplication::random
static int random()
Generates a uniform random number.
Definition: kapplication.cpp:2947
KLockFile::isLocked
bool isLocked() const
Returns whether the lock is held or not.
Definition: klockfile.cpp:354
KLockFile::unlock
void unlock()
Release the lock.
Definition: klockfile.cpp:359
KNotifyClient::instance
KInstance * instance()
Shortcut to KNotifyClient::Instance::current() :)
Definition: knotifyclient.cpp:267
KGlobal::endl
kdbgstream & endl(kdbgstream &s)
Definition: kdebug.h:430

KDE Home | KDE Accessibility Home | Description of Access Keys