trunk/runtime/sv5ipc.inc

{Used by ISQLMonitor and implements System V IPC}

const
  IPCFileName: string = 'FB.SQL.MONITOR1_0';
  cNumberOfSemaphores = 10;
  cMutexSemaphore = 0;
  cMonitorCounter = 1;
  cReadReadyEventSemaphore = 2;
  cReadFinishedEventSemaphore = 4;
  cDataAvailableEventSemaphore = 6;
  cWriterBusyEventSemaphore = 8;
  cDefaultTimeout = 1; { 1 seconds }

{
  The call to semctl in ipc is broken in FPC release 2.4.2 and earlier. Hence
  need to replace with a working libc call. semtimedop is not present in 2.4.2 and earlier.
}

{$IF FPC_FULLVERSION <= 20402 }
Function real_semctl(semid:cint; semnum:cint; cmd:cint): cint; cdecl; varargs; external clib name 'semctl';

Function semctl(semid:cint; semnum:cint; cmd:cint; var arg: tsemun): cint;
  begin
    semctl := real_semctl(semid,semnum,cmd,pointer(arg));
  end;
{$IFDEF HAS_SEMTIMEDOP}
Function semtimedop(semid:cint; sops: psembuf; nsops: cuint; timeOut: ptimespec): cint; cdecl; external clib name 'semtimedop';
{$ENDIF}
Function semget(key:Tkey; nsems:cint; semflg:cint): cint; cdecl; external clib name 'semget';
Function semop(semid:cint; sops: psembuf; nsops: cuint): cint; cdecl; external clib name 'semop';

function GetLastErrno: cint;
begin
  Result := fpgetCerrno
end;
{$ELSE}
function GetLastErrno: cint;
begin
  Result := fpgetErrno
end;

{$ENDIF}

type
  TGlobalInterface = class;
  {Interprocess Communication Objects. All platform dependent IPC is abstracted
   into this set of objects }

  { TIpcCommon }

  TIpcCommon = class
   private
    function GetSa: PSecurityAttributes;
 protected
    FInitialiser: boolean;  static;
    FSemaphoreSetID: cint;  static;
    FSharedMemoryID: cint;  static;
    function sem_op(SemNum, op: integer; flags: cshort = 0): cint;
    function sem_timedop(SemNum, op: integer; timeout_secs: integer; flags: cshort = 0): cint;
    function GetSemValue(SemNum: integer): cint;
    procedure SemInit(SemNum, AValue: cint);
  public
    property Sa : PSecurityAttributes read GetSa;
  end;

  { TSharedMemory }

  {
    The shared memory segment is used for interprocess communication and
    holds both a message buffer and a number of shared variables. Shared
    memory is allocated to each shared variable using the Allocate function.
    An underlying assumption is that each process using the shared memory
    calls "Allocate" in the same order and for the same memory sizes.

    Linux:

    The Linux implementation uses Linux shared memory. IPC_PRIVATE is used
    to allocate the memory and the resulting memory id is written to a
    well known file. By default this is in the current user's home directory,
    but this can be over-ridden to specify a globally unique filename.

    Access to the shared memory is restricted to the current user/group.
    Note that the Linux semaphore set is also created with the shared memory.
  }

  TSharedMemory = class(TIpcCommon)
  private
    FBuffer: PChar;
    FLastAllocationSize: integer;
    FUnused: integer;
    FBufptr: PChar;
    procedure DropSharedMemory;
    procedure GetSharedMemory(MemSize: integer);
  public
    constructor Create(MemSize: integer);
    destructor Destroy; override;
    function Allocate(Size: integer): PChar;
    property LastAllocationSize: integer read FLastAllocationSize;
  end;

  {TMutex}

  TMutex = class(TIpcCommon)
  private
    FMutexSemaphore: cint;
    FLockCount: integer;
  public
    constructor Create(SemNumber: cint);
    procedure Lock;
    procedure Unlock;
  end;

  { TSingleLockGate }

  {
    A single lock gate is either open or closed. When open, any thread can pass
    through it while, when closed, all threads are blocked as they try to pass
    through the gate. When the gate is opened, all blocked threads are resumed.

    There is an implementation assumption that only one writer thread at
    a time (i.e. the thread which locks or unlocks the gate) can have access to
    it at any one time. I.e. an external Mutex prevents race conditions.

    Linux:

    In the Linux implementation, the gate is implemented by a semaphore
    and a share memory integer used as a bi-state variable. When the gate
    is open, the bi-state variable is non-zero. It is set to zero when closed.
    Another shared memory integer is used to count the number of waiting
    threads, and a second semaphore is used to protect access to this.

    The event semaphore is initialised to zero. When a thread passes through the gate
    it checks the state. If open, the thread continues. If closed then it
    increments the count of waiting threads and then decrements the semaphore
    and hence enters an indefinite wait state.

    When the gate is locked, the state is set to zero. When unlocked, the state
    is set to one and the semaphore incremented by the number of waiting threads,
    which itself is then zeroed.

    Always initialised to the Unlocked state
  }

  TSingleLockGate = class(TIpcCommon)
  private
    FOwner: TGlobalInterface;
    FSemaphore: cint;
    FMutex: cint;
    FSignalledState: PInteger;
    FWaitingThreads: PInteger;
    function GetWaitingThreads: integer;
  public
    constructor Create(SemNum: cint; AOwner: TGlobalInterface);
    property WaitingThreads: integer read GetWaitingThreads;
  public
    procedure PassthroughGate;
    procedure Unlock;
    procedure Lock;
  end;

  { TMultilockGate }

  { This type of Gate is used where several reader threads must pass
    through the gate before it can be opened for a writer thread.

    The reader threads register their interest by each locking the gate.
    The writer thread then waits on the locked gate until all the reader
    threads have separately unlocked the gate.

    There is an underlying assumption of a single writer. A Mutex must
    be used to control access to the gate from the writer side if this
    assumption is invalid.

    Linux:

    The Linux implementation uses a single semaphore to implement the gate,
    which is initialised to 1 (unlocked), and a count of the number of
    threads that have locked the gate (LockCount). A mutex semaphore
    protects access to the LockCount. When the gate is locked, the lockcount
    is incremented and, if the LockCount was originally zero, the semaphore is
    set to zero (Gate Closed).

    Unlocking the gate, is the reverse. The LockCount is decremented and, if it
    reaches zero, the semaphore is set to one (Gate Opened).

    When a writer passes through the gate, it checks the LockCount, if zero it
    proceeds to pass through the gate. Otherwise it decrements and waits on the
    semaphore. When the writer resumes, it increments the semaphore in order
    to return it to its unlocked state. The wait is a timed wait, as there is
    a risk that a reader thread may terminate while the gate is locked. If the
    LockCount is non-zero, it is decremented and the writer returns to wait on
    the gate.

    Always initialised to the Unlocked state
  }

  TMultilockGate = class(TIpcCommon)
  private
    FOnGateTimeout: TNotifyEvent;
    FOwner: TGlobalInterface;
    FSemaphore: cint;
    FMutex: cint;
    FLockCount: PInteger;
    function GetLockCount: integer;
  public
    constructor Create(SemNum: cint; AOwner: TGlobalInterface);
    procedure Lock;
    procedure Unlock;
    procedure PassthroughGate;
    property LockCount: integer read GetLockCount;
    property OnGateTimeout: TNotifyEvent read FOnGateTimeout write FOnGateTimeout;
  end;

  { TGlobalInterface }

  TGlobalInterface = class(TIpcCommon)
  private
    FMaxBufferSize: integer;
    FSharedMemory: TSharedMemory;
    FWriteLock: TMutex;
    FBuffer: PChar;
    FTraceDataType,
    FBufferSize: PInteger;
    FTimeStamp: PDateTime;
    FReadReadyEvent: TMultiLockGate;
    FReadFinishedEvent: TMultiLockGate;
    FDataAvailableEvent: TSingleLockGate;
    FWriterBusyEvent: TSingleLockGate;
    function GetMonitorCount: integer;
  public
    constructor Create;
    destructor Destroy; override;
    procedure IncMonitorCount;
    procedure DecMonitorCount;
    procedure SendTrace(TraceObject: TTraceObject);
    procedure ReceiveTrace(TraceObject: TTraceObject);
    property DataAvailableEvent: TSingleLockGate read FDataAvailableEvent;
    property WriterBusyEvent: TSingleLockGate read FWriterBusyEvent;
    property ReadReadyEvent: TMultiLockGate read FReadReadyEvent;
    property ReadFinishedEvent: TMultiLockGate read FReadFinishedEvent;
    property WriteLock: TMutex read FWriteLock;
    property MonitorCount: integer read GetMonitorCount;
    property SharedMemory: TSharedMemory read FSharedMemory;
    property MaxBufferSize: integer read FMaxBufferSize;
  end;

