/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "thr_uberdata.h"
#include "mtlib.h"

/*
 * fork handlers are run in LIFO order.
 * The libc fork handler is expected to be the first handler installed,
 * hence would be the last fork handler run in preparation for fork1().
 * It is essential that this be so, for other libraries depend on libc
 * and may grab their own locks before calling into libc.  By special
 * arrangement, the loader runs libc's init section (libc_init()) first.
 */

/*
 * pthread_atfork(): installs handlers to be called during fork1().
 * There is no POSIX API that provides for deletion of atfork handlers.
 * Collaboration between the loader and libc ensures that atfork
 * handlers installed by a library are deleted when that library
 * is unloaded (see _preexec_atfork_unload() in atexit.c).
 */
int
pthread_atfork(void (*prepare)(void),
	void (*parent)(void), void (*child)(void))
{
	ulwp_t *self = curthread;
	uberdata_t *udp = self->ul_uberdata;
	atfork_t *atfp;
	atfork_t *head;
	int error = 0;

	(void) mutex_lock(&udp->atfork_lock);
	if (self->ul_fork) {
		/*
		 * Cannot call pthread_atfork() from a fork handler.
		 */
		error = EDEADLK;
	} else if ((atfp = lmalloc(sizeof (atfork_t))) == NULL) {
		error = ENOMEM;
	} else {
		atfp->prepare = prepare;
		atfp->parent = parent;
		atfp->child = child;
		if ((head = udp->atforklist) == NULL) {
			udp->atforklist = atfp;
			atfp->forw = atfp->back = atfp;
		} else {
			head->back->forw = atfp;
			atfp->forw = head;
			atfp->back = head->back;
			head->back = atfp;
		}
	}

	(void) mutex_unlock(&udp->atfork_lock);
	return (error);
}

/*
 * _prefork_handler() is called by fork1() before it starts processing.
 * It executes the user installed "prepare" routines in LIFO order (POSIX)
 */
void
_prefork_handler(void)
{
	uberdata_t *udp = curthread->ul_uberdata;
	atfork_t *atfork_q;
	atfork_t *atfp;

	ASSERT(MUTEX_OWNED(&udp->atfork_lock, curthread));
	if ((atfork_q = udp->atforklist) != NULL) {
		atfp = atfork_q = atfork_q->back;
		do {
			if (atfp->prepare)
				(*atfp->prepare)();
		} while ((atfp = atfp->back) != atfork_q);
	}
}

/*
 * _postfork_parent_handler() is called by fork1() after it retuns as parent.
 * It executes the user installed "parent" routines in FIFO order (POSIX).
 */
void
_postfork_parent_handler(void)
{
	uberdata_t *udp = curthread->ul_uberdata;
	atfork_t *atfork_q;
	atfork_t *atfp;

	ASSERT(MUTEX_OWNED(&udp->atfork_lock, curthread));
	if ((atfork_q = udp->atforklist) != NULL) {
		atfp = atfork_q;
		do {
			if (atfp->parent)
				(*atfp->parent)();
		} while ((atfp = atfp->forw) != atfork_q);
	}
}

/*
 * _postfork_child_handler() is called by fork1() after it returns as child.
 * It executes the user installed "child" routines in FIFO order (POSIX).
 */
void
_postfork_child_handler(void)
{
	uberdata_t *udp = curthread->ul_uberdata;
	atfork_t *atfork_q;
	atfork_t *atfp;

	ASSERT(MUTEX_OWNED(&udp->atfork_lock, curthread));
	if ((atfork_q = udp->atforklist) != NULL) {
		atfp = atfork_q;
		do {
			if (atfp->child)
				(*atfp->child)();
		} while ((atfp = atfp->forw) != atfork_q);
	}
}