Re: gnat/linux:setitimer

[Tilman Glotzner <Tilman.Gloetzner@etas.co.kr>]

1) How do I monitor signals with gdb ? 
I know of the "handle <signal> print" command, and the "handle <signal> 
stop" command. 
I tried to set a breakpoint with "catch signal 14", but gdb tells me, that 
this feature is not yet implemented (My version of gdb is 5.1.1). 
Are there any other ways ?

2) I tried to to export all signal related code to c, and released all 
signals  by using pragma Unreserve_All_Interrupts (see program below). The 
signal is not catched either:
Even though setitimer returns a 0 (=success), I am suspecious if the 
SIG_ALRM signal is really sent.

Or maybe  gnat's runtime library uses that signal even though it should be 
release released by pragma Unreserve_All_Interrupts



--------------------------------------------------------------
-- Filename: timer_test.adb
-- Desc: Test program for timer package
--
-- (c) 2003 Tilman Glotzner, DG2TG
--
-- History:
-- Date       Name         Descrition
-- 2003-12-08 T. Glotzner  Creation
--------------------------------------------------------------
pragma Unreserve_All_Interrupts;

with Text_Io,Ada.Interrupts,Ada.Interrupts.Names;
use Text_Io,Ada.Interrupts,Ada.Interrupts.Names;

procedure Timer_Test_A is
   Counter: Integer := 0;
   I: Integer := 20;

   procedure Settimer;
   pragma Import (C,Settimer);
begin
   New_line;
   Put_Line("Timer_Test_A");
   Put_Line("==========");

   Settimer;
   Put_Line("I := " & I'Img);
   while (Counter <=  I) loop
      null;
         Counter := Counter + 1;


         delay(0.5);
--         Put_Line("Counter = " & Counter'Img);
      end loop;

end Timer_Test_A;

// Filename: setitimer.c

#include<stdlib.h>
#include<stdio.h>
#include<signal.h>
#include<time.h>
#include<unistd.h>
#include<sys/time.h>


void sigalrm_dispatcher(int signal)
{
    printf("sigalarm dispatcher started (%d)\n",signal);
}


int settimer()
{
    int status;
    struct itimerval timer;
    /* initial interval */
    timer.it_value.tv_sec = 2;
    timer.it_value.tv_usec = 100000;
    /* subsequent intervals */
    timer.it_interval.tv_sec = 0;
    timer.it_interval.tv_usec = 500000;

    if (SIG_ERR == signal ( SIGALRM, sigalrm_dispatcher ))
    {
      printf("Installation of signal handler failed.\n");
    }
    else
    {
      printf("Installation of signal handler successful.\n");
    }


    status = setitimer( ITIMER_REAL, &timer, NULL );
    printf("settimer executed (Status=%d).\n",status);
}

Thanks,

Tilman



Mark H Johnson

Mark H Johnson wrote:

> TIlman Glotzner wrote:
>> Hello,
>> 
>> below my attempt to connect the linux system timer to an ada program.
>> 1) In the process list, I see the program distributed over 5
>> processes. Each signal handler is mapped onto one process. One
>> process is probably needed for the main program. On which part
>> of the program are the other 2 processes mapped to ?
>> 
> 
> The GNAT implementation of tasks on Linux (up until *very* recently) has
> processes for
>   - the main program
>   - a thread manager
>   - a thread per signal being managed
>   - a thread per task
> and they show up as individual processes in ps, top, etc. We ended up
> writing a small library package that would write a file in /tmp/ that
> had our "task name" so we could correlate between PID's and tasks.
> 
> When I mean "very recently", if you are using the new pthread library
> (e.g., Red Hat 9 or later), the rules have changed somewhat and I
> haven't used it enough to comment on it.
> 
>> 2) When the timer expires, the timer signal (SIGALRM) is not catched
>> by the signal handler.  The signal handlers itselves apparrently work as
>> the handlers react to signals sent by a unix kill command. As
>> process number I need to give the PID of the appropriate signal
>> handler. I suspect that the signal is sent to the process that
>> started the itimer. As the signal signal handlers  run as
>> separated processes, the SIGALRM signal issued from the itimer does not
>> reach the signal handlers. What do I need to do to make it work ?
>> 
> What we do instead is to:
>   - determine the process group
>   - use killpg instead of kill to send the signal to the process group
> In this case, the signal is delivered to all the threads and all but one
> thread will ignore it. Only the signal handler will catch it and process
> it.
> 
>> 3) Is there a unix utility that allows me to monitor signals,
>>  i.e. which program issues which signal, and which program catches it ?
>> 
> The latter part can be done with the debugger (gdb). I am not aware of
> any utility to tell you who sent the signal.
> 
>> 4) I first tried to import the system call "setitimer", and hand over
>> setitimer's parameters by access types(ITimervalPtrs'address). The
>> program also compiles if handing over the variables directly (not
>> references to the variables). Is gnat/ada doing a parameter conversion to
>> a reference implicitly for me ?
>> 
> Not sure, we have C code that actually calls setitimer in our system
> :-). You should be able to do something like...
>    pragma Interface(C, Setitimer);
> and use declarations that are compatible with C to call setitimer
> directly from Ada. We do that for a lot of other functions but just not
> that one.
> 
> You may also need
>    pragma Unreserve_All_Interrupts;
> since the run time may also be trapping the specific signals you are
> trying to use.
>    --Mark

-- 
Tilman Glotzner
ETAS Ltd, Seoul, Korea