{ TSharedMemory }

procedure TSharedMemory.GetSharedMemory(MemSize: integer);
var F: cint;
begin
    {Get the Shared Memory and Semaphore IDs from the Global File if it exists
     or create them and the file otherwise }

    repeat
      F := fpOpen(IPCFileName, O_WrOnly or O_Creat or O_Excl);
      if F < 0 then
      begin
        if fpgetErrno = 17 {EEXIST} then
        begin
          { looks like it already exists}
          Sleep(100);
          F := fpOpen(IPCFileName,O_RdOnly);
          if (F < 0) and (fpgetErrno = 2 {ENOENT}) then
            {probably just got deleted }
          else
          if F < 0 then
            IBError(ibxeCannotCreateSharedResource,['Error accessing IPC File - ' +
                                                 StrError(fpgetErrno)]);
        end
        else
            IBError(ibxeCannotCreateSharedResource,['Error creating IPC File  - ' +
                                                 StrError(fpgetErrno)]);
      end
      else
        FInitialiser := true
    until F >= 0;

    if FInitialiser then
    begin
      FSharedMemoryID := shmget(IPC_PRIVATE,MemSize, IPC_CREAT or
                           S_IRUSR or S_IWUSR or S_IRGRP or S_IWGRP);
      if FSharedMemoryID < 0 then
          IBError(ibxeCannotCreateSharedResource,['Cannot create shared memory segment - ' +
                                                 StrError(fpgetErrno)]);

      FSemaphoreSetID := semget(IPC_PRIVATE, cNumberOfSemaphores,IPC_CREAT or
                           S_IRUSR or S_IWUSR or S_IRGRP or S_IWGRP);
      if FSemaphoreSetID < 0 then
          IBError(ibxeCannotCreateSharedResource,['Cannot create shared semaphore set - ' +
                                                 StrError(fpgetErrno)]);

      fpWrite(F,FSharedMemoryID,sizeof(FSharedMemoryID));
      fpWrite(F,FSemaphoreSetID,sizeof(FSemaphoreSetID));
    end
    else
    begin
      fpRead(F,FSharedMemoryID,sizeof(FSharedMemoryID));
      fpRead(F,FSemaphoreSetID,sizeof(FSemaphoreSetID));
      if GetSemValue(cMonitorCounter) = 0 then
      begin
        FInitialiser := true;
        //writeln('Opened file and is initialiser');
      end
    end;
    fpClose(F);
end;

procedure TSharedMemory.DropSharedMemory;
var ds: TShmid_ds;
    arg: tsemun;
begin
  if shmctl(FSharedMemoryID,IPC_STAT,@ds) < 0 then
    IBError(ibxeSV5APIError,['Error getting shared memory info' + strError(fpgetErrno)]);
  if ds.shm_nattch = 0 then  { we are the last one out - so, turn off the lights }
  begin
    shmctl(FSharedMemoryID,IPC_RMID,nil);
    semctl(FSemaphoreSetID,0,IPC_RMID,arg);
    DeleteFile(IPCFileName);
  end;
end;

