elf/dl-catch.c

   1 /* Exception handling in the dynamic linker.
   2    Copyright (C) 1995-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 <libintl.h>
  20 #include <setjmp.h>
  21 #include <stdbool.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <ldsodefs.h>
  26 #include <stdio.h>
  27 #include <tls.h>
  28
  29 /* This structure communicates state between _dl_catch_error and
  30    _dl_signal_error.  */
  31 struct rtld_catch
  32   {
  33     struct dl_exception *exception; /* The exception data is stored there.  */
  34     volatile int *errcode;      /* Return value of _dl_signal_error.  */
  35     jmp_buf env;                /* longjmp here on error.  */
  36   };
  37
  38 /* Multiple threads at once can use the `_dl_catch_error' function.
  39    The calls can come from `_dl_map_object_deps', `_dlerror_run', or
  40    from any of the libc functionality which loads dynamic objects
  41    (NSS, iconv).  Therefore we have to be prepared to save the state
  42    in thread-local memory.  We use THREAD_GETMEM and THREAD_SETMEM
  43    instead of ELF TLS because ELF TLS is not available in the dynamic
  44    loader.  Additionally, the exception handling mechanism must be
  45    usable before the TCB has been set up, which is why
  46    rtld_catch_notls is used if !__rtld_tls_init_tp_called.  This is
  47    not needed for static builds, where initialization completes before
  48    static dlopen etc. can be called.  */
  49
  50 #if IS_IN (rtld)
  51 static struct rtld_catch *rtld_catch_notls;
  52 #endif
  53
  54 static struct rtld_catch *
  55 get_catch (void)
  56 {
  57 #if IS_IN (rtld)
  58   if (!__rtld_tls_init_tp_called)
  59     return rtld_catch_notls;
  60   else
  61 #endif
  62     return THREAD_GETMEM (THREAD_SELF, rtld_catch);
  63 }
  64
  65 static void
  66 set_catch (struct rtld_catch *catch)
  67 {
  68 #if IS_IN (rtld)
  69   if (!__rtld_tls_init_tp_called)
  70     rtld_catch_notls = catch;
  71   else
  72 #endif
  73     THREAD_SETMEM (THREAD_SELF, rtld_catch, catch);
  74 }
  75
  76 /* Lossage while resolving the program's own symbols is always fatal.  */
  77 static void
  78 __attribute__ ((noreturn))
  79 fatal_error (int errcode, const char *objname, const char *occasion,
  80              const char *errstring)
  81 {
  82   char buffer[1024];
  83   _dl_fatal_printf ("%s: %s: %s%s%s%s%s\n",
  84                     RTLD_PROGNAME,
  85                     occasion ?: N_("error while loading shared libraries"),
  86                     objname, *objname ? ": " : "",
  87                     errstring, errcode ? ": " : "",
  88                     (errcode
  89                      ? __strerror_r (errcode, buffer, sizeof buffer)
  90                      : ""));
  91 }
  92
  93 void
  94 _dl_signal_exception (int errcode, struct dl_exception *exception,
  95                       const char *occasion)
  96 {
  97   struct rtld_catch *lcatch = get_catch ();
  98   if (lcatch != NULL)
  99     {
 100       *lcatch->exception = *exception;
 101       *lcatch->errcode = errcode;
 102
 103       /* We do not restore the signal mask because none was saved.  */
 104       __longjmp (lcatch->env[0].__jmpbuf, 1);
 105     }
 106   else
 107     fatal_error (errcode, exception->objname, occasion, exception->errstring);
 108 }
 109 rtld_hidden_def (_dl_signal_exception)
 110
 111 void
 112 _dl_signal_error (int errcode, const char *objname, const char *occasion,
 113                   const char *errstring)
 114 {
 115   struct rtld_catch *lcatch = get_catch ();
 116
 117   if (! errstring)
 118     errstring = N_("DYNAMIC LINKER BUG!!!");
 119
 120   if (lcatch != NULL)
 121     {
 122       _dl_exception_create (lcatch->exception, objname, errstring);
 123       *lcatch->errcode = errcode;
 124
 125       /* We do not restore the signal mask because none was saved.  */
 126       __longjmp (lcatch->env[0].__jmpbuf, 1);
 127     }
 128   else
 129     fatal_error (errcode, objname, occasion, errstring);
 130 }
 131 rtld_hidden_def (_dl_signal_error)
 132
 133 #if IS_IN (rtld)
 134 /* This points to a function which is called when a continuable error is
 135    received.  Unlike the handling of `catch' this function may return.
 136    The arguments will be the `errstring' and `objname'.
 137
 138    Since this functionality is not used in normal programs (only in ld.so)
 139    we do not care about multi-threaded programs here.  We keep this as a
 140    global variable.  */
 141 static receiver_fct receiver;
 142
 143 void
 144 _dl_signal_cexception (int errcode, struct dl_exception *exception,
 145                        const char *occasion)
 146 {
 147   if (__builtin_expect (GLRO(dl_debug_mask)
 148                         & ~(DL_DEBUG_STATISTICS), 0))
 149     _dl_debug_printf ("%s: error: %s: %s (%s)\n",
 150                       exception->objname, occasion,
 151                       exception->errstring, receiver ? "continued" : "fatal");
 152
 153   if (receiver)
 154     {
 155       /* We are inside _dl_receive_error.  Call the user supplied
 156          handler and resume the work.  The receiver will still be
 157          installed.  */
 158       (*receiver) (errcode, exception->objname, exception->errstring);
 159     }
 160   else
 161     _dl_signal_exception (errcode, exception, occasion);
 162 }
 163
 164 void
 165 _dl_signal_cerror (int errcode, const char *objname, const char *occasion,
 166                    const char *errstring)
 167 {
 168   if (__builtin_expect (GLRO(dl_debug_mask)
 169                         & ~(DL_DEBUG_STATISTICS), 0))
 170     _dl_debug_printf ("%s: error: %s: %s (%s)\n", objname, occasion,
 171                       errstring, receiver ? "continued" : "fatal");
 172
 173   if (receiver)
 174     {
 175       /* We are inside _dl_receive_error.  Call the user supplied
 176          handler and resume the work.  The receiver will still be
 177          installed.  */
 178       (*receiver) (errcode, objname, errstring);
 179     }
 180   else
 181     _dl_signal_error (errcode, objname, occasion, errstring);
 182 }
 183
 184 void
 185 _dl_receive_error (receiver_fct fct, void (*operate) (void *), void *args)
 186 {
 187   struct rtld_catch *old_catch = get_catch ();
 188   receiver_fct old_receiver = receiver;
 189
 190   /* Set the new values.  */
 191   set_catch (NULL);
 192   receiver = fct;
 193
 194   (*operate) (args);
 195
 196   set_catch (old_catch);
 197   receiver = old_receiver;
 198 }
 199 #endif
 200
 201 int
 202 _dl_catch_exception (struct dl_exception *exception,
 203                      void (*operate) (void *), void *args)
 204 {
 205   /* If exception is NULL, temporarily disable exception handling.
 206      Exceptions during operate (args) are fatal.  */
 207   if (exception == NULL)
 208     {
 209       struct rtld_catch *old_catch = get_catch ();
 210       set_catch (NULL);
 211       operate (args);
 212       /* If we get here, the operation was successful.  */
 213       set_catch (old_catch);
 214       return 0;
 215     }
 216
 217   /* We need not handle `receiver' since setting a `catch' is handled
 218      before it.  */
 219
 220   /* Only this needs to be marked volatile, because it is the only local
 221      variable that gets changed between the setjmp invocation and the
 222      longjmp call.  All others are just set here (before setjmp) and read
 223      in _dl_signal_error (before longjmp).  */
 224   volatile int errcode;
 225
 226   struct rtld_catch c;
 227   /* Don't use an initializer since we don't need to clear C.env.  */
 228   c.exception = exception;
 229   c.errcode = &errcode;
 230
 231   struct rtld_catch *old = get_catch ();
 232   set_catch (&c);
 233
 234   /* Do not save the signal mask.  */
 235   if (__builtin_expect (__sigsetjmp (c.env, 0), 0) == 0)
 236     {
 237       (*operate) (args);
 238       set_catch (old);
 239       *exception = (struct dl_exception) { NULL };
 240       return 0;
 241     }
 242
 243   /* We get here only if we longjmp'd out of OPERATE.
 244      _dl_signal_exception has already stored values into
 245      *EXCEPTION.  */
 246   set_catch (old);
 247   return errcode;
 248 }
 249 rtld_hidden_def (_dl_catch_exception)
 250
 251 int
 252 _dl_catch_error (const char **objname, const char **errstring,
 253                  bool *mallocedp, void (*operate) (void *), void *args)
 254 {
 255   struct dl_exception exception;
 256   int errorcode = _dl_catch_exception (&exception, operate, args);
 257   *objname = exception.objname;
 258   *errstring = exception.errstring;
 259   *mallocedp = exception.message_buffer == exception.errstring;
 260   return errorcode;
 261 }