From 9a7565403758f65c07fe3705e966381d9cfd35b6 Mon Sep 17 00:00:00 2001 From: Adhemerval Zanella Date: Mon, 18 Jan 2021 15:18:13 -0300 Subject: posix: Consolidate fork implementation The Linux nptl implementation is used as base for generic fork implementation to handle the internal locks and mutexes. The system specific bits are moved a new internal _Fork symbol. (This new implementation will be used to provide a async-signal-safe _Fork now that POSIX has clarified that fork might not be async-signal-safe [1]). For Hurd it means that the __nss_database_fork_prepare_parent and __nss_database_fork_subprocess will be run in a slight different order. [1] https://austingroupbugs.net/view.php?id=62 --- posix/Makefile | 3 +- posix/_Fork.c | 34 +++++++++++++++++ posix/fork.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++------- 3 files changed, 139 insertions(+), 14 deletions(-) create mode 100644 posix/_Fork.c (limited to 'posix') diff --git a/posix/Makefile b/posix/Makefile index 8d139e5..3bd7d60 100644 --- a/posix/Makefile +++ b/posix/Makefile @@ -39,7 +39,7 @@ routines := \ times \ wait waitpid wait3 wait4 waitid \ alarm sleep pause nanosleep \ - fork vfork _exit register-atfork \ + fork _Fork vfork _exit register-atfork \ execve fexecve execv execle execl execvp execlp execvpe \ getpid getppid \ getuid geteuid getgid getegid getgroups setuid setgid group_member \ @@ -266,6 +266,7 @@ CFLAGS-execl.os = -fomit-frame-pointer CFLAGS-execvp.os = -fomit-frame-pointer CFLAGS-execlp.os = -fomit-frame-pointer CFLAGS-nanosleep.c += -fexceptions -fasynchronous-unwind-tables +CFLAGS-fork.c = $(libio-mtsafe) tstgetopt-ARGS = -a -b -cfoobar --required foobar --optional=bazbug \ --none random --col --color --colour diff --git a/posix/_Fork.c b/posix/_Fork.c new file mode 100644 index 0000000..4a998c0 --- /dev/null +++ b/posix/_Fork.c @@ -0,0 +1,34 @@ +/* _Fork implementation. Generic version. + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include + +/* Clone the calling process, creating an exact copy. Return -1 for errors, + 0 to the new process, and the process ID of the new process to the + old process. + Different than fork, this functions is marked as async-signal-safe by + POSIX (by Austin Group issue 62). */ +pid_t +_Fork (void) +{ + __set_errno (ENOSYS); + return -1; +} +libc_hidden_def (_Fork) +stub_warning (_Fork) diff --git a/posix/fork.c b/posix/fork.c index 05bda04..44caf8d 100644 --- a/posix/fork.c +++ b/posix/fork.c @@ -1,4 +1,5 @@ -/* Copyright (C) 1991-2021 Free Software Foundation, Inc. +/* fork - create a child process. + Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or @@ -15,20 +16,109 @@ License along with the GNU C Library; if not, see . */ -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +static void +fresetlockfiles (void) +{ + _IO_ITER i; + + for (i = _IO_iter_begin(); i != _IO_iter_end(); i = _IO_iter_next(i)) + if ((_IO_iter_file (i)->_flags & _IO_USER_LOCK) == 0) + _IO_lock_init (*((_IO_lock_t *) _IO_iter_file(i)->_lock)); +} -/* Clone the calling process, creating an exact copy. - Return -1 for errors, 0 to the new process, - and the process ID of the new process to the old process. */ -int -__fork (void) +pid_t +__libc_fork (void) { - __set_errno (ENOSYS); - return -1; + /* Determine if we are running multiple threads. We skip some fork + handlers in the single-thread case, to make fork safer to use in + signal handlers. */ + bool multiple_threads = __libc_single_threaded == 0; + + __run_fork_handlers (atfork_run_prepare, multiple_threads); + + struct nss_database_data nss_database_data; + + /* If we are not running multiple threads, we do not have to + preserve lock state. If fork runs from a signal handler, only + async-signal-safe functions can be used in the child. These data + structures are only used by unsafe functions, so their state does + not matter if fork was called from a signal handler. */ + if (multiple_threads) + { + call_function_static_weak (__nss_database_fork_prepare_parent, + &nss_database_data); + + _IO_list_lock (); + + /* Acquire malloc locks. This needs to come last because fork + handlers may use malloc, and the libio list lock has an + indirect malloc dependency as well (via the getdelim + function). */ + call_function_static_weak (__malloc_fork_lock_parent); + } + + pid_t pid = _Fork (); + + if (pid == 0) + { + fork_system_setup (); + + /* Reset the lock state in the multi-threaded case. */ + if (multiple_threads) + { + __libc_unwind_link_after_fork (); + + fork_system_setup_after_fork (); + + /* Release malloc locks. */ + call_function_static_weak (__malloc_fork_unlock_child); + + /* Reset the file list. These are recursive mutexes. */ + fresetlockfiles (); + + /* Reset locks in the I/O code. */ + _IO_list_resetlock (); + + call_function_static_weak (__nss_database_fork_subprocess, + &nss_database_data); + } + + /* Reset the lock the dynamic loader uses to protect its data. */ + __rtld_lock_initialize (GL(dl_load_lock)); + + reclaim_stacks (); + + /* Run the handlers registered for the child. */ + __run_fork_handlers (atfork_run_child, multiple_threads); + } + else + { + /* Release acquired locks in the multi-threaded case. */ + if (multiple_threads) + { + /* Release malloc locks, parent process variant. */ + call_function_static_weak (__malloc_fork_unlock_parent); + + /* We execute this even if the 'fork' call failed. */ + _IO_list_unlock (); + } + + /* Run the handlers registered for the parent. */ + __run_fork_handlers (atfork_run_parent, multiple_threads); + } + + return pid; } +weak_alias (__libc_fork, __fork) libc_hidden_def (__fork) -stub_warning (fork) - -weak_alias (__fork, fork) +weak_alias (__libc_fork, fork) -- cgit v1.1