constructor TSharedMemory.Create(MemSize: integer);
begin
  inherited Create;
  FInitialiser := false;
  GetSharedMemory(MemSize);
  FBuffer := shmat(FSharedMemoryID,nil,0);
  if PtrInt(FBuffer) = -1 then
    IBError(ibxeCannotCreateSharedResource,[StrError(Errno)]);
  FBufPtr := FBuffer;
  FUnused := MemSize
end;

destructor TSharedMemory.Destroy;
begin
  shmdt(FBuffer);
  DropSharedMemory;
  inherited Destroy;
end;

function TSharedMemory.Allocate(Size: integer): PChar;
begin
  if Size > FUnused then
      IBError(ibxeCannotCreateSharedResource, ['Not enough shared memory']);
  Result := FBufPtr;

  if Size = 0 then
  begin
    FLastAllocationSize := FUnused;
    FUnused := 0
  end
  else
  begin
    FLastAllocationSize := Size;
    Dec(FUnused,Size);
  end;
  Inc(FBufPtr,Size)
end;

{ TIpcCommon }

function TIpcCommon.GetSa: PSecurityAttributes;
begin
  Result := nil
end;

function TIpcCommon.sem_op(SemNum, op: integer; flags: cshort): cint;
var sembuf: TSEMbuf;
begin
    sembuf.sem_num := SemNum;
    sembuf.sem_op:= op;
    sembuf.sem_flg := flags or SEM_UNDO;
    Result := semop(FSemaphoreSetID,@sembuf,1);
end;

function TIpcCommon.sem_timedop(SemNum, op: integer; timeout_secs: integer;
  flags: cshort): cint;
var sembuf: TSEMbuf;
    timeout: TimeSpec;
begin
    sembuf.sem_num := SemNum;
    sembuf.sem_op:= op;
    sembuf.sem_flg := flags or SEM_UNDO;
    timeout.tv_sec := timeout_secs;
    timeout.tv_nsec := 0;
{$IFDEF HAS_SEMTIMEDOP}
    Result := semtimedop(FSemaphoreSetID,@sembuf,1,@timeout);
{$ELSE}
    Result := semop(FSemaphoreSetID,@sembuf,1);    {May hang on race condition}
{$ENDIF}
end;

function TIpcCommon.GetSemValue(SemNum: integer): cint;
var args :TSEMun;
begin
  Result := semctl(FSemaphoreSetID,SemNum,SEM_GETVAL,args);
  if Result < 0 then
     IBError(ibxeSV5APIError,['GetSemValue: '+strError(GetLastErrno)]);
end;

procedure TIpcCommon.SemInit(SemNum, AValue: cint);
var args :TSEMun;
begin
  //writeln('Initialising ',SemNum,' to ',AValue);
  args.val := AValue;
  if semctl(FSemaphoreSetID,SemNum,SEM_SETVAL,args)  < 0 then
     IBError(ibxeCannotCreateSharedResource,['Unable to initialise Semaphone ' +
                          IntToStr(SemNum) + '- ' + StrError(GetLastErrno)]);

end;

  { TMutex }

constructor TMutex.Create(SemNumber: cint);
begin
  inherited Create;
  FMutexSemaphore := SemNumber;
  if FInitialiser then
    SemInit(FMutexSemaphore,1)
end;

{ Obtain ownership of the Mutex and prevent other threads from accessing protected resource }

procedure TMutex.Lock;
begin
  //writeln('Lock: Entering Mutex ',FMutexSemaphore,' LockCount=',FLockCount,' State = ',GetSemValue(FMutexSemaphore));
  if FLockCount = 0 then
    sem_op(FMutexSemaphore,-1);
  Inc(FLockCount);
  //writeln('Lock: Mutex Exit');
end;

{Give up ownership of the Mutex and allow other threads access }

procedure TMutex.Unlock;
begin
  //writeln('UnLock: Entering Mutex, LockCount=',FLockCount);
  if FLockCount = 0 then Exit;
  Dec(FLockCount);
  if FLockCount = 0 then
    sem_op(FMutexSemaphore,1);
  //writeln('UnLock: Mutex Exit',' State = ',GetSemValue(FMutexSemaphore));
end;

{ TSingleLockGate }

function TSingleLockGate.GetWaitingThreads: integer;
begin
  Result := FWaitingThreads^
end;

constructor TSingleLockGate.Create(SemNum: cint; AOwner: TGlobalInterface);
begin
  inherited Create;
  FOwner := AOwner;
  FSignalledState := PInteger(FOwner.SharedMemory.Allocate(sizeof(FSignalledState)));
  FWaitingThreads := PInteger(FOwner.SharedMemory.Allocate(sizeof(FWaitingThreads)));
  FSemaphore := SemNum;
  FMutex := SemNum + 1;
  if FInitialiser then
  begin
    FSignalledState^ := 1;
    FWaitingThreads^ := 0;
    SemInit(FSemaphore,0);
    SemInit(FMutex,1);
  end;
end;

procedure TSingleLockGate.PassthroughGate;
begin
  if FSignalledState^ = 0 then
  begin
    sem_op(FMutex,-1,0); //Acquire Mutex
    Inc(FWaitingThreads^);
    sem_op(FMutex,1,0); //Release Mutex
    //writeln(ClassName + ': Wait State Entered ',FSemaphore,' = ',GetSemValue(FSemaphore));
    sem_op(FSemaphore,-1,0); //Enter Wait
    //writeln(ClassName + ': Wait State Ends ',FSemaphore);
  end;
end;

procedure TSingleLockGate.Unlock;
begin
  if FSignalledState^ = 0 then
  begin
    FSignalledState^ := 1;
    sem_op(FMutex,-1,0); //Acquire Mutex
    //writeln(ClassName + ': Unlocking' ,FSemaphore);
    sem_op(FSemaphore,FWaitingThreads^,0);
    FWaitingThreads^ := 0;
    sem_op(FMutex,1,0); //Release Mutex
  end;
end;

procedure TSingleLockGate.Lock;
begin
  if FSignalledState^ = 1 then
  begin
    //writeln(ClassName + ': Locking Gate ',FSemaphore);
    SemInit(FSemaphore,0);
    FSignalledState^ := 0;
  end;
end;

{ TMultilockGate }

