void wait_for_event(struct state *state)
{
s64 event_usecs =
script_time_to_live_time_usecs(
state, state->event->time_usecs);
DEBUGP("waiting until %lld -- now is %lld\n",
event_usecs, now_usecs());
while (1) {
const s64 wait_usecs = event_usecs - now_usecs();
if (wait_usecs <= 0)
break;
/* If we're waiting a long time, and we are on an OS
* that we know has a fine-grained usleep(), then
* usleep() instead of spinning on the CPU.
*/
#ifdef linux
/* Since the scheduler may not wake us up precisely
* when we tell it to, sleep until just before the
* event we're waiting for and then spin.
*/
if (wait_usecs > MAX_SPIN_USECS) {
run_unlock(state);
usleep(wait_usecs - MAX_SPIN_USECS);
run_lock(state);
}
#endif
/* At this point we should only have a millisecond or
* two to wait, so we spin.
*/
}
check_event_time(state, now_usecs());
}
void state_free(struct state *state)
{
/* We have to stop the system call thread first, since it's using
* sockets that we want to close and reset.
*/
syscalls_free(state, state->syscalls);
/* Then we close the sockets and reset the connections, while
* we still have a netdev for injecting reset packets to free
* per-connection kernel state.
*/
close_all_sockets(state);
netdev_free(state->netdev);
packets_free(state->packets);
code_free(state->code);
run_unlock(state);
if (pthread_mutex_destroy(&state->mutex) != 0)
die_perror("pthread_mutex_destroy");
memset(state, 0, sizeof(*state)); /* paranoia to help catch bugs */
free(state);
}
