1: /* Support for reading /etc/ld.so.cache files written by Linux ldconfig.
    2:    Copyright (C) 1996-2002, 2003, 2004, 2006 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, write to the Free
   17:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   18:    02111-1307 USA.  */
   19: 
   20: #include <assert.h>
   21: #include <unistd.h>
   22: #include <ldsodefs.h>
   23: #include <sys/mman.h>
   24: #include <dl-cache.h>
   25: #include <dl-procinfo.h>
   26: 
   27: #include <stdio-common/_itoa.h>
   28: 
   29: #ifndef _DL_PLATFORMS_COUNT
   30: # define _DL_PLATFORMS_COUNT 0
   31: #endif
   32: 
   33: /* This is the starting address and the size of the mmap()ed file.  */
   34: static struct cache_file *cache;
   35: static struct cache_file_new *cache_new;
   36: static size_t cachesize;
   37: 
   38: /* 1 if cache_data + PTR points into the cache.  */
   39: #define _dl_cache_verify_ptr(ptr) (ptr < cache_data_size)
   40: 
   41: #define SEARCH_CACHE(cache) \
   42: /* We use binary search since the table is sorted in the cache file.          \
   43:    The first matching entry in the table is returned.                         \
   44:    It is important to use the same algorithm as used while generating         \
   45:    the cache file.  */                                                        \
   46: do                                                                            \
   47:   {                                                                           \
   48:     left = 0;                                                                 \
   49:     right = cache->nlibs - 1;                                                 \
   50:                                                                               \
   51:     while (left <= right)                                                     \
   52:       {                                                                       \
   53:         __typeof__ (cache->libs[0].key) key;                                 \
   54:                                                                               \
   55:         middle = (left + right) / 2;                                         \
   56:                                                                               \
   57:         key = cache->libs[middle].key;                                       \
   58:                                                                               \
   59:         /* Make sure string table indices are not bogus before using         \
   60:            them.  */                                                         \
   61:         if (! _dl_cache_verify_ptr (key))                                    \
   62:           {                                                                  \
   63:             cmpres = 1;                                                              \
   64:             break;                                                           \
   65:           }                                                                  \
   66:                                                                               \
   67:         /* Actually compare the entry with the key.  */                              \
   68:         cmpres = _dl_cache_libcmp (name, cache_data + key);                  \
   69:         if (__builtin_expect (cmpres == 0, 0))                               \
   70:           {                                                                  \
   71:             /* Found it.  LEFT now marks the last entry for which we         \
   72:                know the name is correct.  */                                 \
   73:             left = middle;                                                   \
   74:                                                                               \
   75:             /* There might be entries with this name before the one we       \
   76:                found.  So we have to find the beginning.  */                 \
   77:             while (middle > 0)                                               \
   78:               {                                                                      \
   79:                 __typeof__ (cache->libs[0].key) key;                        \
   80:                                                                               \
   81:                 key = cache->libs[middle - 1].key;                          \
   82:                 /* Make sure string table indices are not bogus before              \
   83:                    using them.  */                                          \
   84:                 if (! _dl_cache_verify_ptr (key)                            \
   85:                     /* Actually compare the entry.  */                              \
   86:                     || _dl_cache_libcmp (name, cache_data + key) != 0)              \
   87:                   break;                                                    \
   88:                 --middle;                                                   \
   89:               }                                                                      \
   90:                                                                               \
   91:             do                                                               \
   92:               {                                                                      \
   93:                 int flags;                                                  \
   94:                 __typeof__ (cache->libs[0]) *lib = &cache->libs[middle];      \
   95:                                                                               \
   96:                 /* Only perform the name test if necessary.  */                     \
   97:                 if (middle > left                                           \
   98:                     /* We haven't seen this string so far.  Test whether the  \
   99:                        index is ok and whether the name matches.  Otherwise   \
  100:                        we are done.  */                                             \
  101:                     && (! _dl_cache_verify_ptr (lib->key)                   \
  102:                         || (_dl_cache_libcmp (name, cache_data + lib->key)    \
  103:                             != 0)))                                        \
  104:                   break;                                                    \
  105:                                                                               \
  106:                 flags = lib->flags;                                         \
  107:                 if (_dl_cache_check_flags (flags)                           \
  108:                     && _dl_cache_verify_ptr (lib->value))                   \
  109:                   {                                                         \
  110:                     if (best == NULL || flags == GLRO(dl_correct_cache_id))   \
  111:                       {                                                             \
  112:                         HWCAP_CHECK;                                       \
  113:                         best = cache_data + lib->value;                            \
  114:                                                                               \
  115:                         if (flags == GLRO(dl_correct_cache_id))                    \
  116:                           /* We've found an exact match for the shared             \
  117:                              object and no general `ELF' release.  Stop            \
  118:                              searching.  */                                \
  119:                           break;                                           \
  120:                       }                                                             \
  121:                   }                                                         \
  122:               }                                                                      \
  123:             while (++middle <= right);                                       \
  124:             break;                                                           \
  125:         }                                                                    \
  126:                                                                               \
  127:         if (cmpres < 0)                                                              \
  128:           left = middle + 1;                                                 \
  129:         else                                                                 \
  130:           right = middle - 1;                                                \
  131:       }                                                                       \
  132:   }                                                                           \
  133: while (0)
  134: 
  135: 
  136: int
  137: internal_function
  138: _dl_cache_libcmp (const char *p1, const char *p2)
  139: {
  140:   while (*p1 != '\0')
  141:     {
  142:       if (*p1 >= '0' && *p1 <= '9')
  143:         {
  144:           if (*p2 >= '0' && *p2 <= '9')
  145:             {
  146:               /* Must compare this numerically.  */
  147:               int val1;
  148:               int val2;
  149: 
  150:               val1 = *p1++ - '0';
  151:               val2 = *p2++ - '0';
  152:               while (*p1 >= '0' && *p1 <= '9')
  153:                 val1 = val1 * 10 + *p1++ - '0';
  154:               while (*p2 >= '0' && *p2 <= '9')
  155:                 val2 = val2 * 10 + *p2++ - '0';
  156:               if (val1 != val2)
  157:                 return val1 - val2;
  158:             }
  159:           else
  160:             return 1;
  161:         }
  162:       else if (*p2 >= '0' && *p2 <= '9')
  163:         return -1;
  164:       else if (*p1 != *p2)
  165:         return *p1 - *p2;
  166:       else
  167:         {
  168:           ++p1;
  169:           ++p2;
  170:         }
  171:     }
  172:   return *p1 - *p2;
  173: }
  174: 
  175: 
  176: /* Look up NAME in ld.so.cache and return the file name stored there,
  177:    or null if none is found.  */
  178: 
  179: const char *
  180: internal_function
  181: _dl_load_cache_lookup (const char *name)
  182: {
  183:   int left, right, middle;
  184:   int cmpres;
  185:   const char *cache_data;
  186:   uint32_t cache_data_size;
  187:   const char *best;
  188: 
  189:   /* Print a message if the loading of libs is traced.  */
  190:   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
  191:     _dl_debug_printf (" search cache=%s\n", LD_SO_CACHE);
  192: 
  193:   if (cache == NULL)
  194:     {
  195:       /* Read the contents of the file.  */
  196:       void *file = _dl_sysdep_read_whole_file (LD_SO_CACHE, &cachesize,
  197:                                                PROT_READ);
  198: 
  199:       /* We can handle three different cache file formats here:
  200:          - the old libc5/glibc2.0/2.1 format
  201:          - the old format with the new format in it
  202:          - only the new format
  203:          The following checks if the cache contains any of these formats.  */
  204:       if (file != MAP_FAILED && cachesize > sizeof *cache
  205:           && memcmp (file, CACHEMAGIC, sizeof CACHEMAGIC - 1) == 0)
  206:         {
  207:           size_t offset;
  208:           /* Looks ok.  */
  209:           cache = file;
  210: 
  211:           /* Check for new version.  */
  212:           offset = ALIGN_CACHE (sizeof (struct cache_file)
  213:                                 + cache->nlibs * sizeof (struct file_entry));
  214: 
  215:           cache_new = (struct cache_file_new *) ((void *) cache + offset);
  216:           if (cachesize < (offset + sizeof (struct cache_file_new))
  217:               || memcmp (cache_new->magic, CACHEMAGIC_VERSION_NEW,
  218:                          sizeof CACHEMAGIC_VERSION_NEW - 1) != 0)
  219:             cache_new = (void *) -1;
  220:         }
  221:       else if (file != MAP_FAILED && cachesize > sizeof *cache_new
  222:                && memcmp (file, CACHEMAGIC_VERSION_NEW,
  223:                           sizeof CACHEMAGIC_VERSION_NEW - 1) == 0)
  224:         {
  225:           cache_new = file;
  226:           cache = file;
  227:         }
  228:       else
  229:         {
  230:           if (file != MAP_FAILED)
  231:             __munmap (file, cachesize);
  232:           cache = (void *) -1;
  233:         }
  234: 
  235:       assert (cache != NULL);
  236:     }
  237: 
  238:   if (cache == (void *) -1)
  239:     /* Previously looked for the cache file and didn't find it.  */
  240:     return NULL;
  241: 
  242:   best = NULL;
  243: 
  244:   if (cache_new != (void *) -1)
  245:     {
  246:       uint64_t platform;
  247: 
  248:       /* This is where the strings start.  */
  249:       cache_data = (const char *) cache_new;
  250: 
  251:       /* Now we can compute how large the string table is.  */
  252:       cache_data_size = (const char *) cache + cachesize - cache_data;
  253: 
  254:       platform = _dl_string_platform (GLRO(dl_platform));
  255:       if (platform != (uint64_t) -1)
  256:         platform = 1ULL << platform;
  257: 
  258:       /* Only accept hwcap if it's for the right platform.  */
  259: #define _DL_HWCAP_TLS_MASK (1LL << 63)
  260: #define HWCAP_CHECK \
  261:       if (GLRO(dl_osversion) && lib->osversion > GLRO(dl_osversion))          \
  262:         continue;                                                            \
  263:       if (_DL_PLATFORMS_COUNT                                                 \
  264:           && (lib->hwcap & _DL_HWCAP_PLATFORM) != 0                          \
  265:           && (lib->hwcap & _DL_HWCAP_PLATFORM) != platform)                  \
  266:         continue;                                                            \
  267:       if (lib->hwcap                                                          \
  268:           & ~(GLRO(dl_hwcap) | _DL_HWCAP_PLATFORM | _DL_HWCAP_TLS_MASK))      \
  269:         continue
  270:       SEARCH_CACHE (cache_new);
  271:     }
  272:   else
  273:     {
  274:       /* This is where the strings start.  */
  275:       cache_data = (const char *) &cache->libs[cache->nlibs];
  276: 
  277:       /* Now we can compute how large the string table is.  */
  278:       cache_data_size = (const char *) cache + cachesize - cache_data;
  279: 
  280: #undef HWCAP_CHECK
  281: #define HWCAP_CHECK do {} while (0)
  282:       SEARCH_CACHE (cache);
  283:     }
  284: 
  285:   /* Print our result if wanted.  */
  286:   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0)
  287:       && best != NULL)
  288:     _dl_debug_printf ("  trying file=%s\n", best);
  289: 
  290:   return best;
  291: }
  292: 
  293: #ifndef MAP_COPY
  294: /* If the system does not support MAP_COPY we cannot leave the file open
  295:    all the time since this would create problems when the file is replaced.
  296:    Therefore we provide this function to close the file and open it again
  297:    once needed.  */
  298: void
  299: _dl_unload_cache (void)
  300: {
  301:   if (cache != NULL && cache != (struct cache_file *) -1)
  302:     {
  303:       __munmap (cache, cachesize);
  304:       cache = NULL;
  305:     }
  306: }
  307: #endif