common/cleanup.c

/*
 * Copyright (c) 2000-2001 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdlib.h>
#include <assert.h>

#include "cleanup.h"

struct cu {
	void ( * cu_funcp )( void *arg1, void *arg2 );
	void *cu_arg1;
	void *cu_arg2;
	int  cu_flags;
	struct cu *cu_nextp;
};

/* Cleanup structure flags
 */
#define CU_EARLY	0x00000001
			/* call cleanup routine before calling killall */

typedef struct cu cu_t;

static cu_t *cu_rootp;

void
cleanup_init( void )
{
	cu_rootp = 0;
}

static cleanup_t *
cleanup_register_base( void ( * funcp )( void *arg1, void *arg2 ),
		  void *arg1,
		  void *arg2 )
{
	cu_t *p;

	p = ( cu_t * )calloc( 1, sizeof( cu_t ));
	assert( p );
	p->cu_funcp = funcp;
	p->cu_arg1 = arg1;
	p->cu_arg2 = arg2;
	p->cu_flags = 0;
	p->cu_nextp = cu_rootp;
	cu_rootp = p;

	return ( cleanup_t *)p;
}

cleanup_t *
cleanup_register( void ( * funcp )( void *arg1, void *arg2 ),
		  void *arg1,
		  void *arg2 )
{
	cu_t *p;

	p = cleanup_register_base( funcp, arg1, arg2 );

	return ( cleanup_t *)p;
}

cleanup_t *
cleanup_register_early( void ( * funcp )( void *arg1, void *arg2 ),
		  void *arg1,
		  void *arg2 )
{
	cu_t *p;

	p = cleanup_register_base( funcp, arg1, arg2 );
	p->cu_flags = CU_EARLY;

	return ( cleanup_t *)p;
}

void
cleanup_cancel( cleanup_t *cleanupp )
{
	cu_t *p = ( cu_t *)cleanupp;
	cu_t *nextp;
	cu_t *prevp;

	assert( cu_rootp );

	for ( prevp = 0, nextp = cu_rootp
	      ;
	      nextp && nextp != p
	      ;
	      prevp = nextp, nextp = nextp->cu_nextp )
	;

	assert( nextp );
	if ( prevp ) {
		prevp->cu_nextp = p->cu_nextp;
	} else {
		cu_rootp = p->cu_nextp;
	}
	free( ( void * )p );
}

void
cleanup( void )
{
	while ( cu_rootp ) {
		cu_t *p = cu_rootp;
		( * p->cu_funcp )( p->cu_arg1, p->cu_arg2 );
		cu_rootp = p->cu_nextp;
		free( ( void * )p );
	}
}

void
cleanup_early( void )
{
	cu_t *cuptr, *cuprevp;

	cuptr = cu_rootp;
	cuprevp = NULL;

	while ( cuptr ) {
		cu_t *cunextp = cuptr->cu_nextp;

		if ( cuptr->cu_flags & CU_EARLY) {
			( * cuptr->cu_funcp )( cuptr->cu_arg1, cuptr->cu_arg2 );
			free( ( void * )cuptr );
			if ( cuprevp )  {
				cuprevp->cu_nextp = cunextp;
			} else {
				cu_rootp = cunextp;
			}
			cuptr = cunextp;
		} else {
			cuprevp = cuptr;
			cuptr = cunextp;
		}
	}
}