---

SemaphoreCommon.hpp

#if   !defined(__SEMAPHORECOMMON_HPP)
#define __SEMAPHORECOMMON_HPP

/*
  CoreLinux++ 
  Copyright (C) 1999,2000 CoreLinux Consortium
  
   The CoreLinux++ 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.

   The CoreLinux++ Library 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 the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  
*/

#if !defined(__COMMON_HPP)
#include <Common.hpp>
#endif

namespace corelinux
{
  struct   _CSAHeader
  {
    Int      creatorId;        // 0 if not opened before
    Int      currentUsed;      // The current used up in the pool
    Int      currentGrps;      // The current groups present
    Int      reserved;         // 
  };

  DECLARE_TYPE( struct _CSAHeader, CSAHeader );

  struct   _CSAGroupHeader
  {
    Int   groupInfo;           // Either an Id, 0 if tail, or -1 if available
    Int   groupShares;         // How many processes are using this
    Int   groupType;           // -1 not used, 0 Mutex, 1 Gateway, 2-10 res
    Int   groupSemCount;       // Semaphore count if info is -1 
    // and not reclaimed | !0 
  };

  DECLARE_TYPE( struct _CSAGroupHeader, CSAGrpHeader );

  struct   _CSASemaphoreHeader
  {
    Int   semOwner;            // Current semaphore owner
    Int   maxSemValue;         // 1 for mutexes, n for others, -1 if control
    Word  isRecursive;         // ? for instance, 0 for control
    Word  isBalking;           // ? for instance, 0 for control
    Int   semShares;           // Shares for this semaphore
  };

  DECLARE_TYPE( struct _CSASemaphoreHeader, CSASemHeader );

  DECLARE_CLASS( CoreLinuxGuardPool );

  DECLARE_CLASS( SemaphoreGroup );

  DECLARE_CLASS( MemoryStorage );

  DECLARE_CLASS( SemaphoreCommon );

  class SemaphoreCommon : public Synchronized
  {
  public:

    //
    // Accessors
    //

    static   Int   getSemaphoreMaxValue( SemaphoreGroupPtr, Int );

    //
    // Mutators
    //
    static   void  groupDefined( SemaphoreGroupPtr );

    static   Int   groupUnDefined( SemaphoreGroupPtr );

    static   Int   setLock( SemaphoreGroupPtr, Int, Int, Int );

    static   Int   setUnLock( SemaphoreGroupPtr, Int, Int, Int );

    static   Int   obtainSemaphore
    (
     SemaphoreGroupPtr,
     Int,
     IntRef,
     IntRef,
     IntRef,
     Int
     );
               
    static   Int   relinquishSemaphore(SemaphoreGroupPtr,Int);

    static   Int   setMaxValue( SemaphoreGroupPtr, Int, Int );



  protected:


    SemaphoreCommon( void );


    virtual           ~SemaphoreCommon( void );

    //
    // Instance mutators
    //

    void  registerGroup( SemaphoreGroupPtr );

    Int   deregisterGroup( SemaphoreGroupPtr );

    Int   claimSemaphore
    (
     SemaphoreGroupPtr,
     Int,
     IntRef,
     IntRef,
     IntRef,
     Int
     );

    Int   reclaimSemaphore(SemaphoreGroupPtr,Int);



    CSAGrpHeaderPtr   findGroup
    ( 
     IntCref , 
     IntCref , 
     CSAGrpHeaderPtr 
     );


    CSAGrpHeaderPtr   findAvailableGroup
    ( 
     IntCref , 
     IntCref , 
     CSAGrpHeaderPtr 
     );


    CSAGrpHeaderPtr   subsetGroup( Int, CSAGrpHeaderPtr ) ;

    CSAGrpHeaderPtr   combineGroup( Int, CSAGrpHeaderPtr ) ;

    bool  isOriginator( void ) const;

    Int   getOriginatorId( void ) const;

    Int   canonicalUndefined( void );



    static   void  createAttachment( void );

    friend   class CoreLinuxGuardPool;


    static   void  exitAttachment( void );


  private:

    SemaphoreCommon( SemaphoreCommonCref )
      throw ( Assertion )
      :
      Synchronized()
    {
      NEVER_GET_HERE;
    }

  private:

    MemoryStoragePtr     theCSA;
    CSAHeaderPtr         theBase;
    bool                 theOriginator;
    static   SemaphoreCommonPtr   theInstance;
    static   SemaphoreGroupPtr    theControlGroup;
    static   bool                 theInitializeFlag;
  };

}

#endif // if !defined(__SEMAPHORECOMMON_HPP)

/*
   Common rcs information do not modify
   $Author: prudhomm $
   $Revision: 1.8 $
   $Date: 2000/08/31 22:52:20 $
   $Locker:  $
*/

---

This is the CoreLinux++ reference manual
Provided by The CoreLinux Consortium