Loading...
Searching...
No Matches
Semaphore.cpp
Go to the documentation of this file.
// -*- c++ -*-
//------------------------------------------------------------------------------
// $Id: Semaphore.cpp,v 1.5 2012/05/20 04:12:18 vlg Exp $
//------------------------------------------------------------------------------
// Semaphore.C
//------------------------------------------------------------------------------
// Copyright (c) 2000 by Vladislav Grinchenko
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
// Created: 07/10/2000
//------------------------------------------------------------------------------
#if !defined(WIN32)
#include <sstream>
#include <string>
#include <iomanip>
#include "assa/Semaphore.h"
using namespace ASSA;
/*--- Static definitions and constants ---*/
const int ASSA::Semaphore::BIGCOUNT = 10000;
sembuf Semaphore::m_op_lock [2] =
{
{2, 0, 0}, // Wait for [2] lock to equal 0,
{2, 1, SEM_UNDO} // then increment [2] to 1 - this locks it.
// UNDO to release the lock if processes
// exits before explicitly unlocking.
};
sembuf Semaphore::m_op_endcreate [2] =
{
{1, -1, SEM_UNDO}, // Decrement [1] (proc counter) with undo on
// exit,
{2, -1, SEM_UNDO} // then decrement [2] (lock) back to 0.
};
sembuf Semaphore::m_op_open [2] =
{
{1, -1, SEM_UNDO}, // Decrement [1] (proc counter) with undo on
// exit.
};
sembuf Semaphore::m_op_close [3] =
{
{2, 0, 0}, // Wait for [2] lock to equal 0,
{2, 1, SEM_UNDO}, // then increment [2] to 1 - this locks it,
{1, 1, SEM_UNDO} // then increment [1] (proc counter)
};
sembuf Semaphore::m_op_unlock [1] =
{
{2, -1, SEM_UNDO} // Decrement [2] (lock) back to 0
};
sembuf Semaphore::m_op_op [1] =
{
{0, 99, SEM_UNDO} // Decrement or increment [0] with undo on
// exit. The 99 is set to the actual amount
// to add or substract (positive or negative)
};
//------------------------------------------------------------------------------
int
Semaphore::
create (key_t key_, int initval_)
{
trace_with_mask("Semaphore::create", SEM);
register int semval;
union semnum {
int val;
struct semid_ds* buf;
ushort* array;
} semctrl_arg;
if (IPC_PRIVATE == key_) {
EL((ASSAERR,"Not intended for private semaphores\n"));
return (-1);
}
else if (key_ == (key_t) -1) {
EL((ASSAERR,"Probably an ftok() error by caller\n"));
return (-1);
}
m_key = key_;
bool done = false;
while (!done) {
if ( (m_id = semget (m_key, 3, 0666 | IPC_CREAT)) < 0) {
EL((ASSAERR,"Permission problem or kernel tables full\n"));
return (-1);
}
/*
When the semaphore is created, we know that the value of
all 3 set members is 0.
Get a lock on the semaphore by waiting for [2] to equal 0,
then increment it.
There is a race condition here. There is a possibility
that between the semget(2) and semop(2) below, another
process can cal Semaphore:::close () member function
which can remove a semaphore if that process is the last
one using it.
Therefore, we handle the error condition of an invalid
semaphore ID specially below, and if it does happen, we
just go back and create it again.
*/
if (semop (m_id, &m_op_lock[0], 2) < 0) {
if (errno == EINVAL) {
continue;
}
EL((ASSAERR,"Can't lock semaphore\n"));
Assure_exit (false);
}
done = true;
} // while (!done)
/*
Get the value of the process counter. If it equals 0,
then no one has initialized the semaphore yet.
*/
if ((semval = semctl (m_id, 1, GETVAL, 0)) < 0) {
EL((ASSAERR,"Can't GETVAL\n"));
Assure_exit (false);
}
if (semval == 0) {
/*
We could initalize by doing a SETALL, but that
would clear the adjust value that we set when
we locked the semaphore above. Instead, we'll do
two system calls to initialize semaphore value [0]
and process counter [1].
*/
semctrl_arg.val = initval_;
if (semctl (m_id, 0, SETVAL, semctrl_arg) < 0) {
EL((ASSAERR,"Can't SETVAL[0]\n"));
Assure_exit (false);
}
semctrl_arg.val = BIGCOUNT;
if (semctl (m_id, 1, SETVAL, semctrl_arg) < 0) {
EL((ASSAERR,"Can't SETVAL[1]\n"));
Assure_exit (false);
}
} // if (semval == 0)
/*--- Decrement the process counter and then release the lock. ---*/
if (semop (m_id, &m_op_endcreate[0], 2) < 0) {
EL((ASSAERR,"Error on semop (ndcreate)\n"));
Assure_exit (false);
}
return (m_id);
}
int
Semaphore::
open (key_t key_)
{
trace_with_mask("Semaphore::open", SEM);
if (IPC_PRIVATE == key_) {
EL((ASSAERR,"Not intended for private semaphores\n"));
return (-1);
}
else if (key_ == (key_t) -1) {
EL((ASSAERR,"Probably an ftok() error by caller\n"));
return (-1);
}
m_key = key_;
if ((m_id = semget (m_key, 3, 0)) < 0) {
EL((ASSAERR,"Error on semget(3)"));
return (-1);
}
/*--- Decrement the process counter. No need for lock ---*/
if (semop (m_id, &m_op_open[0], 1) < 0) {
EL((ASSAERR,"Error on semget(open)\n"));
Assure_exit(false);
}
return (m_id);
}
void
Semaphore::
remove ()
{
trace_with_mask("Semaphore::remove", SEM);
if (m_id < 0 || m_key == ((key_t) -1) ) return;
if (semctl (m_id, 0, IPC_RMID, 0) < 0) {
EL((ASSAERR,"Can't IPC_RMID\n"));
Assure_exit(false);
}
init ();
}
void
Semaphore::
close ()
{
trace_with_mask("Semaphore::close", SEM);
register int semval;
if (m_id < 0) return;
/*
First get the lock on semaphore, then increment process counter.
*/
if (semop (m_id, &m_op_close[0], 3) < 0) {
EL((ASSAERR,"Can't semop(2)\n"));
Assure_exit(false);
}
/*
Now that we have a lock, read the value of the process counter
to see if this is the last reference to the semaphore.
There is a race condition here (same as in Semaphore::create()).
*/
if ((semval = semctl (m_id, 1, GETVAL, 0)) < 0) {
EL((ASSAERR,"Can't GETVAL\n"));
Assure_exit(false);
}
if (semval > BIGCOUNT) {
EL((ASSAERR,"sem[1] > BIGCOUNT\n"));
Assure_exit(false);
}
else if (semval == BIGCOUNT) {
remove ();
}
else if (semop (m_id, &m_op_unlock[0], 1) < 0) {
EL((ASSAERR,"Can't unlock\n"));
Assure_exit(false);
}
/*--- Invalidate ---*/
init ();
}
void
Semaphore::
op (int value_)
{
/* Test if m_id is still valid. If it fails, then
* next operation is failing because of it. If not,
* then something else happens here.
*/
trace_with_mask("Semaphore::op", SEM);
int semval = 0;
dump ();
if ((semval = semctl (m_id, 1, GETVAL, 0)) < 0) {
EL((ASSAERR,"Can't GETVAL\n"));
Assure_exit (false);
}
/* This will fail on Solaris? */
if ((m_op_op[0].sem_op = value_) == 0) {
EL((ASSAERR,"Can't have value_ == 0\n"));
Assure_exit(false);
}
if (semop (m_id, &m_op_op[0], 1) < 0) {
EL((ASSAERR,"sem_op error\n"));
Assure_exit(false);
}
}
void
Semaphore::
dump (void) const
{
trace_with_mask("Semaphore::dump", SEM);
std::ostringstream msg;
msg << "\n\n\tKey.....: ";
if (m_key == (key_t) -1) {
msg << m_key;
}
else {
msg << "0x" << std::hex << m_key << std::dec;
}
msg << "\n\tID......: " << m_id << "\n\n";
if (m_id >= 0 && m_key >= (key_t) -1) {
msg << "\tsemval [0]\tproc counter[1]\tlock [2]\n"
<< "\t----------\t---------------\t--------\n";
/*--- Get value of element in semaphore set ---*/
msg << "\t " << semctl (m_id, 0, GETVAL)
<< "\t\t " << semctl (m_id, 1, GETVAL)
<< "\t\t " << semctl (m_id, 2, GETVAL);
}
else {
msg << "Semaphore id = -1. No info is available.";
}
msg << std::ends;
DL((SEM,"%s\n\n", msg.str ().c_str ()));
}
#endif /* !defined(WIN32) */
Assure_exit
#define Assure_exit(exp_)
Macro that makes program exit if assert fails.
Definition Assure.h:39
EL
#define EL(X)
A macro for writing error message to the Logger.
Definition Logger.h:285
DL
#define DL(X)
A macro for writing debug message to the Logger.
Definition Logger.h:273
trace_with_mask
#define trace_with_mask(s, m)
trace_with_mask() is used to trace function call chain in C++ program.
Definition Logger.h:437
Semaphore.h
Semaphore class provides a simpler and easier interface to System V semaphore system calls.
ASSA::AutoPtrRef
A wrapper class to provide AutoPtr with reference semantics.
Definition AutoPtr.h:32
ASSA::Semaphore::m_op_open
static sembuf m_op_open[2]
Decrement process counter with undo on exit.
Definition Semaphore.h:171
ASSA::Semaphore::m_id
int m_id
Semaphore's id.
Definition Semaphore.h:154
ASSA::Semaphore::remove
void remove()
Remove a semaphore.
Definition Semaphore.cpp:204
ASSA::Semaphore::create
int create(key_t key_, int initval_=1)
Create a semaphore with a specified initial value.
Definition Semaphore.cpp:74
ASSA::Semaphore::init
void init()
Initalize by invalidating data members.
Definition Semaphore.h:211
ASSA::Semaphore::m_op_op
static sembuf m_op_op[1]
Decrement or increment semaphore with undo on exit.
Definition Semaphore.h:186
ASSA::Semaphore::m_op_unlock
static sembuf m_op_unlock[1]
Decremetn lock back to 0.
Definition Semaphore.h:180
ASSA::Semaphore::m_op_close
static sembuf m_op_close[3]
Wait for lock to equal 0, then increment lock to 1 (lock it), then increment process counter.
Definition Semaphore.h:176
ASSA::Semaphore::m_key
key_t m_key
Semaphore's key.
Definition Semaphore.h:151
ASSA::Semaphore::op
void op(int val_)
General semaphore operation.
Definition Semaphore.cpp:262
ASSA::Semaphore::m_op_lock
static sembuf m_op_lock[2]
Wait for lock to equal 0, then increment lock to 1 - this locks it.
Definition Semaphore.h:161
ASSA::Semaphore::BIGCOUNT
static const int BIGCOUNT
Definition Semaphore.h:157
ASSA::Semaphore::dump
void dump(void) const
Dump the objects state along with the state of the semaphore (if connected) to the log file.
Definition Semaphore.cpp:293
ASSA::Semaphore::m_op_endcreate
static sembuf m_op_endcreate[2]
Decrement process counter with undo on exit, then decrement lock back to 0.
Definition Semaphore.h:166
ASSA::Semaphore::close
void close()
Close a semaphore.
Definition Semaphore.cpp:219
ASSA::Semaphore::open
int open(key_t key_)
Open a semaphore that must already exist.
Definition Semaphore.cpp:174
ASSA
Definition Acceptor.h:40
ASSA::SEM
@ SEM
Class Semaphore messages
Definition LogMask.h:37
ASSA::ASSAERR
@ ASSAERR
ASSA and system errors
Definition LogMask.h:34