Thread: POSIX Signal Handling

Hmm..alright, I'm new to this whole signal thing (as you can probably tell). Why is it bad to call library functions in handlers? The call to printf was just for debugging, to show that it was actually called, is there another simple way that I can tell it was called without resorting to printf? How do I force linkage to the floating point library?

Thanks for the quick reply m8

edit: sorry didn't see the links there, reading now, thanks

Alright, after reading that I changed the code to make it more compliant (if I understood it properly):

Code:

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int counter = 0;

void handle_zero(int sig_num){
  counter++;
}

int main(){
  float num1,num2, num3;

  num3 = 1.0/1.0;

  signal(SIGFPE,handle_zero);

  while (42){
  printf("divide: ");

  scanf("%f %f",  &num1,  &num2);

  num3 = num1/num2;

  printf("result: %f\ncount: %d\n",num3,counter);

  }

  return 0;
}

But no matter how I enter in the zeros (0.0, 0, 0.00, etc) The counter still outputs 0, when I changed the code to work with integers I think it got caught in an infinite loop (other than the purposeful one) though...if that changes anything :-/

Hmm...I've looked around in quite a few places and I think I'm stuck.. Does any one know if there is is an option that I need to do to enable it at compilation? I'm using gcc...

I will change that to volatile though, thanks m8

Originally Posted by nine-hundred

I
So that when I enter something like: 12.2 0.0 or 0 0 the signal isn't caught/triggered, however, when I changed it to read in two integers and divide them, it was caught.

I assume you are on an x86 system, Linux possibly? By default, the FPU is configured to produce the value "infinity" when you divide by zero (or "not a number" if you divide zero by zero). It does NOT trigger an exception, you do NOT get a signal.

You must reprogram the FPU to generate an exception for divide-by-zero. The way you do this is platform-dependent.

Originally Posted by nine-hundred

Hmm..alright, I'm new to this whole signal thing (as you can probably tell). Why is it bad to call library functions in handlers?

The problem is, what happens when you receive a signal while some standard library function is in the middle of executing? More specifically, what happens if you get a signal while in the middle of printf()? The C library may or may not be reentrant. It is certainly not guaranteed to be. So the effects of calling a library function from a signal handler are undefined, except for a certain class of functions which are known to be reentrant.

You get away with it in this case because the particular signal you are trapping is (usually) only produced during a floating point exception. So the chances that you are inside a library function when the signal is delivered are exceedingly small -- pretty much the only way it could happen is if somebody sent you the signal deliberately with kill().

The call to printf was just for debugging, to show that it was actually called, is there another simple way that I can tell it was called without resorting to printf?

Set a flag in the signal handler. After the line of code which does the division, check if this flag is set -- if it is, a divide by zero occurred. But this is silly -- it's far easier, and more efficient, to simply check the denominator before doing the division in the first place.

How do I force linkage to the floating point library?

Add "-lm" to the link line.

oh ok, thanks for the info...this is getting a bit complicated, I think I will have to research it some more before I can do what I want with it. Thanks again, very thorough