elf/tst-dl_find_object.c

   1 /* Basic tests for _dl_find_object.
   2    Copyright (C) 2021-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 <dl-find_object.h>
  20 #include <dlfcn.h>
  21 #include <gnu/lib-names.h>
  22 #include <ldsodefs.h>
  23 #include <link.h>
  24 #include <stdio.h>
  25 #include <support/check.h>
  26 #include <support/xdlfcn.h>
  27
  28 /* Use data objects for testing, so that it is not necessary to decode
  29    function descriptors on architectures that have them.  */
  30 static char main_program_data;
  31
  32 /* Computes the expected _dl_find_object result directly from the
  33    map.  */
  34 static void
  35 from_map (struct link_map *l, struct dl_find_object *expected)
  36 {
  37   struct dl_find_object_internal internal;
  38   _dl_find_object_from_map (l, &internal);
  39   _dl_find_object_to_external (&internal, expected);
  40 }
  41
  42 /* Compare _dl_find_object result at ADDRESS with *EXPECTED.  */
  43 static void
  44 check (void *address,
  45        struct dl_find_object *expected, int line)
  46 {
  47   struct dl_find_object actual;
  48   int ret = _dl_find_object (address, &actual);
  49   if (expected == NULL)
  50     {
  51       if (ret != -1)
  52         {
  53           support_record_failure ();
  54           printf ("%s:%d: unexpected success for %p\n",
  55                   __FILE__, line, address);
  56         }
  57       return;
  58     }
  59   if (ret != 0)
  60     {
  61       support_record_failure ();
  62       printf ("%s:%d: unexpected failure for %p\n",
  63               __FILE__, line, address);
  64       return;
  65     }
  66
  67   if (actual.dlfo_flags != expected->dlfo_flags)
  68     {
  69       support_record_failure ();
  70       printf ("%s:%d: error: %p: flags is %llu, expected %llu\n",
  71               __FILE__, line, address,
  72               actual.dlfo_flags, expected->dlfo_flags);
  73     }
  74   if (expected->dlfo_link_map->l_contiguous)
  75     {
  76       /* If the mappings are not contiguous, the actual and execpted
  77          mappings may differ, so this subtest will not work.  */
  78       if (actual.dlfo_flags != expected->dlfo_flags)
  79         {
  80           support_record_failure ();
  81           printf ("%s:%d: error: %p: map start is %p, expected %p\n",
  82                   __FILE__, line,
  83                   address, actual.dlfo_map_start, expected->dlfo_map_start);
  84         }
  85       if (actual.dlfo_map_end != expected->dlfo_map_end)
  86         {
  87           support_record_failure ();
  88           printf ("%s:%d: error: %p: map end is %p, expected %p\n",
  89                   __FILE__, line,
  90                   address, actual.dlfo_map_end, expected->dlfo_map_end);
  91         }
  92     }
  93   if (actual.dlfo_link_map != expected->dlfo_link_map)
  94     {
  95       support_record_failure ();
  96       printf ("%s:%d: error: %p: link map is %p, expected %p\n",
  97               __FILE__, line,
  98               address, actual.dlfo_link_map, expected->dlfo_link_map);
  99     }
 100   if (actual.dlfo_eh_frame != expected->dlfo_eh_frame)
 101     {
 102       support_record_failure ();
 103       printf ("%s:%d: error: %p: EH frame is %p, expected %p\n",
 104               __FILE__, line,
 105               address, actual.dlfo_eh_frame, expected->dlfo_eh_frame);
 106     }
 107 #if DLFO_STRUCT_HAS_EH_DBASE
 108   if (actual.dlfo_eh_dbase != expected->dlfo_eh_dbase)
 109     {
 110       support_record_failure ();
 111       printf ("%s:%d: error: %p: data base is %p, expected %p\n",
 112               __FILE__, line,
 113               address, actual.dlfo_eh_dbase, expected->dlfo_eh_dbase);
 114     }
 115 #endif
 116 #if DLFO_STRUCT_HAS_EH_COUNT
 117   if (actual.dlfo_eh_count != expected->dlfo_eh_count)
 118     {
 119       support_record_failure ();
 120       printf ("%s:%d: error: %p: count is %d, expected %d\n",
 121               __FILE__, line,
 122               address, actual.dlfo_eh_count, expected->dlfo_eh_count);
 123     }
 124 #endif
 125 }
 126
 127 /* Check that unwind data for the main executable and the dynamic
 128    linker can be found.  */
 129 static void
 130 check_initial (void)
 131 {
 132 #ifndef FOR_STATIC
 133   /* Avoid direct reference, which could lead to copy relocations.  */
 134   struct r_debug *debug = xdlsym (NULL, "_r_debug");
 135   TEST_VERIFY_EXIT (debug != NULL);
 136   char **tzname = xdlsym (NULL, "tzname");
 137
 138   /* The main executable has an unnamed link map.  */
 139   struct link_map *main_map = (struct link_map *) debug->r_map;
 140   TEST_COMPARE_STRING (main_map->l_name, "");
 141
 142   /* The link map of the dynamic linker.  */
 143   struct link_map *rtld_map = xdlopen (LD_SO, RTLD_LAZY | RTLD_NOLOAD);
 144   TEST_VERIFY_EXIT (rtld_map != NULL);
 145
 146   /* The link map of libc.so.  */
 147   struct link_map *libc_map = xdlopen (LIBC_SO, RTLD_LAZY | RTLD_NOLOAD);
 148   TEST_VERIFY_EXIT (libc_map != NULL);
 149
 150   struct dl_find_object expected;
 151
 152   /* Data in the main program.  */
 153   from_map (main_map, &expected);
 154   check (&main_program_data, &expected, __LINE__);
 155   /* Corner cases for the mapping.  */
 156   check ((void *) main_map->l_map_start, &expected, __LINE__);
 157   check ((void *) (main_map->l_map_end - 1), &expected, __LINE__);
 158
 159   /* Data in the dynamic loader.  */
 160   from_map (rtld_map, &expected);
 161   check (debug, &expected, __LINE__);
 162   check ((void *) rtld_map->l_map_start, &expected, __LINE__);
 163   check ((void *) (rtld_map->l_map_end - 1), &expected, __LINE__);
 164
 165   /* Data in libc.  */
 166   from_map (libc_map, &expected);
 167   check (tzname, &expected, __LINE__);
 168   check ((void *) libc_map->l_map_start, &expected, __LINE__);
 169   check ((void *) (libc_map->l_map_end - 1), &expected, __LINE__);
 170 #endif
 171 }
 172
 173 static int
 174 do_test (void)
 175 {
 176   {
 177     struct dl_find_object dlfo = { };
 178     int ret = _dl_find_object (&main_program_data, &dlfo);
 179     printf ("info: main program unwind data: %p (%d)\n",
 180             dlfo.dlfo_eh_frame, ret);
 181     TEST_COMPARE (ret, 0);
 182     TEST_VERIFY (dlfo.dlfo_eh_frame != NULL);
 183   }
 184
 185   check_initial ();
 186
 187   /* dlopen-based test.  First an object that can be dlclosed.  */
 188   struct link_map *mod1 = xdlopen ("tst-dl_find_object-mod1.so", RTLD_NOW);
 189   void *mod1_data = xdlsym (mod1, "mod1_data");
 190   void *map_start = (void *) mod1->l_map_start;
 191   void *map_end = (void *) (mod1->l_map_end - 1);
 192   check_initial ();
 193
 194   struct dl_find_object expected;
 195   from_map (mod1, &expected);
 196   check (mod1_data, &expected, __LINE__);
 197   check (map_start, &expected, __LINE__);
 198   check (map_end, &expected, __LINE__);
 199
 200   /* Unloading must make the data unavailable.  */
 201   xdlclose (mod1);
 202   check_initial ();
 203   check (mod1_data, NULL, __LINE__);
 204   check (map_start, NULL, __LINE__);
 205   check (map_end, NULL, __LINE__);
 206
 207   /* Now try a NODELETE load.  */
 208   struct link_map *mod2 = xdlopen ("tst-dl_find_object-mod2.so", RTLD_NOW);
 209   void *mod2_data = xdlsym (mod2, "mod2_data");
 210   map_start = (void *) mod2->l_map_start;
 211   map_end = (void *) (mod2->l_map_end - 1);
 212   check_initial ();
 213   from_map (mod2, &expected);
 214   check (mod2_data, &expected, __LINE__);
 215   check (map_start, &expected, __LINE__);
 216   check (map_end, &expected, __LINE__);
 217   dlclose (mod2);               /* Does nothing due to NODELETE.  */
 218   check_initial ();
 219   check (mod2_data, &expected, __LINE__);
 220   check (map_start, &expected, __LINE__);
 221   check (map_end, &expected, __LINE__);
 222
 223   /* Now load again the first module.  */
 224   mod1 = xdlopen ("tst-dl_find_object-mod1.so", RTLD_NOW);
 225   mod1_data = xdlsym (mod1, "mod1_data");
 226   map_start = (void *) mod1->l_map_start;
 227   map_end = (void *) (mod1->l_map_end - 1);
 228   check_initial ();
 229   from_map (mod1, &expected);
 230   check (mod1_data, &expected, __LINE__);
 231   check (map_start, &expected, __LINE__);
 232   check (map_end, &expected, __LINE__);
 233
 234   /* Check that _dl_find_object works from a shared object (mostly for
 235      static dlopen).  */
 236   __typeof (_dl_find_object) *find_object
 237     = *(void **) xdlsym (mod2, "find_object");
 238   struct dl_find_object actual;
 239   TEST_COMPARE (find_object (&main_program_data, &actual), 0);
 240   check (&main_program_data, &actual, __LINE__); /* Reversed check.  */
 241
 242   return 0;
 243 }
 244
 245 #include <support/test-driver.c>