bfd/cache.c

   1 /* BFD library -- caching of file descriptors.
   2
   3    Copyright (C) 1990-2017 Free Software Foundation, Inc.
   4
   5    Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 /*
  25 SECTION
  26         File caching
  27
  28         The file caching mechanism is embedded within BFD and allows
  29         the application to open as many BFDs as it wants without
  30         regard to the underlying operating system's file descriptor
  31         limit (often as low as 20 open files).  The module in
  32         <<cache.c>> maintains a least recently used list of
  33         <<bfd_cache_max_open>> files, and exports the name
  34         <<bfd_cache_lookup>>, which runs around and makes sure that
  35         the required BFD is open. If not, then it chooses a file to
  36         close, closes it and opens the one wanted, returning its file
  37         handle.
  38
  39 SUBSECTION
  40         Caching functions
  41 */
  42
  43 #include "sysdep.h"
  44 #include "bfd.h"
  45 #include "libbfd.h"
  46 #include "libiberty.h"
  47 #include "bfd_stdint.h"
  48
  49 #ifdef HAVE_MMAP
  50 #include <sys/mman.h>
  51 #endif
  52
  53 /* In some cases we can optimize cache operation when reopening files.
  54    For instance, a flush is entirely unnecessary if the file is already
  55    closed, so a flush would use CACHE_NO_OPEN.  Similarly, a seek using
  56    SEEK_SET or SEEK_END need not first seek to the current position.
  57    For stat we ignore seek errors, just in case the file has changed
  58    while we weren't looking.  If it has, then it's possible that the
  59    file is shorter and we don't want a seek error to prevent us doing
  60    the stat.  */
  61 enum cache_flag {
  62   CACHE_NORMAL = 0,
  63   CACHE_NO_OPEN = 1,
  64   CACHE_NO_SEEK = 2,
  65   CACHE_NO_SEEK_ERROR = 4
  66 };
  67
  68 /* The maximum number of files which the cache will keep open at
  69    one time.  When needed call bfd_cache_max_open to initialize.  */
  70
  71 static int max_open_files = 0;
  72
  73 /* Set max_open_files, if not already set, to 12.5% of the allowed open
  74    file descriptors, but at least 10, and return the value.  */
  75 static int
  76 bfd_cache_max_open (void)
  77 {
  78   if (max_open_files == 0)
  79     {
  80       int max;
  81 #if defined(__sun) && !defined(__sparcv9) && !defined(__x86_64__)
  82       /* PR ld/19260: 32-bit Solaris has very inelegant handling of the 255
  83          file descriptor limit.  The problem is that setrlimit(2) can raise
  84          RLIMIT_NOFILE to a value that is not supported by libc, resulting
  85          in "Too many open files" errors.  This can happen here even though
  86          max_open_files is set to rlim.rlim_cur / 8.  For example, if
  87          a parent process has set rlim.rlim_cur to 65536, then max_open_files
  88          will be computed as 8192.
  89
  90          This check essentially reverts to the behavior from binutils 2.23.1
  91          for 32-bit Solaris only.  (It is hoped that the 32-bit libc
  92          limitation will be removed soon).  64-bit Solaris libc does not have
  93          this limitation.  */
  94       max = 16;
  95 #else
  96 #ifdef HAVE_GETRLIMIT
  97       struct rlimit rlim;
  98
  99       if (getrlimit (RLIMIT_NOFILE, &rlim) == 0
 100           && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
 101         max = rlim.rlim_cur / 8;
 102       else
 103 #endif
 104 #ifdef _SC_OPEN_MAX
 105         max = sysconf (_SC_OPEN_MAX) / 8;
 106 #else
 107         max = 10;
 108 #endif
 109 #endif /* not 32-bit Solaris */
 110
 111       max_open_files = max < 10 ? 10 : max;
 112     }
 113
 114   return max_open_files;
 115 }
 116
 117 /* The number of BFD files we have open.  */
 118
 119 static int open_files;
 120
 121 /* Zero, or a pointer to the topmost BFD on the chain.  This is
 122    used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
 123    determine when it can avoid a function call.  */
 124
 125 static bfd *bfd_last_cache = NULL;
 126
 127 /* Insert a BFD into the cache.  */
 128
 129 static void
 130 insert (bfd *abfd)
 131 {
 132   if (bfd_last_cache == NULL)
 133     {
 134       abfd->lru_next = abfd;
 135       abfd->lru_prev = abfd;
 136     }
 137   else
 138     {
 139       abfd->lru_next = bfd_last_cache;
 140       abfd->lru_prev = bfd_last_cache->lru_prev;
 141       abfd->lru_prev->lru_next = abfd;
 142       abfd->lru_next->lru_prev = abfd;
 143     }
 144   bfd_last_cache = abfd;
 145 }
 146
 147 /* Remove a BFD from the cache.  */
 148
 149 static void
 150 snip (bfd *abfd)
 151 {
 152   abfd->lru_prev->lru_next = abfd->lru_next;
 153   abfd->lru_next->lru_prev = abfd->lru_prev;
 154   if (abfd == bfd_last_cache)
 155     {
 156       bfd_last_cache = abfd->lru_next;
 157       if (abfd == bfd_last_cache)
 158         bfd_last_cache = NULL;
 159     }
 160 }
 161
 162 /* Close a BFD and remove it from the cache.  */
 163
 164 static bfd_boolean
 165 bfd_cache_delete (bfd *abfd)
 166 {
 167   bfd_boolean ret;
 168
 169   if (fclose ((FILE *) abfd->iostream) == 0)
 170     ret = TRUE;
 171   else
 172     {
 173       ret = FALSE;
 174       bfd_set_error (bfd_error_system_call);
 175     }
 176
 177   snip (abfd);
 178
 179   abfd->iostream = NULL;
 180   --open_files;
 181
 182   return ret;
 183 }
 184
 185 /* We need to open a new file, and the cache is full.  Find the least
 186    recently used cacheable BFD and close it.  */
 187
 188 static bfd_boolean
 189 close_one (void)
 190 {
 191   register bfd *to_kill;
 192
 193   if (bfd_last_cache == NULL)
 194     to_kill = NULL;
 195   else
 196     {
 197       for (to_kill = bfd_last_cache->lru_prev;
 198            ! to_kill->cacheable;
 199            to_kill = to_kill->lru_prev)
 200         {
 201           if (to_kill == bfd_last_cache)
 202             {
 203               to_kill = NULL;
 204               break;
 205             }
 206         }
 207     }
 208
 209   if (to_kill == NULL)
 210     {
 211       /* There are no open cacheable BFD's.  */
 212       return TRUE;
 213     }
 214
 215   to_kill->where = real_ftell ((FILE *) to_kill->iostream);
 216
 217   return bfd_cache_delete (to_kill);
 218 }
 219
 220 /* Check to see if the required BFD is the same as the last one
 221    looked up. If so, then it can use the stream in the BFD with
 222    impunity, since it can't have changed since the last lookup;
 223    otherwise, it has to perform the complicated lookup function.  */
 224
 225 #define bfd_cache_lookup(x, flag) \
 226   ((x) == bfd_last_cache                        \
 227    ? (FILE *) (bfd_last_cache->iostream)        \
 228    : bfd_cache_lookup_worker (x, flag))
 229
 230 /* Called when the macro <<bfd_cache_lookup>> fails to find a
 231    quick answer.  Find a file descriptor for @var{abfd}.  If
 232    necessary, it open it.  If there are already more than
 233    <<bfd_cache_max_open>> files open, it tries to close one first, to
 234    avoid running out of file descriptors.  It will return NULL
 235    if it is unable to (re)open the @var{abfd}.  */
 236
 237 static FILE *
 238 bfd_cache_lookup_worker (bfd *abfd, enum cache_flag flag)
 239 {
 240   bfd *orig_bfd = abfd;
 241   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 242     abort ();
 243
 244   while (abfd->my_archive != NULL
 245          && !bfd_is_thin_archive (abfd->my_archive))
 246     abfd = abfd->my_archive;
 247
 248   if (abfd->iostream != NULL)
 249     {
 250       /* Move the file to the start of the cache.  */
 251       if (abfd != bfd_last_cache)
 252         {
 253           snip (abfd);
 254           insert (abfd);
 255         }
 256       return (FILE *) abfd->iostream;
 257     }
 258
 259   if (flag & CACHE_NO_OPEN)
 260     return NULL;
 261
 262   if (bfd_open_file (abfd) == NULL)
 263     ;
 264   else if (!(flag & CACHE_NO_SEEK)
 265            && real_fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0
 266            && !(flag & CACHE_NO_SEEK_ERROR))
 267     bfd_set_error (bfd_error_system_call);
 268   else
 269     return (FILE *) abfd->iostream;
 270
 271   /* xgettext:c-format */
 272   _bfd_error_handler (_("reopening %B: %s\n"),
 273                       orig_bfd, bfd_errmsg (bfd_get_error ()));
 274   return NULL;
 275 }
 276
 277 static file_ptr
 278 cache_btell (struct bfd *abfd)
 279 {
 280   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 281   if (f == NULL)
 282     return abfd->where;
 283   return real_ftell (f);
 284 }
 285
 286 static int
 287 cache_bseek (struct bfd *abfd, file_ptr offset, int whence)
 288 {
 289   FILE *f = bfd_cache_lookup (abfd, whence != SEEK_CUR ? CACHE_NO_SEEK : CACHE_NORMAL);
 290   if (f == NULL)
 291     return -1;
 292   return real_fseek (f, offset, whence);
 293 }
 294
 295 /* Note that archive entries don't have streams; they share their parent's.
 296    This allows someone to play with the iostream behind BFD's back.
 297
 298    Also, note that the origin pointer points to the beginning of a file's
 299    contents (0 for non-archive elements).  For archive entries this is the
 300    first octet in the file, NOT the beginning of the archive header.  */
 301
 302 static file_ptr
 303 cache_bread_1 (struct bfd *abfd, void *buf, file_ptr nbytes)
 304 {
 305   FILE *f;
 306   file_ptr nread;
 307   /* FIXME - this looks like an optimization, but it's really to cover
 308      up for a feature of some OSs (not solaris - sigh) that
 309      ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
 310      internally and tries to link against them.  BFD seems to be smart
 311      enough to realize there are no symbol records in the "file" that
 312      doesn't exist but attempts to read them anyway.  On Solaris,
 313      attempting to read zero bytes from a NULL file results in a core
 314      dump, but on other platforms it just returns zero bytes read.
 315      This makes it to something reasonable. - DJ */
 316   if (nbytes == 0)
 317     return 0;
 318
 319   f = bfd_cache_lookup (abfd, CACHE_NORMAL);
 320   if (f == NULL)
 321     return 0;
 322
 323 #if defined (__VAX) && defined (VMS)
 324   /* Apparently fread on Vax VMS does not keep the record length
 325      information.  */
 326   nread = read (fileno (f), buf, nbytes);
 327   /* Set bfd_error if we did not read as much data as we expected.  If
 328      the read failed due to an error set the bfd_error_system_call,
 329      else set bfd_error_file_truncated.  */
 330   if (nread == (file_ptr)-1)
 331     {
 332       bfd_set_error (bfd_error_system_call);
 333       return nread;
 334     }
 335 #else
 336   nread = fread (buf, 1, nbytes, f);
 337   /* Set bfd_error if we did not read as much data as we expected.  If
 338      the read failed due to an error set the bfd_error_system_call,
 339      else set bfd_error_file_truncated.  */
 340   if (nread < nbytes && ferror (f))
 341     {
 342       bfd_set_error (bfd_error_system_call);
 343       return nread;
 344     }
 345 #endif
 346   if (nread < nbytes)
 347     /* This may or may not be an error, but in case the calling code
 348        bails out because of it, set the right error code.  */
 349     bfd_set_error (bfd_error_file_truncated);
 350   return nread;
 351 }
 352
 353 static file_ptr
 354 cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 355 {
 356   file_ptr nread = 0;
 357
 358   /* Some filesystems are unable to handle reads that are too large
 359      (for instance, NetApp shares with oplocks turned off).  To avoid
 360      hitting this limitation, we read the buffer in chunks of 8MB max.  */
 361   while (nread < nbytes)
 362     {
 363       const file_ptr max_chunk_size = 0x800000;
 364       file_ptr chunk_size = nbytes - nread;
 365       file_ptr chunk_nread;
 366
 367       if (chunk_size > max_chunk_size)
 368         chunk_size = max_chunk_size;
 369
 370       chunk_nread = cache_bread_1 (abfd, (char *) buf + nread, chunk_size);
 371
 372       /* Update the nread count.
 373
 374          We just have to be careful of the case when cache_bread_1 returns
 375          a negative count:  If this is our first read, then set nread to
 376          that negative count in order to return that negative value to the
 377          caller.  Otherwise, don't add it to our total count, or we would
 378          end up returning a smaller number of bytes read than we actually
 379          did.  */
 380       if (nread == 0 || chunk_nread > 0)
 381         nread += chunk_nread;
 382
 383       if (chunk_nread < chunk_size)
 384         break;
 385     }
 386
 387   return nread;
 388 }
 389
 390 static file_ptr
 391 cache_bwrite (struct bfd *abfd, const void *where, file_ptr nbytes)
 392 {
 393   file_ptr nwrite;
 394   FILE *f = bfd_cache_lookup (abfd, CACHE_NORMAL);
 395
 396   if (f == NULL)
 397     return 0;
 398   nwrite = fwrite (where, 1, nbytes, f);
 399   if (nwrite < nbytes && ferror (f))
 400     {
 401       bfd_set_error (bfd_error_system_call);
 402       return -1;
 403     }
 404   return nwrite;
 405 }
 406
 407 static int
 408 cache_bclose (struct bfd *abfd)
 409 {
 410   return bfd_cache_close (abfd) - 1;
 411 }
 412
 413 static int
 414 cache_bflush (struct bfd *abfd)
 415 {
 416   int sts;
 417   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 418
 419   if (f == NULL)
 420     return 0;
 421   sts = fflush (f);
 422   if (sts < 0)
 423     bfd_set_error (bfd_error_system_call);
 424   return sts;
 425 }
 426
 427 static int
 428 cache_bstat (struct bfd *abfd, struct stat *sb)
 429 {
 430   int sts;
 431   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 432
 433   if (f == NULL)
 434     return -1;
 435   sts = fstat (fileno (f), sb);
 436   if (sts < 0)
 437     bfd_set_error (bfd_error_system_call);
 438   return sts;
 439 }
 440
 441 static void *
 442 cache_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 443              void *addr ATTRIBUTE_UNUSED,
 444              bfd_size_type len ATTRIBUTE_UNUSED,
 445              int prot ATTRIBUTE_UNUSED,
 446              int flags ATTRIBUTE_UNUSED,
 447              file_ptr offset ATTRIBUTE_UNUSED,
 448              void **map_addr ATTRIBUTE_UNUSED,
 449              bfd_size_type *map_len ATTRIBUTE_UNUSED)
 450 {
 451   void *ret = (void *) -1;
 452
 453   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 454     abort ();
 455 #ifdef HAVE_MMAP
 456   else
 457     {
 458       static uintptr_t pagesize_m1;
 459       FILE *f;
 460       file_ptr pg_offset;
 461       bfd_size_type pg_len;
 462
 463       f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 464       if (f == NULL)
 465         return ret;
 466
 467       if (pagesize_m1 == 0)
 468         pagesize_m1 = getpagesize () - 1;
 469
 470       /* Handle archive members.  */
 471       if (abfd->my_archive != NULL
 472           && !bfd_is_thin_archive (abfd->my_archive))
 473         offset += abfd->origin;
 474
 475       /* Align.  */
 476       pg_offset = offset & ~pagesize_m1;
 477       pg_len = (len + (offset - pg_offset) + pagesize_m1) & ~pagesize_m1;
 478
 479       ret = mmap (addr, pg_len, prot, flags, fileno (f), pg_offset);
 480       if (ret == (void *) -1)
 481         bfd_set_error (bfd_error_system_call);
 482       else
 483         {
 484           *map_addr = ret;
 485           *map_len = pg_len;
 486           ret = (char *) ret + (offset & pagesize_m1);
 487         }
 488     }
 489 #endif
 490
 491   return ret;
 492 }
 493
 494 static const struct bfd_iovec cache_iovec =
 495 {
 496   &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
 497   &cache_bclose, &cache_bflush, &cache_bstat, &cache_bmmap
 498 };
 499
 500 /*
 501 INTERNAL_FUNCTION
 502         bfd_cache_init
 503
 504 SYNOPSIS
 505         bfd_boolean bfd_cache_init (bfd *abfd);
 506
 507 DESCRIPTION
 508         Add a newly opened BFD to the cache.
 509 */
 510
 511 bfd_boolean
 512 bfd_cache_init (bfd *abfd)
 513 {
 514   BFD_ASSERT (abfd->iostream != NULL);
 515   if (open_files >= bfd_cache_max_open ())
 516     {
 517       if (! close_one ())
 518         return FALSE;
 519     }
 520   abfd->iovec = &cache_iovec;
 521   insert (abfd);
 522   ++open_files;
 523   return TRUE;
 524 }
 525
 526 /*
 527 INTERNAL_FUNCTION
 528         bfd_cache_close
 529
 530 SYNOPSIS
 531         bfd_boolean bfd_cache_close (bfd *abfd);
 532
 533 DESCRIPTION
 534         Remove the BFD @var{abfd} from the cache. If the attached file is open,
 535         then close it too.
 536
 537 RETURNS
 538         <<FALSE>> is returned if closing the file fails, <<TRUE>> is
 539         returned if all is well.
 540 */
 541
 542 bfd_boolean
 543 bfd_cache_close (bfd *abfd)
 544 {
 545   if (abfd->iovec != &cache_iovec)
 546     return TRUE;
 547
 548   if (abfd->iostream == NULL)
 549     /* Previously closed.  */
 550     return TRUE;
 551
 552   return bfd_cache_delete (abfd);
 553 }
 554
 555 /*
 556 FUNCTION
 557         bfd_cache_close_all
 558
 559 SYNOPSIS
 560         bfd_boolean bfd_cache_close_all (void);
 561
 562 DESCRIPTION
 563         Remove all BFDs from the cache. If the attached file is open,
 564         then close it too.
 565
 566 RETURNS
 567         <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
 568         returned if all is well.
 569 */
 570
 571 bfd_boolean
 572 bfd_cache_close_all (void)
 573 {
 574   bfd_boolean ret = TRUE;
 575
 576   while (bfd_last_cache != NULL)
 577     ret &= bfd_cache_close (bfd_last_cache);
 578
 579   return ret;
 580 }
 581
 582 /*
 583 INTERNAL_FUNCTION
 584         bfd_open_file
 585
 586 SYNOPSIS
 587         FILE* bfd_open_file (bfd *abfd);
 588
 589 DESCRIPTION
 590         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
 591         (possibly <<NULL>>) that results from this operation.  Set up the
 592         BFD so that future accesses know the file is open. If the <<FILE *>>
 593         returned is <<NULL>>, then it won't have been put in the
 594         cache, so it won't have to be removed from it.
 595 */
 596
 597 FILE *
 598 bfd_open_file (bfd *abfd)
 599 {
 600   abfd->cacheable = TRUE;       /* Allow it to be closed later.  */
 601
 602   if (open_files >= bfd_cache_max_open ())
 603     {
 604       if (! close_one ())
 605         return NULL;
 606     }
 607
 608   switch (abfd->direction)
 609     {
 610     case read_direction:
 611     case no_direction:
 612       abfd->iostream = real_fopen (abfd->filename, FOPEN_RB);
 613       break;
 614     case both_direction:
 615     case write_direction:
 616       if (abfd->opened_once)
 617         {
 618           abfd->iostream = real_fopen (abfd->filename, FOPEN_RUB);
 619           if (abfd->iostream == NULL)
 620             abfd->iostream = real_fopen (abfd->filename, FOPEN_WUB);
 621         }
 622       else
 623         {
 624           /* Create the file.
 625
 626              Some operating systems won't let us overwrite a running
 627              binary.  For them, we want to unlink the file first.
 628
 629              However, gcc 2.95 will create temporary files using
 630              O_EXCL and tight permissions to prevent other users from
 631              substituting other .o files during the compilation.  gcc
 632              will then tell the assembler to use the newly created
 633              file as an output file.  If we unlink the file here, we
 634              open a brief window when another user could still
 635              substitute a file.
 636
 637              So we unlink the output file if and only if it has
 638              non-zero size.  */
 639 #ifndef __MSDOS__
 640           /* Don't do this for MSDOS: it doesn't care about overwriting
 641              a running binary, but if this file is already open by
 642              another BFD, we will be in deep trouble if we delete an
 643              open file.  In fact, objdump does just that if invoked with
 644              the --info option.  */
 645           struct stat s;
 646
 647           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
 648             unlink_if_ordinary (abfd->filename);
 649 #endif
 650           abfd->iostream = real_fopen (abfd->filename, FOPEN_WUB);
 651           abfd->opened_once = TRUE;
 652         }
 653       break;
 654     }
 655
 656   if (abfd->iostream == NULL)
 657     bfd_set_error (bfd_error_system_call);
 658   else
 659     {
 660       if (! bfd_cache_init (abfd))
 661         return NULL;
 662     }
 663
 664   return (FILE *) abfd->iostream;
 665 }