elf/dl-catch.c

   1 /* Exception handling in the dynamic linker.
   2    Copyright (C) 1995-2024 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     {
 130       if (objname == NULL)
 131         objname = "";
 132       fatal_error (errcode, objname, occasion, errstring);
 133     }
 134 }
 135 rtld_hidden_def (_dl_signal_error)
 136
 137 #if IS_IN (rtld)
 138 /* This points to a function which is called when a continuable error is
 139    received.  Unlike the handling of `catch' this function may return.
 140    The arguments will be the `errstring' and `objname'.
 141
 142    Since this functionality is not used in normal programs (only in ld.so)
 143    we do not care about multi-threaded programs here.  We keep this as a
 144    global variable.  */
 145 static receiver_fct receiver;
 146
 147 void
 148 _dl_signal_cexception (int errcode, struct dl_exception *exception,
 149                        const char *occasion)
 150 {
 151   if (__builtin_expect (GLRO(dl_debug_mask)
 152                         & ~(DL_DEBUG_STATISTICS), 0))
 153     _dl_debug_printf ("%s: error: %s: %s (%s)\n",
 154                       exception->objname, occasion,
 155                       exception->errstring, receiver ? "continued" : "fatal");
 156
 157   if (receiver)
 158     {
 159       /* We are inside _dl_receive_error.  Call the user supplied
 160          handler and resume the work.  The receiver will still be
 161          installed.  */
 162       (*receiver) (errcode, exception->objname, exception->errstring);
 163     }
 164   else
 165     _dl_signal_exception (errcode, exception, occasion);
 166 }
 167
 168 void
 169 _dl_signal_cerror (int errcode, const char *objname, const char *occasion,
 170                    const char *errstring)
 171 {
 172   if (__builtin_expect (GLRO(dl_debug_mask)
 173                         & ~(DL_DEBUG_STATISTICS), 0))
 174     _dl_debug_printf ("%s: error: %s: %s (%s)\n", objname, occasion,
 175                       errstring, receiver ? "continued" : "fatal");
 176
 177   if (receiver)
 178     {
 179       /* We are inside _dl_receive_error.  Call the user supplied
 180          handler and resume the work.  The receiver will still be
 181          installed.  */
 182       (*receiver) (errcode, objname, errstring);
 183     }
 184   else
 185     _dl_signal_error (errcode, objname, occasion, errstring);
 186 }
 187
 188 void
 189 _dl_receive_error (receiver_fct fct, void (*operate) (void *), void *args)
 190 {
 191   struct rtld_catch *old_catch = get_catch ();
 192   receiver_fct old_receiver = receiver;
 193
 194   /* Set the new values.  */
 195   set_catch (NULL);
 196   receiver = fct;
 197
 198   (*operate) (args);
 199
 200   set_catch (old_catch);
 201   receiver = old_receiver;
 202 }
 203 #endif
 204
 205 int
 206 _dl_catch_exception (struct dl_exception *exception,
 207                      void (*operate) (void *), void *args)
 208 {
 209   /* If exception is NULL, temporarily disable exception handling.
 210      Exceptions during operate (args) are fatal.  */
 211   if (exception == NULL)
 212     {
 213       struct rtld_catch *old_catch = get_catch ();
 214       set_catch (NULL);
 215       operate (args);
 216       /* If we get here, the operation was successful.  */
 217       set_catch (old_catch);
 218       return 0;
 219     }
 220
 221   /* We need not handle `receiver' since setting a `catch' is handled
 222      before it.  */
 223
 224   /* Only this needs to be marked volatile, because it is the only local
 225      variable that gets changed between the setjmp invocation and the
 226      longjmp call.  All others are just set here (before setjmp) and read
 227      in _dl_signal_error (before longjmp).  */
 228   volatile int errcode;
 229
 230   struct rtld_catch c;
 231   /* Don't use an initializer since we don't need to clear C.env.  */
 232   c.exception = exception;
 233   c.errcode = &errcode;
 234
 235   struct rtld_catch *old = get_catch ();
 236   set_catch (&c);
 237
 238   /* Do not save the signal mask.  */
 239   if (__builtin_expect (__sigsetjmp (c.env, 0), 0) == 0)
 240     {
 241       (*operate) (args);
 242       set_catch (old);
 243       *exception = (struct dl_exception) { NULL };
 244       return 0;
 245     }
 246
 247   /* We get here only if we longjmp'd out of OPERATE.
 248      _dl_signal_exception has already stored values into
 249      *EXCEPTION.  */
 250   set_catch (old);
 251   return errcode;
 252 }
 253 rtld_hidden_def (_dl_catch_exception)
 254
 255 int
 256 _dl_catch_error (const char **objname, const char **errstring,
 257                  bool *mallocedp, void (*operate) (void *), void *args)
 258 {
 259   struct dl_exception exception;
 260   int errorcode = _dl_catch_exception (&exception, operate, args);
 261   *objname = exception.objname;
 262   *errstring = exception.errstring;
 263   *mallocedp = exception.message_buffer == exception.errstring;
 264   return errorcode;
 265 }