/*
* 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);
}
}