elf/loadtest.c

   1 #include <assert.h>
   2 #include <dlfcn.h>
   3 #include <errno.h>
   4 #include <error.h>
   5 #include <mcheck.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8
   9
  10 /* How many load/unload operations do we do.  */
  11 #define TEST_ROUNDS     1000
  12
  13
  14 static struct
  15 {
  16   /* Name of the module.  */
  17   const char *name;
  18   /* The handle.  */
  19   void *handle;
  20 } testobjs[] =
  21 {
  22   { "testobj1.so", NULL },
  23   { "testobj2.so", NULL },
  24   { "testobj3.so", NULL },
  25   { "testobj4.so", NULL },
  26   { "testobj5.so", NULL },
  27   { "testobj6.so", NULL },
  28 };
  29 #define NOBJS   (sizeof (testobjs) / sizeof (testobjs[0]))
  30
  31
  32 static const struct
  33 {
  34   /* Name of a function to call.  */
  35   const char *fname;
  36   /* Index in status and handle array.  */
  37   int index;
  38   /* Options while loading the module.  */
  39   int options;
  40 } tests[] =
  41 {
  42   { "obj1func2", 0, RTLD_LAZY },
  43   { "obj1func1", 0, RTLD_LAZY | RTLD_GLOBAL },
  44   { "obj1func1", 0, RTLD_NOW, },
  45   { "obj1func2", 0, RTLD_NOW | RTLD_GLOBAL },
  46   { "obj2func2", 1, RTLD_LAZY },
  47   { "obj2func1", 1, RTLD_LAZY | RTLD_GLOBAL, },
  48   { "obj2func1", 1, RTLD_NOW, },
  49   { "obj2func2", 1, RTLD_NOW | RTLD_GLOBAL },
  50   { "obj3func2", 2, RTLD_LAZY },
  51   { "obj3func1", 2, RTLD_LAZY | RTLD_GLOBAL },
  52   { "obj3func1", 2, RTLD_NOW },
  53   { "obj3func2", 2, RTLD_NOW | RTLD_GLOBAL },
  54   { "obj4func2", 3, RTLD_LAZY },
  55   { "obj4func1", 3, RTLD_LAZY | RTLD_GLOBAL },
  56   { "obj4func1", 3, RTLD_NOW },
  57   { "obj4func2", 3, RTLD_NOW | RTLD_GLOBAL },
  58   { "obj5func2", 4, RTLD_LAZY },
  59   { "obj5func1", 4, RTLD_LAZY | RTLD_GLOBAL },
  60   { "obj5func1", 4, RTLD_NOW },
  61   { "obj5func2", 4, RTLD_NOW | RTLD_GLOBAL },
  62   { "obj6func2", 5, RTLD_LAZY },
  63   { "obj6func1", 5, RTLD_LAZY | RTLD_GLOBAL },
  64   { "obj6func1", 5, RTLD_NOW },
  65   { "obj6func2", 5, RTLD_NOW | RTLD_GLOBAL },
  66 };
  67 #define NTESTS  (sizeof (tests) / sizeof (tests[0]))
  68
  69
  70 #include <include/link.h>
  71
  72 #define OUT \
  73   for (map = _r_debug.r_map; map != NULL; map = map->l_next)                  \
  74     if (map->l_type == lt_loaded)                                             \
  75       printf ("name = \"%s\", opencount = %d\n",                              \
  76               map->l_name, (int) map->l_opencount);                           \
  77   fflush (stdout)
  78
  79
  80 int
  81 main (int argc, char *argv[])
  82 {
  83   int debug = argc > 1 && argv[1][0] != '\0';
  84   int count = TEST_ROUNDS;
  85   int result = 0;
  86   struct link_map *map;
  87
  88   mtrace ();
  89
  90   /* Just a seed.  */
  91   srandom (TEST_ROUNDS);
  92
  93   if (debug)
  94     {
  95       puts ("in the beginning");
  96       OUT;
  97     }
  98
  99   while (count--)
 100     {
 101       int nr = random () % NTESTS;
 102       int index = tests[nr].index;
 103
 104       printf ("%4d: %4d: ", count + 1, nr);
 105       fflush (stdout);
 106
 107       if (testobjs[index].handle == NULL)
 108         {
 109           int (*fct) (int);
 110
 111           /* Load the object.  */
 112           testobjs[index].handle = dlopen (testobjs[index].name,
 113                                            tests[nr].options);
 114           if (testobjs[index].handle == NULL)
 115             error (EXIT_FAILURE, 0, "cannot load `%s': %s",
 116                    testobjs[index].name, dlerror ());
 117
 118           /* Test the function call.  */
 119           fct = dlsym (testobjs[index].handle, tests[nr].fname);
 120           if (fct == NULL)
 121             error (EXIT_FAILURE, 0,
 122                    "cannot get function `%s' from shared object `%s': %s",
 123                    tests[nr].fname, testobjs[index].name, dlerror ());
 124
 125           fct (10);
 126
 127           printf ("successfully loaded `%s', handle %p\n",
 128                   testobjs[index].name, testobjs[index].handle);
 129         }
 130       else
 131         {
 132           if (dlclose (testobjs[index].handle) != 0)
 133             {
 134               printf ("failed to close %s\n", testobjs[index].name);
 135               result = 1;
 136             }
 137           else
 138             printf ("successfully unloaded `%s', handle %p\n",
 139                     testobjs[index].name, testobjs[index].handle);
 140
 141           testobjs[index].handle = NULL;
 142         }
 143
 144       if (debug)
 145         OUT;
 146     }
 147
 148   /* Unload all loaded modules.  */
 149   for (count = 0; count < (int) NOBJS; ++count)
 150     if (testobjs[count].handle != NULL)
 151       {
 152         printf ("\nclose: %s: l_initfini = %p, l_versions = %p\n",
 153                 testobjs[count].name,
 154                 ((struct link_map*)testobjs[count].handle)->l_initfini,
 155                 ((struct link_map*)testobjs[count].handle)->l_versions);
 156
 157         if (dlclose (testobjs[count].handle) != 0)
 158           {
 159             printf ("failed to close %s\n", testobjs[count].name);
 160             result = 1;
 161           }
 162       }
 163
 164   /* Check whether all files are unloaded.  */
 165   for (map = _r_debug.r_map; map != NULL; map = map->l_next)
 166     if (map->l_type == lt_loaded)
 167       {
 168         printf ("name = \"%s\", opencount = %d\n",
 169                 map->l_name, (int) map->l_opencount);
 170         result = 1;
 171       }
 172
 173   return result;
 174 }
 175
 176
 177 extern int foo (int a);
 178 int
 179 foo (int a)
 180 {
 181   return a - 1;
 182 }