void *thread_main8(void *arg)
{
/* The mutator will patch in messaging primitives to signal events at mutex creation,
deletion, locking and unlocking. Thus far, we are only considering reporting of events
so actual contention is meaningless */
Lock_t newmutex;
if (!createLock(&newmutex)) {
fprintf(stderr, "%s[%d]: createLock failed\n", __FILE__, __LINE__);
return NULL;
}
sleep_ms(100);
if (!lockLock(&newmutex)) {
fprintf(stderr, "%s[%d]: lockLock failed\n", __FILE__, __LINE__);
return NULL;
}
sleep_ms(100);
if (!unlockLock(&newmutex)) {
fprintf(stderr, "%s[%d]: unlockLock failed\n", __FILE__, __LINE__);
return NULL;
}
sleep_ms(100);
if (!destroyLock(&newmutex)) {
fprintf(stderr, "%s[%d]: destroyLock failed\n", __FILE__, __LINE__);
return NULL;
}
sleep(1);
return NULL;
}
Lock::Lock(const std::string &name, bool clean_first):
name_(name)
{
if (clean_first)
cleanLock(name);
createLock();
}
//----------------------------------------------------------------------
SFBool CSharedResource::Lock(const SFString& fn, const SFString& mode, SFBool lockType)
{
ASSERT(!isOpen());
m_filename = fn;
m_mode = mode;
m_fp = NULL;
// If the file we are trying to lock does not exist but we are not trying to open
// it under one of the create modes then do not create a lock, do not open the file,
// and let the user know.
if (!SFos::fileExists(m_filename) &&
(m_mode != asciiWriteCreate &&
m_mode != asciiWriteAppend &&
m_mode != binaryWriteCreate))
{
m_error = LK_FILE_NOT_EXIST;
m_errorMsg = "File does not exist: " + m_filename;
return FALSE;
}
SFBool openIt = TRUE; //FALSE;
if (m_mode == binaryReadOnly ||
m_mode == asciiReadOnly)
{
// Wait for lock to clear...
if (lockType == LOCK_WAIT)
waitOnLock(TRUE);
// ... proceed even if it doesn't....
openIt = TRUE;
} else if (m_mode == binaryReadWrite ||
m_mode == binaryWriteCreate ||
m_mode == asciiReadWrite ||
m_mode == asciiWriteAppend ||
m_mode == asciiWriteCreate)
{
ASSERT(lockType == LOCK_CREATE || lockType == LOCK_WAIT);
openIt = createLock(TRUE);
} else
{
m_error = LK_BAD_OPEN_MODE;
m_errorMsg = "Bad file open mode: " + m_mode;
return FALSE;
}
if (openIt)
{
m_fp = fopen((const char *)m_filename, (const char *)m_mode); // operator on event database
m_isascii = ::isAscii(m_mode);
}
return isOpen();
}
int lockManagerReadLockHashed(int xid, byte * dat, int datLen) {
if(xid == -1) { return 0; }
pthread_mutex_lock(&xid_table_mutex);
pblHashTable_t * xidLocks = pblHtLookup_r(xidLockTable, &xid, sizeof(int));
if(!xidLocks) {
xidLocks = lockManagerBeginTransactionUnlocked(xid);
}
long currentLockLevel = (long)pblHtLookup_r(xidLocks, dat, datLen);
// printf("xid %d read lock (%d)\n", xid, currentLockLevel);
if(currentLockLevel >= LM_READLOCK) {
pthread_mutex_unlock(&xid_table_mutex);
return 0;
}
assert(!currentLockLevel);
pthread_mutex_unlock(&xid_table_mutex);
pthread_mutex_t * mut = getMutex(dat, datLen);
pthread_mutex_lock(mut);
lock * ridLock = pblHtLookup_r(ridLockTable, dat, datLen);
if(!ridLock) {
ridLock = createLock(dat, datLen);
}
ridLock->active++;
if(ridLock->writers || ridLock->waiting) {
struct timeval tv;
int tod_ret = gettimeofday (&tv, NULL);
tv.tv_sec++; // Wait up to one second to obtain a lock before detecting deadlock.
struct timespec ts;
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
if(tod_ret != 0) {
perror("Could not get time of day");
return LLADD_INTERNAL_ERROR;
}
do {
int wait_ret = pthread_cond_timedwait(&ridLock->readOK, mut, &ts);
if(wait_ret == ETIMEDOUT) {
ridLock->active--;
pthread_mutex_unlock(mut);
return LLADD_DEADLOCK;
}
} while(ridLock->writers);
}
if(currentLockLevel < LM_READLOCK) {
ridLock->readers++;
pblHtRemove_r(xidLocks, dat, datLen);
pblHtInsert_r(xidLocks, dat, datLen, (void*)LM_READLOCK);
}
ridLock->active--;
pthread_mutex_unlock(mut);
return 0;
}
void func6_1()
{
#if defined(os_none)
createLock(&test6lock);
lockLock(&test6lock);
assert (NULL != createThreads(TEST6_THREADS, thread_main6, test6_threads));
unlockLock(&test6lock);
mutateeIdle = 1;
while (mutateeIdle) {}
#else
#endif
}
void func5_1()
{
#if defined(os_none)
createLock(&test5lock);
lockLock(&test5lock);
assert (NULL != createThreads(TEST5_THREADS, thread_main5, test5_threads));
sleep_ms(999);
unlockLock(&test5lock);
mutateeIdle = 1;
while (mutateeIdle) {}
#else
#endif
}
void func3_1()
{
createLock(&test3lock);
mutateeIdle = 1;
lockLock(&test3lock);
assert (NULL != createThreads(TEST3_THREADS, thread_main3, test3_threads));
sleep_ms(999);
unlockLock(&test3lock);
dprintf("%s[%d]: func3_1\n", __FILE__, __LINE__);
while (mutateeIdle) {}
dprintf("%s[%d]: leaving func3_1\n", __FILE__, __LINE__);
}
void func4_1()
{
/*
#if defined(os_linux) && defined(arch_x86)
#else
*/
dprintf("%s[%d]: welcome to func4_1\n", __FILE__, __LINE__);
createLock(&test4lock);
lockLock(&test4lock);
assert (NULL != createThreads(TEST3_THREADS, thread_main4, test4_threads));
unlockLock(&test4lock);
mutateeIdle = 1;
while (mutateeIdle) {}
/*
#endif
*/
}
/**
* Initializes a lock.
*
* @retval RWL_SUCCESS Success.
* @retval RWL_EXIST "create" is false and the semaphore set doesn't exist.
* log_add() called.
* @retval RWL_SYSTEM System error. log_add() called.
*/
static srwl_Status initLock(
const int create /**< [in] Whether to create the lock. If true, then
any previous lock will be deleted. */,
int key /**< [in] IPC key for the semaphore */,
srwl_Lock** const lock /**< [out] address of pointer to lock */)
{
srwl_Status status;
srwl_Lock* lck;
if (!isInitialized) {
struct sembuf acquireLock;
struct sembuf releaseLock;
acquireLock.sem_num = SI_LOCK;
acquireLock.sem_op = -1;
acquireLock.sem_flg = SEM_UNDO; /* release lock upon exit */
releaseLock.sem_num = SI_LOCK;
releaseLock.sem_op = 1;
releaseLock.sem_flg = SEM_UNDO; /* undo acquireLock undo */
writeLockOps[0] = acquireLock;
writeLockOps[1].sem_num = SI_NUM_READERS;
writeLockOps[1].sem_op = 0;
writeLockOps[1].sem_flg = 0;
readLockOps[0] = acquireLock;
readLockOps[1].sem_num = SI_NUM_READERS;
readLockOps[1].sem_op = 1;
readLockOps[1].sem_flg = SEM_UNDO; /* decrement #readers upon exit */
shareOps[0] = releaseLock;
writeUnlockOps[0] = releaseLock;
readUnlockOps[0].sem_num = SI_NUM_READERS;
readUnlockOps[0].sem_op = -1;
readUnlockOps[0].sem_flg = SEM_UNDO; /* undo readLockOps[1] undo */
{
mode_t um = umask(0);
umask(um);
read_write = 0666 & ~um;
}
isInitialized = 1;
}
lck = (srwl_Lock*) malloc(sizeof(srwl_Lock));
if (NULL == lck) {
LOG_SERROR1("Couldn't allocate %lu bytes for lock",
(unsigned long) sizeof(srwl_Lock));
status = RWL_SYSTEM;
}
else {
int semId;
status = create ? createLock(key, &semId) : getLock(key, &semId);
if (RWL_SUCCESS != status) {
free(lck);
}
else {
lck->semId = semId;
lck->pid = getpid();
lck->isValid = VALID_STRING;
lck->numReadLocks = 0;
lck->numWriteLocks = 0;
*lock = lck;
}
} /* "lck" allocated */
return status;
}
void Lock::recreate(){
deleteLock();
cleanLock(name_.c_str());
createLock();
}
int lockManagerWriteLockHashed(int xid, byte * dat, int datLen) {
if(xid == -1) { return 0; }
pthread_mutex_lock(&xid_table_mutex);
pblHashTable_t * xidLocks = pblHtLookup_r(xidLockTable, &xid, sizeof(int));
if(!xidLocks) {
xidLocks = lockManagerBeginTransactionUnlocked(xid);
}
long currentLockLevel = (long)pblHtLookup_r(xidLocks, dat, datLen);
// printf("xid %d write lock (%d)\n", xid, currentLockLevel);
int me = 0;
pthread_mutex_unlock(&xid_table_mutex);
if(currentLockLevel >= LM_WRITELOCK) {
return 0;
} else if(currentLockLevel == LM_READLOCK) {
me = 1;
}
pthread_mutex_t * mut = getMutex(dat, datLen);
pthread_mutex_lock(mut);
lock * ridLock = pblHtLookup_r(ridLockTable, dat, datLen);
if(!ridLock) {
ridLock = createLock(dat, datLen);
}
ridLock->active++;
ridLock->waiting++;
if(ridLock->writers || (ridLock->readers - me)) {
struct timeval tv;
int tod_ret = gettimeofday(&tv, NULL);
tv.tv_sec++;
struct timespec ts;
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
if(tod_ret != 0) {
perror("Could not get time of day");
return LLADD_INTERNAL_ERROR;
}
while(ridLock->writers || (ridLock->readers - me)) {
int lockret = pthread_cond_timedwait(&ridLock->writeOK, mut, &ts);
if(lockret == ETIMEDOUT) {
ridLock->waiting--;
ridLock->active--;
pthread_mutex_unlock(mut);
return LLADD_DEADLOCK;
}
}
}
ridLock->waiting--;
if(currentLockLevel == 0) {
ridLock->readers++;
ridLock->writers++;
} else if (currentLockLevel == LM_READLOCK) {
ridLock->writers++;
pblHtRemove_r(xidLocks, dat, datLen);
}
if(currentLockLevel != LM_WRITELOCK) {
pblHtInsert_r(xidLocks, dat, datLen, (void*)LM_WRITELOCK);
}
ridLock->active--;
pthread_mutex_unlock(mut);
return 0;
}
