You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tqt3/src/kernel/qlock.cpp

298 lines
7.3 KiB

/****************************************************************************
**
** Definition of TQLock class. This manages interprocess locking
**
** Created : 20000406
**
** Copyright (C) 2000-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the kernel module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** Licensees holding valid TQt Commercial licenses may use this file in
** accordance with the TQt Commercial License Agreement provided with
** the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "qlock_p.h"
#ifndef QT_NO_QWS_MULTIPROCESS
#include <unistd.h>
#include <sys/types.h>
#if defined(Q_OS_MACX)
#define Q_NO_SEMAPHORE
#include <sys/stat.h>
#include <sys/file.h>
#else
#include <sys/sem.h>
#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED) \
|| defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) || defined(Q_OS_NETBSD) || defined(Q_OS_BSDI)
/* union semun is defined by including <sys/sem.h> */
#else
/* according to X/OPEN we have to define it ourselves */
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
};
#endif
#endif
#include <sys/ipc.h>
#include <string.h>
#include <errno.h>
#define MAX_LOCKS 200 // maximum simultaneous read locks
class TQLockData
{
public:
#ifdef Q_NO_SEMAPHORE
TQCString file;
#endif
int id;
int count;
bool owned;
};
#endif
/*!
\class TQLock qlock_p.h
\brief The TQLock class is a wrapper for a System V shared semaphore.
\ingroup qws
\ingroup io
\internal
It is used by TQt/Embedded for synchronizing access to the graphics
card and shared memory region between processes.
*/
/*!
\enum TQLock::Type
\value Read
\value Write
*/
/*!
\fn TQLock::TQLock( const TQString &filename, char id, bool create )
Creates a lock. \a filename is the file path of the Unix-domain
socket the TQt/Embedded client is using. \a id is the name of the
particular lock to be created on that socket. If \a create is TRUE
the lock is to be created (as the TQt/Embedded server does); if \a
create is FALSE the lock should exist already (as the TQt/Embedded
client expects).
*/
TQLock::TQLock( const TQString &filename, char id, bool create )
{
#ifndef QT_NO_QWS_MULTIPROCESS
data = new TQLockData;
data->count = 0;
#ifdef Q_NO_SEMAPHORE
data->file = TQString(filename+id).local8Bit();
for(int x = 0; x < 2; x++) {
data->id = open(data->file, O_RDWR | (x ? O_CREAT : 0), S_IRWXU);
if(data->id != -1 || !create) {
data->owned = x;
break;
}
}
#else
key_t semkey = ftok(filename, id);
data->id = semget(semkey,0,0);
data->owned = create;
if ( create ) {
semun arg; arg.val = 0;
if ( data->id != -1 )
semctl(data->id,0,IPC_RMID,arg);
data->id = semget(semkey,1,IPC_CREAT|0600);
arg.val = MAX_LOCKS;
semctl(data->id,0,SETVAL,arg);
}
#endif
if ( data->id == -1 ) {
qWarning( "Cannot %s semaphore %s \'%c\'",
create ? "create" : "get", filename.latin1(), id );
qDebug("Error %d %s\n",errno,strerror(errno));
}
#endif
}
/*!
\fn TQLock::~TQLock()
Destroys a lock
*/
TQLock::~TQLock()
{
#ifndef QT_NO_QWS_MULTIPROCESS
if ( locked() )
unlock();
#ifdef Q_NO_SEMAPHORE
if(isValid()) {
close(data->id);
if( data->owned )
unlink( data->file );
}
#else
if(data->owned) {
semun arg; arg.val = 0;
semctl( data->id, 0, IPC_RMID, arg );
}
#endif
delete data;
#endif
}
/*!
\fn bool TQLock::isValid() const
Returns TRUE if the lock constructor was succesful; returns FALSE if
the lock could not be created or was not available to connect to.
*/
bool TQLock::isValid() const
{
#ifndef QT_NO_QWS_MULTIPROCESS
return (data->id != -1);
#else
return TRUE;
#endif
}
/*!
Locks the semaphore with a lock of type \a t. Locks can either be
\c Read or \c Write. If a lock is \c Read, attempts by other
processes to obtain \c Read locks will succeed, and \c Write
attempts will block until the lock is unlocked. If locked as \c
Write, all attempts to lock by other processes will block until
the lock is unlocked. Locks are stacked: i.e. a given TQLock can be
locked multiple times by the same process without blocking, and
will only be unlocked after a corresponding number of unlock()
calls.
*/
void TQLock::lock( Type t )
{
#ifndef QT_NO_QWS_MULTIPROCESS
if ( !data->count ) {
#ifdef Q_NO_SEMAPHORE
int op = LOCK_SH;
if(t == Write)
op = LOCK_EX;
for( int rv=1; rv; ) {
rv = flock(data->id, op);
if (rv == -1 && errno != EINTR)
qDebug("Semop lock failure %s",strerror(errno));
}
#else
sembuf sops;
sops.sem_num = 0;
sops.sem_flg = SEM_UNDO;
if ( t == Write ) {
sops.sem_op = -MAX_LOCKS;
type = Write;
} else {
sops.sem_op = -1;
type = Read;
}
int rv;
do {
rv = semop(data->id,&sops,1);
if (rv == -1 && errno != EINTR)
qDebug("Semop lock failure %s",strerror(errno));
} while ( rv == -1 && errno == EINTR );
#endif
}
data->count++;
#endif
}
/*!
\fn void TQLock::unlock()
Unlocks the semaphore. If other processes were blocking waiting to
lock() the semaphore, one of them will wake up and succeed in
lock()ing.
*/
void TQLock::unlock()
{
#ifndef QT_NO_QWS_MULTIPROCESS
if( data->count ) {
data->count--;
if( !data->count ) {
#ifdef Q_NO_SEMAPHORE
for( int rv=1; rv; ) {
rv = flock(data->id, LOCK_UN);
if (rv == -1 && errno != EINTR)
qDebug("Semop lock failure %s",strerror(errno));
}
#else
sembuf sops;
sops.sem_num = 0;
sops.sem_op = 1;
sops.sem_flg = SEM_UNDO;
if ( type == Write )
sops.sem_op = MAX_LOCKS;
int rv;
do {
rv = semop(data->id,&sops,1);
if (rv == -1 && errno != EINTR)
qDebug("Semop unlock failure %s",strerror(errno));
} while ( rv == -1 && errno == EINTR );
#endif
}
} else {
qDebug("Unlock without corresponding lock");
}
#endif
}
/*!
\fn bool TQLock::locked() const
Returns TRUE if the lock is currently held by the current process;
otherwise returns FALSE.
*/
bool TQLock::locked() const
{
#ifndef QT_NO_QWS_MULTIPROCESS
return (data->count > 0);
#else
return FALSE;
#endif
}