Simple AVR interrupts in C - How to cleanly stop and restart "INT0"?

Question

I'm trying to use an ATTiny84's INT0 pin to detect a falling edge event on a 1 kHz signal.

What is the correct way to temporarily halt this interrupt INT0, and then resuming it at a later time, without skewing its response time?

I'm having difficulty halting the interrupt, performing a time-consuming operation, and then resuming the interrupt. Afterwards the interrupt's response seems to have drifted very badly from its original position.

I've been using cli() to stop it, and sei() to restart it, but this seems not to work reliably. Is there a better way?

If I do not perform any halt and restart of the interrupt, then the ISR performs solidly and in lock-step with the 1 kHz signal flawlessly. If I do halt, pause for a while and resume the interrupt it seems to "remember" that it needs to call the ISR at an unpredictable moment and loses sync with the 1 kHz signal and never regains sync.

Answer 1

As is typical, I managed to stumble on a solution about an hour after I posted the question!

Here's a severely truncated code example. This is not a complete program so please don't expect it to do anything useful.

(Thank you @Lundin for some useful further improvements to my naive code...)

//Code sample for an Atmel ATTiny84A (DIP package) microcontroller

void Init_Interrupt_Handler()
{
  //the "INT0" interrupt is used... 

  MCUCR |= 0b00000010; //generate interrupts on falling edge of physical pin 5 (PB2)
  GIMSK |= 0b01000000; //enable INT0 interrupt
}

volatile unsigned char triggered = 0;
ISR(INT0_vect)
{
  //this ISR is called when a falling edge is detected on physical pin 5 (PB2)

  triggered = 1; //a signal to tell the while(1) loop in main to do something
}

void SlowFunction()
{
  //something that takes a long time...
}

int main(void)
{
  Init_Interrupt_Handler();

  sei(); //enable global interrupts

  while(1)
  { 
    if(triggered)
    {
      //turn off the INT0 interrupt until we've finished reading the data
      GIMSK &= ~0b01000000;

      triggered = 0; //this must be cleared when the interrupt is NOT enabled

      SlowFunction();

      //purge interrupt flag so that we don't get a spurious interrupt immediately
      GIFR |= (1 << INTF0);

      //reenable the INT0 interrupt in readiness for the next round
      GIMSK |= 0b01000000;
    }
  }
}

So the solution is to write a 1 into the INTFO bit of the GIFR register immediately before re-enabling the INT0 ISR.

Indeed, now I can have SlowFunction() take as long as it needs, and afterwards I can resume responding to the falling edges seamlessly and with no timing jitter of any kind.

Thanks to those that replied in the comments above.