1  /* fork - create a child process.
       2     Copyright (C) 1991-2023 Free Software Foundation, Inc.
       3     This file is part of the GNU C Library.
       4  
       5     The GNU C Library is free software; you can redistribute it and/or
       6     modify it under the terms of the GNU Lesser General Public
       7     License as published by the Free Software Foundation; either
       8     version 2.1 of the License, or (at your option) any later version.
       9  
      10     The GNU C Library is distributed in the hope that it will be useful,
      11     but WITHOUT ANY WARRANTY; without even the implied warranty of
      12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13     Lesser General Public License for more details.
      14  
      15     You should have received a copy of the GNU Lesser General Public
      16     License along with the GNU C Library; if not, see
      17     <https://www.gnu.org/licenses/>.  */
      18  
      19  #include <fork.h>
      20  #include <libio/libioP.h>
      21  #include <ldsodefs.h>
      22  #include <malloc/malloc-internal.h>
      23  #include <nss/nss_database.h>
      24  #include <register-atfork.h>
      25  #include <stdio-lock.h>
      26  #include <sys/single_threaded.h>
      27  #include <unwind-link.h>
      28  
      29  static void
      30  fresetlockfiles (void)
      31  {
      32    _IO_ITER i;
      33  
      34    for (i = _IO_iter_begin(); i != _IO_iter_end(); i = _IO_iter_next(i))
      35      if ((_IO_iter_file (i)->_flags & _IO_USER_LOCK) == 0)
      36        _IO_lock_init (*((_IO_lock_t *) _IO_iter_file(i)->_lock));
      37  }
      38  
      39  pid_t
      40  __libc_fork (void)
      41  {
      42    /* Determine if we are running multiple threads.  We skip some fork
      43       handlers in the single-thread case, to make fork safer to use in
      44       signal handlers.  Although POSIX has dropped async-signal-safe
      45       requirement for fork (Austin Group tracker issue #62) this is
      46       best effort to make is async-signal-safe at least for single-thread
      47       case.  */
      48    bool multiple_threads = !SINGLE_THREAD_P;
      49    uint64_t lastrun;
      50  
      51    lastrun = __run_prefork_handlers (multiple_threads);
      52  
      53    struct nss_database_data nss_database_data;
      54  
      55    /* If we are not running multiple threads, we do not have to
      56       preserve lock state.  If fork runs from a signal handler, only
      57       async-signal-safe functions can be used in the child.  These data
      58       structures are only used by unsafe functions, so their state does
      59       not matter if fork was called from a signal handler.  */
      60    if (multiple_threads)
      61      {
      62        call_function_static_weak (__nss_database_fork_prepare_parent,
      63  				 &nss_database_data);
      64  
      65        _IO_list_lock ();
      66  
      67        /* Acquire malloc locks.  This needs to come last because fork
      68  	 handlers may use malloc, and the libio list lock has an
      69  	 indirect malloc dependency as well (via the getdelim
      70  	 function).  */
      71        call_function_static_weak (__malloc_fork_lock_parent);
      72      }
      73  
      74    pid_t pid = _Fork ();
      75  
      76    if (pid == 0)
      77      {
      78        fork_system_setup ();
      79  
      80        /* Reset the lock state in the multi-threaded case.  */
      81        if (multiple_threads)
      82  	{
      83  	  __libc_unwind_link_after_fork ();
      84  
      85  	  fork_system_setup_after_fork ();
      86  
      87  	  /* Release malloc locks.  */
      88  	  call_function_static_weak (__malloc_fork_unlock_child);
      89  
      90  	  /* Reset the file list.  These are recursive mutexes.  */
      91  	  fresetlockfiles ();
      92  
      93  	  /* Reset locks in the I/O code.  */
      94  	  _IO_list_resetlock ();
      95  
      96  	  call_function_static_weak (__nss_database_fork_subprocess,
      97  				     &nss_database_data);
      98  	}
      99  
     100        /* Reset the lock the dynamic loader uses to protect its data.  */
     101        __rtld_lock_initialize (GL(dl_load_lock));
     102  
     103        /* Reset the lock protecting dynamic TLS related data.  */
     104        __rtld_lock_initialize (GL(dl_load_tls_lock));
     105  
     106        reclaim_stacks ();
     107  
     108        /* Run the handlers registered for the child.  */
     109        __run_postfork_handlers (atfork_run_child, multiple_threads, lastrun);
     110      }
     111    else
     112      {
     113        /* If _Fork failed, preserve its errno value.  */
     114        int save_errno = errno;
     115  
     116        /* Release acquired locks in the multi-threaded case.  */
     117        if (multiple_threads)
     118  	{
     119  	  /* Release malloc locks, parent process variant.  */
     120  	  call_function_static_weak (__malloc_fork_unlock_parent);
     121  
     122  	  /* We execute this even if the 'fork' call failed.  */
     123  	  _IO_list_unlock ();
     124  	}
     125  
     126        /* Run the handlers registered for the parent.  */
     127        __run_postfork_handlers (atfork_run_parent, multiple_threads, lastrun);
     128  
     129        if (pid < 0)
     130  	__set_errno (save_errno);
     131      }
     132  
     133    return pid;
     134  }
     135  weak_alias (__libc_fork, __fork)
     136  libc_hidden_def (__fork)
     137  weak_alias (__libc_fork, fork)