constructor TMultilockGate.Create(SemNum: cint; AOwner: TGlobalInterface);
begin
  inherited Create;
  FOwner := AOwner;
  FSemaphore := SemNum;
  FMutex := SemNum + 1;
  FLockCount := PInteger(FOwner.SharedMemory.Allocate(sizeof(FLockCount)));
  if FInitialiser then
  begin
    FLockCount^ := 0;
    SemInit(FSemaphore,1);
    SemInit(FMutex,1);
  end;
end;

function TMultilockGate.GetLockCount: integer;
begin
  Result := FLockCount^
end;

procedure TMultilockGate.Lock;
begin
    sem_op(FMutex,-1,0); //Acquire Mutex
    if FLockCount^ = 0 then
    begin
      //writeln(ClassName,': Locking ',FSemaphore);
      SemInit(FSemaphore,0);
    end;
    Inc(FLockCount^);
    sem_op(FMutex,1,0); //Release Mutex
end;

procedure TMultilockGate.Unlock;
begin
    sem_op(FMutex,-1,0); //Acquire Mutex
    Dec(FLockCount^);
    if FLockCount^ <= 0 then
    begin
      //writeln(ClassName,': UnLocking ',FSemaphore);
      SemInit(FSemaphore,1);
      FLockCount^ := 0
    end;
    sem_op(FMutex,1,0); //Release Mutex
end;

procedure TMultilockGate.PassthroughGate;
begin
  if FLockCount^ = 0 then
    Exit;
  //writeln(ClassName,': Waiting on ',FSemaphore);
  while sem_timedop(FSemaphore,-1,cDefaultTimeout) < 0 do
  {looks like we lost a reader}
  begin
    if FLockCount^ > 0 then
    begin
      UnLock;
      if assigned(FOnGateTimeout) then
        OnGateTimeout(self)
    end
  end;
  sem_op(FSemaphore,1);
  //writeln(ClassName,': Wait done on ',FSemaphore);
end;


{ TGlobalInterface }

function TGlobalInterface.GetMonitorCount: integer;
begin
  Result := GetSemValue(cMonitorCounter)
end;

constructor TGlobalInterface.Create;
begin
  inherited Create;
  FSharedMemory := TSharedMemory.Create(cMonitorHookSize);

  FWriteLock := TMutex.Create(cMutexSemaphore);

  FDataAvailableEvent := TSingleLockGate.Create(cDataAvailableEventSemaphore,self);
  FWriterBusyEvent := TSingleLockGate.Create(cWriterBusyEventSemaphore,self);
  FReadReadyEvent := TMultiLockGate.Create(cReadReadyEventSemaphore,self);
  FReadFinishedEvent := TMultiLockGate.Create(cReadFinishedEventSemaphore,self);

  if FInitialiser then
    SemInit(cMonitorCounter,0);
  FTraceDataType := PInteger(FSharedMemory.Allocate(sizeof(Integer)));
  FTimeStamp := PDateTime(FSharedMemory.Allocate(sizeof(TDateTime)));
  FBufferSize := PInteger(FSharedMemory.Allocate(sizeof(Integer)));
  FBuffer := FSharedMemory.Allocate(0); //All remaining
  FMaxBufferSize := FSharedMemory.LastAllocationSize;

  if FInitialiser then
  begin
    FBufferSize^ := 0;
    FDataAvailableEvent.Lock
  end;
end;

destructor TGlobalInterface.Destroy;
begin
  if assigned(FWriteLock) then FWriteLock.Free;
  if assigned(FDataAvailableEvent) then FDataAvailableEvent.Free;
  if assigned(FWriterBusyEvent) then FWriterBusyEvent.Free;
  if assigned(FReadReadyEvent) then FReadReadyEvent.Free;
  if assigned(FReadFinishedEvent) then FReadFinishedEvent.Free;
  if assigned(FSharedMemory) then FSharedMemory.Free;
  inherited Destroy;
end;

procedure TGlobalInterface.IncMonitorCount;
begin
  sem_op(cMonitorCounter,1);
end;

procedure TGlobalInterface.DecMonitorCount;
begin
  sem_op(cMonitorCounter,-1,IPC_NOWAIT);
end;

procedure TGlobalInterface.SendTrace(TraceObject: TTraceObject);
begin
  FTraceDataType^ := Integer(TraceObject.FDataType);
  FTimeStamp^ := TraceObject.FTimeStamp;
  FBufferSize^ := Min(Length(TraceObject.FMsg), MaxBufferSize);
  Move(TraceObject.FMsg[1], FBuffer^, FBufferSize^);
end;

procedure TGlobalInterface.ReceiveTrace(TraceObject: TTraceObject);
begin
  SetString(TraceObject.FMsg, FBuffer, FBufferSize^);
  TraceObject.FDataType := TTraceFlag(FTraceDataType^);
  TraceObject.FTimeStamp := TDateTime(FTimeStamp^);
end;


