stdlib/tst-tls-atexit.c

   1 /* Verify that DSO is unloaded only if its TLS objects are destroyed.
   2    Copyright (C) 2013-2017 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    <http://www.gnu.org/licenses/>.  */
  18
  19 /* For the default case, i.e. NO_DELETE not defined, the test dynamically loads
  20    a DSO and spawns a thread that subsequently calls into the DSO to register a
  21    destructor for an object in the DSO and then calls dlclose on the handle for
  22    the DSO.  When the thread exits, the DSO should not be unloaded or else the
  23    destructor called during thread exit will crash.  Further in the main
  24    thread, the DSO is opened and closed again, at which point the DSO should be
  25    unloaded.
  26
  27    When NO_DELETE is defined, the DSO is loaded twice, once with just RTLD_LAZY
  28    flag and the second time with the RTLD_NODELETE flag set.  The thread is
  29    spawned, destructor registered and then thread exits without closing the
  30    DSO.  In the main thread, the first handle is then closed, followed by the
  31    second handle.  In the end, the DSO should remain loaded due to the
  32    RTLD_NODELETE flag being set in the second dlopen call.  */
  33
  34 #include <dlfcn.h>
  35 #include <pthread.h>
  36 #include <stdio.h>
  37 #include <unistd.h>
  38 #include <string.h>
  39 #include <errno.h>
  40 #include <link.h>
  41 #include <stdbool.h>
  42
  43 #ifndef NO_DELETE
  44 # define LOADED_IS_GOOD false
  45 #endif
  46
  47 #ifndef H2_RTLD_FLAGS
  48 # define H2_RTLD_FLAGS (RTLD_LAZY)
  49 #endif
  50
  51 #define DSO_NAME "$ORIGIN/tst-tls-atexit-lib.so"
  52
  53 /* Walk through the map in the _r_debug structure to see if our lib is still
  54    loaded.  */
  55 static bool
  56 is_loaded (void)
  57 {
  58   struct link_map *lm = (struct link_map *) _r_debug.r_map;
  59
  60   for (; lm; lm = lm->l_next)
  61     if (lm->l_type == lt_loaded && lm->l_name
  62         && strcmp (basename (DSO_NAME), basename (lm->l_name)) == 0)
  63       {
  64         printf ("%s is still loaded\n", lm->l_name);
  65         return true;
  66       }
  67   return false;
  68 }
  69
  70 /* Accept a valid handle returned by DLOPEN, load the reg_dtor symbol to
  71    register a destructor and then call dlclose on the handle.  The dlclose
  72    should not unload the DSO since the destructor has not been called yet.  */
  73 static void *
  74 reg_dtor_and_close (void *h)
  75 {
  76   void (*reg_dtor) (void) = (void (*) (void)) dlsym (h, "reg_dtor");
  77
  78   if (reg_dtor == NULL)
  79     {
  80       printf ("Unable to find symbol: %s\n", dlerror ());
  81       return (void *) (uintptr_t) 1;
  82     }
  83
  84   reg_dtor ();
  85
  86 #ifndef NO_DELETE
  87   dlclose (h);
  88 #endif
  89
  90   return NULL;
  91 }
  92
  93 static int
  94 spawn_thread (void *h)
  95 {
  96   pthread_t t;
  97   int ret;
  98   void *thr_ret;
  99
 100   if ((ret = pthread_create (&t, NULL, reg_dtor_and_close, h)) != 0)
 101     {
 102       printf ("pthread_create failed: %s\n", strerror (ret));
 103       return 1;
 104     }
 105
 106   if ((ret = pthread_join (t, &thr_ret)) != 0)
 107     {
 108       printf ("pthread_join failed: %s\n", strerror (ret));
 109       return 1;
 110     }
 111
 112   if (thr_ret != NULL)
 113     return 1;
 114
 115   return 0;
 116 }
 117
 118 static int
 119 do_test (void)
 120 {
 121   /* Load the DSO.  */
 122   void *h1 = dlopen (DSO_NAME, RTLD_LAZY);
 123   if (h1 == NULL)
 124     {
 125       printf ("h1: Unable to load DSO: %s\n", dlerror ());
 126       return 1;
 127     }
 128
 129 #ifndef NO_DELETE
 130   if (spawn_thread (h1) != 0)
 131     return 1;
 132 #endif
 133
 134   void *h2 = dlopen (DSO_NAME, H2_RTLD_FLAGS);
 135   if (h2 == NULL)
 136     {
 137       printf ("h2: Unable to load DSO: %s\n", dlerror ());
 138       return 1;
 139     }
 140
 141 #ifdef NO_DELETE
 142   if (spawn_thread (h1) != 0)
 143     return 1;
 144
 145   dlclose (h1);
 146 #endif
 147   dlclose (h2);
 148
 149   /* Check link maps to ensure that the DSO has unloaded.  In the normal case,
 150      the DSO should be unloaded if there are no uses.  However, if one of the
 151      dlopen calls were with RTLD_NODELETE, the DSO should remain loaded.  */
 152   return is_loaded () == LOADED_IS_GOOD ? 0 : 1;
 153 }
 154
 155 #define TEST_FUNCTION do_test ()
 156 #include "../test-skeleton.c"