posix/register-atfork.c

   1 /* Copyright (C) 2002-2022 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <libc-lock.h>
  19 #include <stdbool.h>
  20 #include <register-atfork.h>
  21
  22 #define DYNARRAY_ELEMENT           struct fork_handler
  23 #define DYNARRAY_STRUCT            fork_handler_list
  24 #define DYNARRAY_PREFIX            fork_handler_list_
  25 #define DYNARRAY_INITIAL_SIZE      48
  26 #include <malloc/dynarray-skeleton.c>
  27
  28 static struct fork_handler_list fork_handlers;
  29 static bool fork_handler_init = false;
  30
  31 static int atfork_lock = LLL_LOCK_INITIALIZER;
  32
  33 int
  34 __register_atfork (void (*prepare) (void), void (*parent) (void),
  35                    void (*child) (void), void *dso_handle)
  36 {
  37   lll_lock (atfork_lock, LLL_PRIVATE);
  38
  39   if (!fork_handler_init)
  40     {
  41       fork_handler_list_init (&fork_handlers);
  42       fork_handler_init = true;
  43     }
  44
  45   struct fork_handler *newp = fork_handler_list_emplace (&fork_handlers);
  46   if (newp != NULL)
  47     {
  48       newp->prepare_handler = prepare;
  49       newp->parent_handler = parent;
  50       newp->child_handler = child;
  51       newp->dso_handle = dso_handle;
  52     }
  53
  54   /* Release the lock.  */
  55   lll_unlock (atfork_lock, LLL_PRIVATE);
  56
  57   return newp == NULL ? ENOMEM : 0;
  58 }
  59 libc_hidden_def (__register_atfork)
  60
  61 static struct fork_handler *
  62 fork_handler_list_find (struct fork_handler_list *fork_handlers,
  63                         void *dso_handle)
  64 {
  65   for (size_t i = 0; i < fork_handler_list_size (fork_handlers); i++)
  66     {
  67       struct fork_handler *elem = fork_handler_list_at (fork_handlers, i);
  68       if (elem->dso_handle == dso_handle)
  69         return elem;
  70     }
  71   return NULL;
  72 }
  73
  74 void
  75 __unregister_atfork (void *dso_handle)
  76 {
  77   lll_lock (atfork_lock, LLL_PRIVATE);
  78
  79   struct fork_handler *first = fork_handler_list_find (&fork_handlers,
  80                                                        dso_handle);
  81   /* Removing is done by shifting the elements in the way the elements
  82      that are not to be removed appear in the beginning in dynarray.
  83      This avoid the quadradic run-time if a naive strategy to remove and
  84      shift one element at time.  */
  85   if (first != NULL)
  86     {
  87       struct fork_handler *new_end = first;
  88       first++;
  89       for (; first != fork_handler_list_end (&fork_handlers); ++first)
  90         {
  91           if (first->dso_handle != dso_handle)
  92             {
  93               *new_end = *first;
  94               ++new_end;
  95             }
  96         }
  97
  98       ptrdiff_t removed = first - new_end;
  99       for (size_t i = 0; i < removed; i++)
 100         fork_handler_list_remove_last (&fork_handlers);
 101     }
 102
 103   lll_unlock (atfork_lock, LLL_PRIVATE);
 104 }
 105
 106 void
 107 __run_fork_handlers (enum __run_fork_handler_type who, _Bool do_locking)
 108 {
 109   struct fork_handler *runp;
 110
 111   if (who == atfork_run_prepare)
 112     {
 113       if (do_locking)
 114         lll_lock (atfork_lock, LLL_PRIVATE);
 115       size_t sl = fork_handler_list_size (&fork_handlers);
 116       for (size_t i = sl; i > 0; i--)
 117         {
 118           runp = fork_handler_list_at (&fork_handlers, i - 1);
 119           if (runp->prepare_handler != NULL)
 120             runp->prepare_handler ();
 121         }
 122     }
 123   else
 124     {
 125       size_t sl = fork_handler_list_size (&fork_handlers);
 126       for (size_t i = 0; i < sl; i++)
 127         {
 128           runp = fork_handler_list_at (&fork_handlers, i);
 129           if (who == atfork_run_child && runp->child_handler)
 130             runp->child_handler ();
 131           else if (who == atfork_run_parent && runp->parent_handler)
 132             runp->parent_handler ();
 133         }
 134       if (do_locking)
 135         lll_unlock (atfork_lock, LLL_PRIVATE);
 136     }
 137 }
 138
 139
 140 libc_freeres_fn (free_mem)
 141 {
 142   lll_lock (atfork_lock, LLL_PRIVATE);
 143
 144   fork_handler_list_free (&fork_handlers);
 145
 146   lll_unlock (atfork_lock, LLL_PRIVATE);
 147 }