--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/src/publishsubscribe/qsystemreadwritelock_unix.cpp Fri Apr 16 15:51:22 2010 +0300
@@ -0,0 +1,546 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsystemreadwritelock_p.h"
+#include <QFile>
+#include <sys/sem.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <QRegExp>
+#include <QCryptographicHash>
+#include <QDir>
+
+QTM_BEGIN_NAMESPACE
+
+class QSystemReadWriteLockPrivate
+{
+public:
+ enum SemIndex {
+ ActiveReaders = 0,
+ TotalWriters,
+ ActiveWriterSem,
+ NumInstances
+ };
+
+ QSystemReadWriteLockPrivate():id(-1),semId(-1),
+ key(QString()),keyFileName(QString()),
+ error(QSystemReadWriteLock::NoError),
+ errorString(QString()){};
+ void setError(const QString &errorString);
+
+ key_t id;
+ int semId;
+ QString key;
+ QString keyFileName;
+
+ QSystemReadWriteLock::SystemReadWriteLockError error;
+ QString errorString;
+};
+
+void QSystemReadWriteLockPrivate::setError(const QString &_errorString)
+{
+ errorString = _errorString;
+ switch (errno) {
+ case EPERM:
+ case EACCES:
+ error = QSystemReadWriteLock::PermissionDenied;
+ break;
+ case ERANGE:
+ case ENOMEM:
+ case ENOSPC:
+ error = QSystemReadWriteLock::OutOfResources;
+ break;
+ case EIDRM:
+ error = QSystemReadWriteLock::NotFound;
+ break;
+ default:
+ error = QSystemReadWriteLock::UnknownError;
+ }
+}
+
+/*
+ This function is taken from qcore_unix_p.h(qt_safe_open)
+ If/when QSystemReadWriteLock is integrated into Qt,
+ this function defintion may replaced by the sharedmemory
+ definition.
+ */
+static inline int safe_open(const char *pathname, int flags, mode_t mode = 0777)
+{
+#ifdef O_CLOEXEC
+ flags |= O_CLOEXEC;
+#endif
+ register int fd;
+
+ do {
+ fd = ::open(pathname, flags, mode);
+ } while (fd == -1 && errno == EINTR);
+
+ // unknown flags are ignored, so we have no way of verifying if
+ // O_CLOEXEC was accepted
+ if (fd != -1)
+ ::fcntl(fd, F_SETFD, FD_CLOEXEC);
+ return fd;
+}
+
+/*
+ This function is taken from qsharedmemory_unix.cpp.
+ If/when QSystemReadWriteLock is integrated into Qt,
+ this function defintion may replaced by the sharedmemory
+ definition.
+ */
+int createUnixKeyFile(const QString &fileName)
+{
+ if (QFile::exists(fileName)) {
+ return 0;
+ }
+
+ int fd = safe_open(QFile::encodeName(fileName).constData(),
+ O_EXCL | O_CREAT | O_RDWR, 0640);
+
+ if (-1 == fd) {
+ if (errno == EEXIST)
+ return 0;
+ return -1;
+ } else {
+ close(fd);
+ }
+ return 1;
+}
+
+/*
+ This function is taken from qsharedmemory_unix.cpp.
+ If/when QSystemReadWriteLock is integrated into Qt,
+ the function definition may replaced by the sharedmemory
+ definition.
+ */
+QString makePlatformSafeKey(const QString &key,
+ const QString &prefix)
+{
+ if (key.isEmpty())
+ return QString();
+
+ QString result = prefix;
+
+ QString part1 = key;
+ part1.replace(QRegExp(QLatin1String("[^A-Za-z]")), QString());
+ result.append(part1);
+
+ QByteArray hex = QCryptographicHash::hash(key.toUtf8(), QCryptographicHash::Sha1).toHex();
+ result.append(QLatin1String(hex));
+ return QDir::tempPath() + QLatin1Char('/') + result;
+}
+
+/*
+ \class QSystemReadWriteLock
+
+ \brief The QSystemReadWriteLock class provides read-write locking between
+ processes.
+
+ A read-write lock is a synchronization tool for protecting resources that can
+ be accessed for reading and writing. This type of lock is useful if you want
+ to allow multiple processes/threads to have simultaneous read-only access, but as soon
+ as one thread wants to write to the resource, all other threads must be
+ blocked until the writing is complete.
+
+ QSystemReadWriteLock behaves much like the QReadWriteLock class, but it also
+ works across multiple processes (although it also works perfectly well,
+ albeit slightly less efficiently, in a single process). The system
+ resources are cleaned up when the last QSystemReadWriteLock instance
+ is destroyed.
+
+ The behaviour of QSystemReadWriteLock is such that writers will
+ take precedence over readers. When writers are waiting, any new
+ readers must wait until all writers complete. That is, writers
+ can starve readers.
+ */
+
+/*
+ Implementation Details:
+
+ The QSystemReadWriteLock class uses Linux kernel semaphores to synchronize
+ access between readers and writers.
+
+ 4 semaphores are used in total.
+ activeReaders - number of active readers
+ TotalWriters - number of active and pending writers
+
+ ActiveWriterSem - indicates whether a writer is active
+
+ NumInstances - counts the number of instances of QSystemReadWriteLock
+ objects there for a given key. This is needed
+ to determine whether system resources are
+ safe to clean up during an instance's destruction.
+
+ activeReaders, TotalWriters and NumInstance are used as counters and
+ not in the way typical semaphores are used. e.g.a value of 5 for
+ activeReaders indicates that there are currently 5 readers.
+
+ ActiveWriterSem is used as a typical semaphore. A value of 1
+ means there's an free slot for a writer to become active.
+ */
+
+/*
+ Construct a system read write lock from the provided \a key.
+
+ The \a mode parameter is only used in Unix systems to handle the case
+ where underlying system resources such as semaphores survive a process
+ crash. In this case, the next process to instatiate a lock will
+ get the resources that survived the crash, and unless \mode is
+ Create, the resources will not be reset.
+ */
+QSystemReadWriteLock::QSystemReadWriteLock(const QString &key, AccessMode mode)
+{
+ d = new QSystemReadWriteLockPrivate;
+ d->key = key;
+ d->keyFileName = makePlatformSafeKey(key, QLatin1String("qipc_systemsem_"));
+
+ int built = createUnixKeyFile(d->keyFileName);
+ if (built == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
+ "unable to make key file for key: %1(%2)")
+ .arg(key).arg(strerror(errno)));
+ return;
+ }
+
+ // Get the unix key for the created file
+ d->id = ftok(QFile::encodeName(d->keyFileName).constData(), 'Q');
+ if (d->id == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
+ "ftok failed for key %1(%2)")
+ .arg(key).arg(strerror(errno)));
+ return;
+ }
+
+ d->semId = ::semget(d->id, 4, IPC_CREAT | IPC_EXCL | 0666);
+ bool created = false;
+ if (d->semId == -1) {
+ if (errno == EEXIST) {
+ d->semId = ::semget(d->id, 4,
+ (mode == QSystemReadWriteLock::Create)?IPC_CREAT|0666:0);
+ if (d->semId == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
+ "Unable to access semaphore set for key %1(%2)")
+ .arg(key).arg(::strerror(errno)));
+ return;
+ }
+ } else {
+ d->setError(QObject::tr("QSystemReadWriteLock:QSystemReadWriteLock: "
+ "Unable to access semaphore set for key %1(%2)")
+ .arg(key).arg(::strerror(errno)));
+ return;
+ }
+ } else {
+ created = true;
+ }
+
+ Q_ASSERT(d->semId != -1);
+ if (created || mode == QSystemReadWriteLock::Create) {
+ typedef union {
+ int val;
+ struct semid_ds *buf;
+ ushort *array;
+ }semun;
+
+ semun counterInitVal; //initial value for a "counter" semaphores
+ counterInitVal.val = 0;
+
+ semun activeWriterInitVal;//initial value for the "active writer" semaphore
+ activeWriterInitVal.val = 1;
+
+ if (-1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::ActiveReaders,
+ SETVAL, counterInitVal) ||
+ -1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::TotalWriters,
+ SETVAL, counterInitVal) ||
+ -1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::ActiveWriterSem,
+ SETVAL, activeWriterInitVal) ||
+ -1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::NumInstances,
+ SETVAL, counterInitVal))
+ {
+ d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
+ "Unable to reset semaphore set for key %1(%2)")
+ .arg(key).arg(::strerror(errno)));
+ QFile::remove(d->keyFileName);
+ ::semctl(d->semId, 0, IPC_RMID);
+ d->semId = -1;
+ return;
+ }
+ }
+
+ struct sembuf op;
+ op.sem_num = QSystemReadWriteLockPrivate::NumInstances;
+ op.sem_op = 1;
+ op.sem_flg = SEM_UNDO;
+ int semoprv = ::semop(d->semId, &op, 1);
+ if (semoprv == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
+ "Unable to increment NumInstances semaphore "
+ "for key%1(%2)").arg(key).arg(::strerror(errno)));
+ d->semId = -1;
+ return;
+ }
+}
+
+/*
+ Destroy the lock instance. The last QSystemReadWriteLock instance
+ for a particular key will destroy the underlying system resources.
+ */
+QSystemReadWriteLock::~QSystemReadWriteLock()
+{
+ if (d->semId != -1) {
+ //decrement and check that there are 0 instances
+ //be aware these 2 operations occur together atomically
+ struct sembuf ops[2];
+ ops[0].sem_num = QSystemReadWriteLockPrivate::NumInstances;
+ ops[0].sem_op = -1;
+ ops[0].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
+ ops[1].sem_num = QSystemReadWriteLockPrivate::NumInstances;
+ ops[1].sem_op = 0;
+ ops[1].sem_flg = IPC_NOWAIT;
+
+ //if successful, then delete the semaphore set
+ int semoprv = ::semop(d->semId, ops, 2);
+ if (semoprv == 0) {
+ if(::semctl(d->semId, 0, IPC_RMID) == -1) {
+ qWarning(QObject::tr("QSystemReadWriteLock::~QSystemReadWriteLock: "
+ "Unable to remove semaphore %1(%2)")
+ .arg(d->key).arg(::strerror(errno)).toLatin1());
+ }
+ QFile::remove(d->keyFileName);
+ } else {
+ if (errno == EAGAIN) {
+ //wasn't 0 instances so just decrement the NumInstances semaphore
+ if (::semop(d->semId, ops, 1) == -1) {
+ qWarning(QObject::tr("QSystemReadWriteLock::~QSystemReadWriteLock: unable "
+ "to decrement NumInstances semaphore for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)).toLatin1());
+ }
+ } else {
+ qWarning(QObject::tr("QSystemReadWriteLock::~QSystemReadWriteLock: unable "
+ "to decrement and check NumInstances semaphore for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)).toLatin1());
+ ::semop(d->semId, ops, 1);//try decrement anyway
+ }
+ }
+
+ }
+
+ Q_ASSERT(d);
+ delete d;
+ d = 0;
+}
+
+/*
+ Return the key of the lock as passed to the constructor.
+ */
+QString QSystemReadWriteLock::key() const
+{
+ return d->key;
+}
+
+/*
+ Locks the lock for reading. The function will block if any thread/process
+ has locked for writing.
+ */
+bool QSystemReadWriteLock::lockForRead()
+{
+ if (d->semId == -1) {
+ d->errorString = QObject::tr("QSystemReadWriteLock::lockForRead: unable to lock for read for key %1(%2)")
+ .arg(d->key).arg("Lock had not been correctly initialized");
+ d->error = UnknownError;
+ return false;
+ }
+
+ struct sembuf ops[2];
+
+ ops[0].sem_num = QSystemReadWriteLockPrivate::ActiveReaders;
+ ops[0].sem_op = 1;
+ ops[0].sem_flg = SEM_UNDO;
+
+ ops[1].sem_num = QSystemReadWriteLockPrivate::TotalWriters;
+ ops[1].sem_op = 0;
+ ops[1].sem_flg = 0;
+
+ if (-1 == ::semop(d->semId, ops, 2)) {
+ d->setError(QObject::tr("QSystemReadWriteLock::lockForRead: unable to lock for read for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)));
+ return false;
+ } else {
+ d->errorString = "";
+ d->error = NoError;
+ return true;
+ }
+}
+
+/*
+ Locks the lock for writing. This function will block if another thread/process
+ has locked for reading or writing.
+ */
+bool QSystemReadWriteLock::lockForWrite()
+{
+ if (d->semId == -1) {
+ d->errorString = QObject::tr("QSystemReadWriteLock::lockForWrite: "
+ "unable to lock for write for key %1(%2)")
+ .arg(d->key).arg("Lock had not been correctly initialized");
+ d->error = UnknownError;
+ return false;
+ }
+
+ struct sembuf op;
+ op.sem_num = QSystemReadWriteLockPrivate::TotalWriters;
+ op.sem_op = 1;
+ op.sem_flg = SEM_UNDO;
+
+ int semoprv = ::semop(d->semId, &op, 1);
+ if (semoprv == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::lockForWrite: "
+ "Could not increment TotalWriters semaphore for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)));
+ return false;
+ }
+
+ op.sem_num = QSystemReadWriteLockPrivate::ActiveReaders;
+ op.sem_op = 0;
+ op.sem_flg = 0;
+ semoprv = ::semop(d->semId, &op, 1);
+ if (semoprv == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::lockForWrite: "
+ "Could not detect if all readers were finished for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)));
+
+ // Decrement our write lock
+ op.sem_num = QSystemReadWriteLockPrivate::TotalWriters;
+ op.sem_op = -1;
+ op.sem_flg = SEM_UNDO;
+ ::semop(d->semId, &op, 1);
+ return false;
+ } else {
+ op.sem_num = QSystemReadWriteLockPrivate::ActiveWriterSem;
+ op.sem_op = -1;
+ op.sem_flg =SEM_UNDO;
+ semoprv = ::semop(d->semId, &op, 1);
+
+ if (semoprv == -1) {
+ d->setError(QObject::tr("QSystemReadWriteLock::lockForWrite: "
+ "Could not decrement ActiveWriterSem semaphore for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)));
+
+ op.sem_num = QSystemReadWriteLockPrivate::TotalWriters;
+ op.sem_op = -1;
+ op.sem_flg = 0;
+ ::semop(d->semId, &op, 1);
+ return false;
+ }
+ d->errorString ="";
+ d->error = NoError;
+ return true;
+ }
+}
+
+/*
+ Release the lock.
+ */
+void QSystemReadWriteLock::unlock()
+{
+ if (d->semId == -1) {
+ d->errorString = QObject::tr("QSystemReadWriteLock::unlock: unable to unlock for key %1(%2)")
+ .arg(d->key).arg("Lock had not been correctly initialized");
+ d->error = UnknownError;
+ return;
+ }
+
+ struct sembuf op;
+ op.sem_num = QSystemReadWriteLockPrivate::ActiveReaders;
+ op.sem_op = -1;
+ op.sem_flg = SEM_UNDO | IPC_NOWAIT;
+ if (::semop(d->semId, &op, 1) == 0) {
+ //do nothing, succeeded in decrementing number of readers
+ } else if (errno == EAGAIN){ //no readers, so check for writers
+ struct sembuf ops[3];
+ ops[0].sem_num = QSystemReadWriteLockPrivate::ActiveWriterSem;
+ ops[0].sem_op = 0;
+ ops[0].sem_flg = IPC_NOWAIT;
+
+ ops[1].sem_num = QSystemReadWriteLockPrivate::ActiveWriterSem;
+ ops[1].sem_op = 1;
+ ops[1].sem_flg = SEM_UNDO;
+
+ ops[2].sem_num = QSystemReadWriteLockPrivate::TotalWriters;
+ ops[2].sem_op = -1;
+ ops[2].sem_flg = SEM_UNDO;
+
+ if (::semop(d->semId, ops, 3) == -1) {
+ if (errno != EAGAIN) {
+ d->setError(QObject::tr("QSystemSemaphoreWriteLock::unlock: unable to check and "
+ "update writer semaphores for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)));
+ return;
+ } //Note: EAGAIN indicates that ActiveWriterSem is has a non zero value
+ //indicating there is no current writer, so nothing needs to be done
+ }
+ } else {
+ //error in decrementing readers
+ d->setError(QObject::tr("QSystemReadWriteLock::unlock: unable to decrement "
+ "ActiveReaders semaphore for key %1(%2)")
+ .arg(d->key).arg(::strerror(errno)));
+ return;
+ }
+ d->errorString="";
+ d->error = NoError;
+}
+
+/*
+ Returns the error code of the last encountered error
+ */
+QSystemReadWriteLock::SystemReadWriteLockError QSystemReadWriteLock::error() const {
+ return d->error;
+}
+
+/*
+ Returns a string describing the last encountered error
+ */
+QString QSystemReadWriteLock::errorString() const
+{
+ return d->errorString;
+}
+
+QTM_END_NAMESPACE
+