| /* Linuxthreads - a simple clone()-based implementation of Posix */ |
| /* threads for Linux. */ |
| /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */ |
| /* */ |
| /* This program is free software; you can redistribute it and/or */ |
| /* modify it under the terms of the GNU Library General Public License */ |
| /* as published by the Free Software Foundation; either version 2 */ |
| /* of the License, or (at your option) any later version. */ |
| /* */ |
| /* This program is distributed in the hope that it will be useful, */ |
| /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ |
| /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ |
| /* GNU Library General Public License for more details. */ |
| |
| /* The "atfork" stuff */ |
| |
| #include <errno.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include "pthread.h" |
| #include "internals.h" |
| #include <bits/libc-lock.h> |
| |
| struct handler_list { |
| void (*handler)(void); |
| struct handler_list * next; |
| }; |
| |
| static pthread_mutex_t pthread_atfork_lock = PTHREAD_MUTEX_INITIALIZER; |
| static struct handler_list * pthread_atfork_prepare = NULL; |
| static struct handler_list * pthread_atfork_parent = NULL; |
| static struct handler_list * pthread_atfork_child = NULL; |
| |
| static void pthread_insert_list(struct handler_list ** list, |
| void (*handler)(void), |
| struct handler_list * newlist, |
| int at_end) |
| { |
| if (handler == NULL) return; |
| if (at_end) { |
| while(*list != NULL) list = &((*list)->next); |
| } |
| newlist->handler = handler; |
| newlist->next = *list; |
| *list = newlist; |
| } |
| |
| struct handler_list_block { |
| struct handler_list prepare, parent, child; |
| }; |
| |
| int __pthread_atfork(void (*prepare)(void), |
| void (*parent)(void), |
| void (*child)(void)) |
| { |
| struct handler_list_block * block = |
| (struct handler_list_block *) malloc(sizeof(struct handler_list_block)); |
| if (block == NULL) return ENOMEM; |
| pthread_mutex_lock(&pthread_atfork_lock); |
| /* "prepare" handlers are called in LIFO */ |
| pthread_insert_list(&pthread_atfork_prepare, prepare, &block->prepare, 0); |
| /* "parent" handlers are called in FIFO */ |
| pthread_insert_list(&pthread_atfork_parent, parent, &block->parent, 1); |
| /* "child" handlers are called in FIFO */ |
| pthread_insert_list(&pthread_atfork_child, child, &block->child, 1); |
| pthread_mutex_unlock(&pthread_atfork_lock); |
| return 0; |
| } |
| strong_alias (__pthread_atfork, pthread_atfork) |
| |
| static inline void pthread_call_handlers(struct handler_list * list) |
| { |
| for (/*nothing*/; list != NULL; list = list->next) (list->handler)(); |
| } |
| |
| extern int __libc_fork(void); |
| |
| pid_t __fork(void) |
| { |
| pid_t pid; |
| |
| pthread_mutex_lock(&pthread_atfork_lock); |
| |
| pthread_call_handlers(pthread_atfork_prepare); |
| __pthread_once_fork_prepare(); |
| __flockfilelist(); |
| |
| pid = __libc_fork(); |
| |
| if (pid == 0) { |
| __pthread_reset_main_thread(); |
| |
| __fresetlockfiles(); |
| __pthread_once_fork_child(); |
| pthread_call_handlers(pthread_atfork_child); |
| |
| pthread_mutex_init(&pthread_atfork_lock, NULL); |
| } else { |
| __funlockfilelist(); |
| __pthread_once_fork_parent(); |
| pthread_call_handlers(pthread_atfork_parent); |
| |
| pthread_mutex_unlock(&pthread_atfork_lock); |
| } |
| |
| return pid; |
| } |
| |
| weak_alias (__fork, fork); |
| |
| #if !defined(_ELIX_LEVEL) || _ELIX_LEVEL >= 4 |
| |
| pid_t __vfork(void) |
| { |
| return __fork(); |
| } |
| weak_alias (__vfork, vfork); |
| |
| #endif /* !_ELIX_LEVEL || _ELIX_LEVEL >= 4 */ |