static void clear_pool(struct pool_rec *p) {
/* Sanity check. */
if (p == NULL) {
return;
}
pr_alarms_block();
/* Run through any cleanups. */
run_cleanups(p->cleanups);
p->cleanups = NULL;
/* Destroy subpools. */
while (p->sub_pools) {
destroy_pool(p->sub_pools);
}
p->sub_pools = NULL;
free_blocks(p->first->h.next, p->tag);
p->first->h.next = NULL;
p->last = p->first;
p->first->h.first_avail = p->free_first_avail;
pr_alarms_unblock();
}
EP_API_EXPORT(void) ep_clear_pool(struct tMemPool *a)
{
ep_block_alarms();
ep_acquire_mutex(alloc_mutex);
while (a->sub_pools)
ep_destroy_pool(a->sub_pools);
ep_release_mutex(alloc_mutex);
/* Don't hold the mutex during cleanups. */
run_cleanups(a->cleanups);
a->cleanups = NULL;
free_proc_chain(a->subprocesses);
a->subprocesses = NULL;
free_blocks(a->first->h.next);
a->first->h.next = NULL;
a->last = a->first;
a->first->h.first_avail = a->free_first_avail;
debug_fill(a->first->h.first_avail,
a->first->h.endp - a->first->h.first_avail);
#ifdef ALLOC_USE_MALLOC
{
void *c, *n;
for (c = a->allocation_list; c; c = n) {
n = *(void **)c;
free(c);
}
a->allocation_list = NULL;
}
#endif
ep_unblock_alarms();
}
/**
* Unwind the current error context by running its registered cleanups.
*/
void
pop_error_context(int flagset)
{
struct error_context *tecp;
tecp= econtext;
econtext= tecp->next;
/* If we are cleaning up normally, do not print anything. */
if (flagset & ehflag_normaltidy)
set_error_printer(tecp, NULL, NULL);
run_cleanups(tecp,flagset);
free(tecp);
}
static void
run_cleanups(struct error_context *econ, int flagsetin)
{
static volatile int preventrecurse= 0;
struct cleanup_entry *volatile cep;
struct cleanup_entry *ncep;
struct error_context recurserr, *oldecontext;
jmp_buf recurse_jump;
volatile int i, flagset;
if (econ->printer.func)
econ->printer.func(econ->errmsg, econ->printer.data);
if (++preventrecurse > 3) {
onerr_abort++;
print_cleanup_error(_("too many nested errors during error recovery"), NULL);
flagset= 0;
} else {
flagset= flagsetin;
}
cep= econ->cleanups;
oldecontext= econtext;
while (cep) {
for (i=0; i<NCALLS; i++) {
if (cep->calls[i].call && cep->calls[i].mask & flagset) {
if (setjmp(recurse_jump)) {
run_cleanups(&recurserr, ehflag_bombout | ehflag_recursiveerror);
} else {
recurserr.cleanups= NULL;
recurserr.next= NULL;
set_error_printer(&recurserr, print_cleanup_error, NULL);
set_jump_handler(&recurserr, &recurse_jump);
econtext= &recurserr;
cep->calls[i].call(cep->argc,cep->argv);
}
econtext= oldecontext;
}
}
flagset &= cep->cpmask;
flagset |= cep->cpvalue;
ncep= cep->next;
if (cep != &emergency.ce) free(cep);
cep= ncep;
}
preventrecurse--;
}