Revision:	33
Committed:	Sat Jul 18 12:30:52 2015 UTC (9 years, 4 months ago) by tony
File size:	19667 byte(s)
Log Message:	Committing updates for Release R1-3-1
#	User	Rev	Content
1	tony	33	{Used by ISQLMonitor and implements System V IPC}
2
3			const
4			IPCFileName: string = 'FB.SQL.MONITOR1_0';
5			cNumberOfSemaphores = 10;
6			cMutexSemaphore = 0;
7			cMonitorCounter = 1;
8			cReadReadyEventSemaphore = 2;
9			cReadFinishedEventSemaphore = 4;
10			cDataAvailableEventSemaphore = 6;
11			cWriterBusyEventSemaphore = 8;
12			cDefaultTimeout = 1; { 1 seconds }
13
14			{
15			The call to semctl in ipc is broken in FPC release 2.4.2 and earlier. Hence
16			need to replace with a working libc call. semtimedop is not present in 2.4.2 and earlier.
17			}
18
19			{$IF FPC_FULLVERSION <= 20402 }
20			Function real_semctl(semid:cint; semnum:cint; cmd:cint): cint; cdecl; varargs; external clib name 'semctl';
21
22			Function semctl(semid:cint; semnum:cint; cmd:cint; var arg: tsemun): cint;
23			begin
24			semctl := real_semctl(semid,semnum,cmd,pointer(arg));
25			end;
26			{$IFDEF HAS_SEMTIMEDOP}
27			Function semtimedop(semid:cint; sops: psembuf; nsops: cuint; timeOut: ptimespec): cint; cdecl; external clib name 'semtimedop';
28			{$ENDIF}
29			Function semget(key:Tkey; nsems:cint; semflg:cint): cint; cdecl; external clib name 'semget';
30			Function semop(semid:cint; sops: psembuf; nsops: cuint): cint; cdecl; external clib name 'semop';
31
32			function GetLastErrno: cint;
33			begin
34			Result := fpgetCerrno
35			end;
36			{$ELSE}
37			function GetLastErrno: cint;
38			begin
39			Result := fpgetErrno
40			end;
41
42			{$ENDIF}
43
44			type
45			TGlobalInterface = class;
46			{Interprocess Communication Objects. All platform dependent IPC is abstracted
47			into this set of objects }
48
49			{ TIpcCommon }
50
51			TIpcCommon = class
52			private
53			function GetSa: PSecurityAttributes;
54			protected
55			FInitialiser: boolean; static;
56			FSemaphoreSetID: cint; static;
57			FSharedMemoryID: cint; static;
58			function sem_op(SemNum, op: integer; flags: cshort = 0): cint;
59			function sem_timedop(SemNum, op: integer; timeout_secs: integer; flags: cshort = 0): cint;
60			function GetSemValue(SemNum: integer): cint;
61			procedure SemInit(SemNum, AValue: cint);
62			public
63			property Sa : PSecurityAttributes read GetSa;
64			end;
65
66			{ TSharedMemory }
67
68			{
69			The shared memory segment is used for interprocess communication and
70			holds both a message buffer and a number of shared variables. Shared
71			memory is allocated to each shared variable using the Allocate function.
72			An underlying assumption is that each process using the shared memory
73			calls "Allocate" in the same order and for the same memory sizes.
74
75			Linux:
76
77			The Linux implementation uses Linux shared memory. IPC_PRIVATE is used
78			to allocate the memory and the resulting memory id is written to a
79			well known file. By default this is in the current user's home directory,
80			but this can be over-ridden to specify a globally unique filename.
81
82			Access to the shared memory is restricted to the current user/group.
83			Note that the Linux semaphore set is also created with the shared memory.
84			}
85
86			TSharedMemory = class(TIpcCommon)
87			private
88			FBuffer: PChar;
89			FLastAllocationSize: integer;
90			FUnused: integer;
91			FBufptr: PChar;
92			procedure DropSharedMemory;
93			procedure GetSharedMemory(MemSize: integer);
94			public
95			constructor Create(MemSize: integer);
96			destructor Destroy; override;
97			function Allocate(Size: integer): PChar;
98			property LastAllocationSize: integer read FLastAllocationSize;
99			end;
100
101			{TMutex}
102
103			TMutex = class(TIpcCommon)
104			private
105			FMutexSemaphore: cint;
106			FLockCount: integer;
107			public
108			constructor Create(SemNumber: cint);
109			procedure Lock;
110			procedure Unlock;
111			end;
112
113			{ TSingleLockGate }
114
115			{
116			A single lock gate is either open or closed. When open, any thread can pass
117			through it while, when closed, all threads are blocked as they try to pass
118			through the gate. When the gate is opened, all blocked threads are resumed.
119
120			There is an implementation assumption that only one writer thread at
121			a time (i.e. the thread which locks or unlocks the gate) can have access to
122			it at any one time. I.e. an external Mutex prevents race conditions.
123
124			Linux:
125
126			In the Linux implementation, the gate is implemented by a semaphore
127			and a share memory integer used as a bi-state variable. When the gate
128			is open, the bi-state variable is non-zero. It is set to zero when closed.
129			Another shared memory integer is used to count the number of waiting
130			threads, and a second semaphore is used to protect access to this.
131
132			The event semaphore is initialised to zero. When a thread passes through the gate
133			it checks the state. If open, the thread continues. If closed then it
134			increments the count of waiting threads and then decrements the semaphore
135			and hence enters an indefinite wait state.
136
137			When the gate is locked, the state is set to zero. When unlocked, the state
138			is set to one and the semaphore incremented by the number of waiting threads,
139			which itself is then zeroed.
140
141			Always initialised to the Unlocked state
142			}
143
144			TSingleLockGate = class(TIpcCommon)
145			private
146			FOwner: TGlobalInterface;
147			FSemaphore: cint;
148			FMutex: cint;
149			FSignalledState: PInteger;
150			FWaitingThreads: PInteger;
151			function GetWaitingThreads: integer;
152			public
153			constructor Create(SemNum: cint; AOwner: TGlobalInterface);
154			property WaitingThreads: integer read GetWaitingThreads;
155			public
156			procedure PassthroughGate;
157			procedure Unlock;
158			procedure Lock;
159			end;
160
161			{ TMultilockGate }
162
163			{ This type of Gate is used where several reader threads must pass
164			through the gate before it can be opened for a writer thread.
165
166			The reader threads register their interest by each locking the gate.
167			The writer thread then waits on the locked gate until all the reader
168			threads have separately unlocked the gate.
169
170			There is an underlying assumption of a single writer. A Mutex must
171			be used to control access to the gate from the writer side if this
172			assumption is invalid.
173
174			Linux:
175
176			The Linux implementation uses a single semaphore to implement the gate,
177			which is initialised to 1 (unlocked), and a count of the number of
178			threads that have locked the gate (LockCount). A mutex semaphore
179			protects access to the LockCount. When the gate is locked, the lockcount
180			is incremented and, if the LockCount was originally zero, the semaphore is
181			set to zero (Gate Closed).
182
183			Unlocking the gate, is the reverse. The LockCount is decremented and, if it
184			reaches zero, the semaphore is set to one (Gate Opened).
185
186			When a writer passes through the gate, it checks the LockCount, if zero it
187			proceeds to pass through the gate. Otherwise it decrements and waits on the
188			semaphore. When the writer resumes, it increments the semaphore in order
189			to return it to its unlocked state. The wait is a timed wait, as there is
190			a risk that a reader thread may terminate while the gate is locked. If the
191			LockCount is non-zero, it is decremented and the writer returns to wait on
192			the gate.
193
194			Always initialised to the Unlocked state
195			}
196
197			TMultilockGate = class(TIpcCommon)
198			private
199			FOnGateTimeout: TNotifyEvent;
200			FOwner: TGlobalInterface;
201			FSemaphore: cint;
202			FMutex: cint;
203			FLockCount: PInteger;
204			function GetLockCount: integer;
205			public
206			constructor Create(SemNum: cint; AOwner: TGlobalInterface);
207			procedure Lock;
208			procedure Unlock;
209			procedure PassthroughGate;
210			property LockCount: integer read GetLockCount;
211			property OnGateTimeout: TNotifyEvent read FOnGateTimeout write FOnGateTimeout;
212			end;
213
214			{ TGlobalInterface }
215
216			TGlobalInterface = class(TIpcCommon)
217			private
218			FMaxBufferSize: integer;
219			FSharedMemory: TSharedMemory;
220			FWriteLock: TMutex;
221			FBuffer: PChar;
222			FTraceDataType,
223			FBufferSize: PInteger;
224			FTimeStamp: PDateTime;
225			FReadReadyEvent: TMultiLockGate;
226			FReadFinishedEvent: TMultiLockGate;
227			FDataAvailableEvent: TSingleLockGate;
228			FWriterBusyEvent: TSingleLockGate;
229			function GetMonitorCount: integer;
230			public
231			constructor Create;
232			destructor Destroy; override;
233			procedure IncMonitorCount;
234			procedure DecMonitorCount;
235			procedure SendTrace(TraceObject: TTraceObject);
236			procedure ReceiveTrace(TraceObject: TTraceObject);
237			property DataAvailableEvent: TSingleLockGate read FDataAvailableEvent;
238			property WriterBusyEvent: TSingleLockGate read FWriterBusyEvent;
239			property ReadReadyEvent: TMultiLockGate read FReadReadyEvent;
240			property ReadFinishedEvent: TMultiLockGate read FReadFinishedEvent;
241			property WriteLock: TMutex read FWriteLock;
242			property MonitorCount: integer read GetMonitorCount;
243			property SharedMemory: TSharedMemory read FSharedMemory;
244			property MaxBufferSize: integer read FMaxBufferSize;
245			end;
246
247			{ TSharedMemory }
248
249			procedure TSharedMemory.GetSharedMemory(MemSize: integer);
250			var F: cint;
251			begin
252			{Get the Shared Memory and Semaphore IDs from the Global File if it exists
253			or create them and the file otherwise }
254
255			repeat
256			F := fpOpen(IPCFileName, O_WrOnly or O_Creat or O_Excl);
257			if F < 0 then
258			begin
259			if fpgetErrno = 17 {EEXIST} then
260			begin
261			{ looks like it already exists}
262			Sleep(100);
263			F := fpOpen(IPCFileName,O_RdOnly);
264			if (F < 0) and (fpgetErrno = 2 {ENOENT}) then
265			{probably just got deleted }
266			else
267			if F < 0 then
268			IBError(ibxeCannotCreateSharedResource,['Error accessing IPC File - ' +
269			StrError(fpgetErrno)]);
270			end
271			else
272			IBError(ibxeCannotCreateSharedResource,['Error creating IPC File - ' +
273			StrError(fpgetErrno)]);
274			end
275			else
276			FInitialiser := true
277			until F >= 0;
278
279			if FInitialiser then
280			begin
281			FSharedMemoryID := shmget(IPC_PRIVATE,MemSize, IPC_CREAT or
282			S_IRUSR or S_IWUSR or S_IRGRP or S_IWGRP);
283			if FSharedMemoryID < 0 then
284			IBError(ibxeCannotCreateSharedResource,['Cannot create shared memory segment - ' +
285			StrError(fpgetErrno)]);
286
287			FSemaphoreSetID := semget(IPC_PRIVATE, cNumberOfSemaphores,IPC_CREAT or
288			S_IRUSR or S_IWUSR or S_IRGRP or S_IWGRP);
289			if FSemaphoreSetID < 0 then
290			IBError(ibxeCannotCreateSharedResource,['Cannot create shared semaphore set - ' +
291			StrError(fpgetErrno)]);
292
293			fpWrite(F,FSharedMemoryID,sizeof(FSharedMemoryID));
294			fpWrite(F,FSemaphoreSetID,sizeof(FSemaphoreSetID));
295			end
296			else
297			begin
298			fpRead(F,FSharedMemoryID,sizeof(FSharedMemoryID));
299			fpRead(F,FSemaphoreSetID,sizeof(FSemaphoreSetID));
300			if GetSemValue(cMonitorCounter) = 0 then
301			begin
302			FInitialiser := true;
303			//writeln('Opened file and is initialiser');
304			end
305			end;
306			fpClose(F);
307			end;
308
309			procedure TSharedMemory.DropSharedMemory;
310			var ds: TShmid_ds;
311			arg: tsemun;
312			begin
313			if shmctl(FSharedMemoryID,IPC_STAT,@ds) < 0 then
314			IBError(ibxeSV5APIError,['Error getting shared memory info' + strError(fpgetErrno)]);
315			if ds.shm_nattch = 0 then { we are the last one out - so, turn off the lights }
316			begin
317			shmctl(FSharedMemoryID,IPC_RMID,nil);
318			semctl(FSemaphoreSetID,0,IPC_RMID,arg);
319			DeleteFile(IPCFileName);
320			end;
321			end;
322
323			constructor TSharedMemory.Create(MemSize: integer);
324			begin
325			inherited Create;
326			FInitialiser := false;
327			GetSharedMemory(MemSize);
328			FBuffer := shmat(FSharedMemoryID,nil,0);
329			if PtrInt(FBuffer) = -1 then
330			IBError(ibxeCannotCreateSharedResource,[StrError(Errno)]);
331			FBufPtr := FBuffer;
332			FUnused := MemSize
333			end;
334
335			destructor TSharedMemory.Destroy;
336			begin
337			shmdt(FBuffer);
338			DropSharedMemory;
339			inherited Destroy;
340			end;
341
342			function TSharedMemory.Allocate(Size: integer): PChar;
343			begin
344			if Size > FUnused then
345			IBError(ibxeCannotCreateSharedResource, ['Not enough shared memory']);
346			Result := FBufPtr;
347
348			if Size = 0 then
349			begin
350			FLastAllocationSize := FUnused;
351			FUnused := 0
352			end
353			else
354			begin
355			FLastAllocationSize := Size;
356			Dec(FUnused,Size);
357			end;
358			Inc(FBufPtr,Size)
359			end;
360
361			{ TIpcCommon }
362
363			function TIpcCommon.GetSa: PSecurityAttributes;
364			begin
365			Result := nil
366			end;
367
368			function TIpcCommon.sem_op(SemNum, op: integer; flags: cshort): cint;
369			var sembuf: TSEMbuf;
370			begin
371			sembuf.sem_num := SemNum;
372			sembuf.sem_op:= op;
373			sembuf.sem_flg := flags or SEM_UNDO;
374			Result := semop(FSemaphoreSetID,@sembuf,1);
375			end;
376
377			function TIpcCommon.sem_timedop(SemNum, op: integer; timeout_secs: integer;
378			flags: cshort): cint;
379			var sembuf: TSEMbuf;
380			timeout: TimeSpec;
381			begin
382			sembuf.sem_num := SemNum;
383			sembuf.sem_op:= op;
384			sembuf.sem_flg := flags or SEM_UNDO;
385			timeout.tv_sec := timeout_secs;
386			timeout.tv_nsec := 0;
387			{$IFDEF HAS_SEMTIMEDOP}
388			Result := semtimedop(FSemaphoreSetID,@sembuf,1,@timeout);
389			{$ELSE}
390			Result := semop(FSemaphoreSetID,@sembuf,1); {May hang on race condition}
391			{$ENDIF}
392			end;
393
394			function TIpcCommon.GetSemValue(SemNum: integer): cint;
395			var args :TSEMun;
396			begin
397			Result := semctl(FSemaphoreSetID,SemNum,SEM_GETVAL,args);
398			if Result < 0 then
399			IBError(ibxeSV5APIError,['GetSemValue: '+strError(GetLastErrno)]);
400			end;
401
402			procedure TIpcCommon.SemInit(SemNum, AValue: cint);
403			var args :TSEMun;
404			begin
405			//writeln('Initialising ',SemNum,' to ',AValue);
406			args.val := AValue;
407			if semctl(FSemaphoreSetID,SemNum,SEM_SETVAL,args) < 0 then
408			IBError(ibxeCannotCreateSharedResource,['Unable to initialise Semaphone ' +
409			IntToStr(SemNum) + '- ' + StrError(GetLastErrno)]);
410
411			end;
412
413			{ TMutex }
414
415			constructor TMutex.Create(SemNumber: cint);
416			begin
417			inherited Create;
418			FMutexSemaphore := SemNumber;
419			if FInitialiser then
420			SemInit(FMutexSemaphore,1)
421			end;
422
423			{ Obtain ownership of the Mutex and prevent other threads from accessing protected resource }
424
425			procedure TMutex.Lock;
426			begin
427			//writeln('Lock: Entering Mutex ',FMutexSemaphore,' LockCount=',FLockCount,' State = ',GetSemValue(FMutexSemaphore));
428			if FLockCount = 0 then
429			sem_op(FMutexSemaphore,-1);
430			Inc(FLockCount);
431			//writeln('Lock: Mutex Exit');
432			end;
433
434			{Give up ownership of the Mutex and allow other threads access }
435
436			procedure TMutex.Unlock;
437			begin
438			//writeln('UnLock: Entering Mutex, LockCount=',FLockCount);
439			if FLockCount = 0 then Exit;
440			Dec(FLockCount);
441			if FLockCount = 0 then
442			sem_op(FMutexSemaphore,1);
443			//writeln('UnLock: Mutex Exit',' State = ',GetSemValue(FMutexSemaphore));
444			end;
445
446			{ TSingleLockGate }
447
448			function TSingleLockGate.GetWaitingThreads: integer;
449			begin
450			Result := FWaitingThreads^
451			end;
452
453			constructor TSingleLockGate.Create(SemNum: cint; AOwner: TGlobalInterface);
454			begin
455			inherited Create;
456			FOwner := AOwner;
457			FSignalledState := PInteger(FOwner.SharedMemory.Allocate(sizeof(FSignalledState)));
458			FWaitingThreads := PInteger(FOwner.SharedMemory.Allocate(sizeof(FWaitingThreads)));
459			FSemaphore := SemNum;
460			FMutex := SemNum + 1;
461			if FInitialiser then
462			begin
463			FSignalledState^ := 1;
464			FWaitingThreads^ := 0;
465			SemInit(FSemaphore,0);
466			SemInit(FMutex,1);
467			end;
468			end;
469
470			procedure TSingleLockGate.PassthroughGate;
471			begin
472			if FSignalledState^ = 0 then
473			begin
474			sem_op(FMutex,-1,0); //Acquire Mutex
475			Inc(FWaitingThreads^);
476			sem_op(FMutex,1,0); //Release Mutex
477			//writeln(ClassName + ': Wait State Entered ',FSemaphore,' = ',GetSemValue(FSemaphore));
478			sem_op(FSemaphore,-1,0); //Enter Wait
479			//writeln(ClassName + ': Wait State Ends ',FSemaphore);
480			end;
481			end;
482
483			procedure TSingleLockGate.Unlock;
484			begin
485			if FSignalledState^ = 0 then
486			begin
487			FSignalledState^ := 1;
488			sem_op(FMutex,-1,0); //Acquire Mutex
489			//writeln(ClassName + ': Unlocking' ,FSemaphore);
490			sem_op(FSemaphore,FWaitingThreads^,0);
491			FWaitingThreads^ := 0;
492			sem_op(FMutex,1,0); //Release Mutex
493			end;
494			end;
495
496			procedure TSingleLockGate.Lock;
497			begin
498			if FSignalledState^ = 1 then
499			begin
500			//writeln(ClassName + ': Locking Gate ',FSemaphore);
501			SemInit(FSemaphore,0);
502			FSignalledState^ := 0;
503			end;
504			end;
505
506			{ TMultilockGate }
507
508			constructor TMultilockGate.Create(SemNum: cint; AOwner: TGlobalInterface);
509			begin
510			inherited Create;
511			FOwner := AOwner;
512			FSemaphore := SemNum;
513			FMutex := SemNum + 1;
514			FLockCount := PInteger(FOwner.SharedMemory.Allocate(sizeof(FLockCount)));
515			if FInitialiser then
516			begin
517			FLockCount^ := 0;
518			SemInit(FSemaphore,1);
519			SemInit(FMutex,1);
520			end;
521			end;
522
523			function TMultilockGate.GetLockCount: integer;
524			begin
525			Result := FLockCount^
526			end;
527
528			procedure TMultilockGate.Lock;
529			begin
530			sem_op(FMutex,-1,0); //Acquire Mutex
531			if FLockCount^ = 0 then
532			begin
533			//writeln(ClassName,': Locking ',FSemaphore);
534			SemInit(FSemaphore,0);
535			end;
536			Inc(FLockCount^);
537			sem_op(FMutex,1,0); //Release Mutex
538			end;
539
540			procedure TMultilockGate.Unlock;
541			begin
542			sem_op(FMutex,-1,0); //Acquire Mutex
543			Dec(FLockCount^);
544			if FLockCount^ <= 0 then
545			begin
546			//writeln(ClassName,': UnLocking ',FSemaphore);
547			SemInit(FSemaphore,1);
548			FLockCount^ := 0
549			end;
550			sem_op(FMutex,1,0); //Release Mutex
551			end;
552
553			procedure TMultilockGate.PassthroughGate;
554			begin
555			if FLockCount^ = 0 then
556			Exit;
557			//writeln(ClassName,': Waiting on ',FSemaphore);
558			while sem_timedop(FSemaphore,-1,cDefaultTimeout) < 0 do
559			{looks like we lost a reader}
560			begin
561			if FLockCount^ > 0 then
562			begin
563			UnLock;
564			if assigned(FOnGateTimeout) then
565			OnGateTimeout(self)
566			end
567			end;
568			sem_op(FSemaphore,1);
569			//writeln(ClassName,': Wait done on ',FSemaphore);
570			end;
571
572
573			{ TGlobalInterface }
574
575			function TGlobalInterface.GetMonitorCount: integer;
576			begin
577			Result := GetSemValue(cMonitorCounter)
578			end;
579
580			constructor TGlobalInterface.Create;
581			begin
582			inherited Create;
583			FSharedMemory := TSharedMemory.Create(cMonitorHookSize);
584
585			FWriteLock := TMutex.Create(cMutexSemaphore);
586
587			FDataAvailableEvent := TSingleLockGate.Create(cDataAvailableEventSemaphore,self);
588			FWriterBusyEvent := TSingleLockGate.Create(cWriterBusyEventSemaphore,self);
589			FReadReadyEvent := TMultiLockGate.Create(cReadReadyEventSemaphore,self);
590			FReadFinishedEvent := TMultiLockGate.Create(cReadFinishedEventSemaphore,self);
591
592			if FInitialiser then
593			SemInit(cMonitorCounter,0);
594			FTraceDataType := PInteger(FSharedMemory.Allocate(sizeof(Integer)));
595			FTimeStamp := PDateTime(FSharedMemory.Allocate(sizeof(TDateTime)));
596			FBufferSize := PInteger(FSharedMemory.Allocate(sizeof(Integer)));
597			FBuffer := FSharedMemory.Allocate(0); //All remaining
598			FMaxBufferSize := FSharedMemory.LastAllocationSize;
599
600			if FInitialiser then
601			begin
602			FBufferSize^ := 0;
603			FDataAvailableEvent.Lock
604			end;
605			end;
606
607			destructor TGlobalInterface.Destroy;
608			begin
609			if assigned(FWriteLock) then FWriteLock.Free;
610			if assigned(FDataAvailableEvent) then FDataAvailableEvent.Free;
611			if assigned(FWriterBusyEvent) then FWriterBusyEvent.Free;
612			if assigned(FReadReadyEvent) then FReadReadyEvent.Free;
613			if assigned(FReadFinishedEvent) then FReadFinishedEvent.Free;
614			if assigned(FSharedMemory) then FSharedMemory.Free;
615			inherited Destroy;
616			end;
617
618			procedure TGlobalInterface.IncMonitorCount;
619			begin
620			sem_op(cMonitorCounter,1);
621			end;
622
623			procedure TGlobalInterface.DecMonitorCount;
624			begin
625			sem_op(cMonitorCounter,-1,IPC_NOWAIT);
626			end;
627
628			procedure TGlobalInterface.SendTrace(TraceObject: TTraceObject);
629			begin
630			FTraceDataType^ := Integer(TraceObject.FDataType);
631			FTimeStamp^ := TraceObject.FTimeStamp;
632			FBufferSize^ := Min(Length(TraceObject.FMsg), MaxBufferSize);
633			Move(TraceObject.FMsg[1], FBuffer^, FBufferSize^);
634			end;
635
636			procedure TGlobalInterface.ReceiveTrace(TraceObject: TTraceObject);
637			begin
638			SetString(TraceObject.FMsg, FBuffer, FBufferSize^);
639			TraceObject.FDataType := TTraceFlag(FTraceDataType^);
640			TraceObject.FTimeStamp := TDateTime(FTimeStamp^);
641			end;
642
643
644