bfd/cache.c

   1 /* BFD library -- caching of file descriptors.
   2
   3    Copyright (C) 1990-2018 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 = _bfd_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   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 241     abort ();
 242
 243   if (abfd->my_archive != NULL
 244       && !bfd_is_thin_archive (abfd->my_archive))
 245     abort ();
 246
 247   if (abfd->iostream != NULL)
 248     {
 249       /* Move the file to the start of the cache.  */
 250       if (abfd != bfd_last_cache)
 251         {
 252           snip (abfd);
 253           insert (abfd);
 254         }
 255       return (FILE *) abfd->iostream;
 256     }
 257
 258   if (flag & CACHE_NO_OPEN)
 259     return NULL;
 260
 261   if (bfd_open_file (abfd) == NULL)
 262     ;
 263   else if (!(flag & CACHE_NO_SEEK)
 264            && _bfd_real_fseek ((FILE *) abfd->iostream,
 265                                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 %pB: %s\n"),
 273                       abfd, 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 _bfd_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 _bfd_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 (FILE *f, void *buf, file_ptr nbytes)
 304 {
 305   file_ptr nread;
 306
 307 #if defined (__VAX) && defined (VMS)
 308   /* Apparently fread on Vax VMS does not keep the record length
 309      information.  */
 310   nread = read (fileno (f), buf, nbytes);
 311   /* Set bfd_error if we did not read as much data as we expected.  If
 312      the read failed due to an error set the bfd_error_system_call,
 313      else set bfd_error_file_truncated.  */
 314   if (nread == (file_ptr)-1)
 315     {
 316       bfd_set_error (bfd_error_system_call);
 317       return nread;
 318     }
 319 #else
 320   nread = fread (buf, 1, nbytes, f);
 321   /* Set bfd_error if we did not read as much data as we expected.  If
 322      the read failed due to an error set the bfd_error_system_call,
 323      else set bfd_error_file_truncated.  */
 324   if (nread < nbytes && ferror (f))
 325     {
 326       bfd_set_error (bfd_error_system_call);
 327       return nread;
 328     }
 329 #endif
 330   if (nread < nbytes)
 331     /* This may or may not be an error, but in case the calling code
 332        bails out because of it, set the right error code.  */
 333     bfd_set_error (bfd_error_file_truncated);
 334   return nread;
 335 }
 336
 337 static file_ptr
 338 cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 339 {
 340   file_ptr nread = 0;
 341   FILE *f;
 342
 343   f = bfd_cache_lookup (abfd, CACHE_NORMAL);
 344   if (f == NULL)
 345     return -1;
 346
 347   /* Some filesystems are unable to handle reads that are too large
 348      (for instance, NetApp shares with oplocks turned off).  To avoid
 349      hitting this limitation, we read the buffer in chunks of 8MB max.  */
 350   while (nread < nbytes)
 351     {
 352       const file_ptr max_chunk_size = 0x800000;
 353       file_ptr chunk_size = nbytes - nread;
 354       file_ptr chunk_nread;
 355
 356       if (chunk_size > max_chunk_size)
 357         chunk_size = max_chunk_size;
 358
 359       chunk_nread = cache_bread_1 (f, (char *) buf + nread, chunk_size);
 360
 361       /* Update the nread count.
 362
 363          We just have to be careful of the case when cache_bread_1 returns
 364          a negative count:  If this is our first read, then set nread to
 365          that negative count in order to return that negative value to the
 366          caller.  Otherwise, don't add it to our total count, or we would
 367          end up returning a smaller number of bytes read than we actually
 368          did.  */
 369       if (nread == 0 || chunk_nread > 0)
 370         nread += chunk_nread;
 371
 372       if (chunk_nread < chunk_size)
 373         break;
 374     }
 375
 376   return nread;
 377 }
 378
 379 static file_ptr
 380 cache_bwrite (struct bfd *abfd, const void *from, file_ptr nbytes)
 381 {
 382   file_ptr nwrite;
 383   FILE *f = bfd_cache_lookup (abfd, CACHE_NORMAL);
 384
 385   if (f == NULL)
 386     return 0;
 387   nwrite = fwrite (from, 1, nbytes, f);
 388   if (nwrite < nbytes && ferror (f))
 389     {
 390       bfd_set_error (bfd_error_system_call);
 391       return -1;
 392     }
 393   return nwrite;
 394 }
 395
 396 static int
 397 cache_bclose (struct bfd *abfd)
 398 {
 399   return bfd_cache_close (abfd) - 1;
 400 }
 401
 402 static int
 403 cache_bflush (struct bfd *abfd)
 404 {
 405   int sts;
 406   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 407
 408   if (f == NULL)
 409     return 0;
 410   sts = fflush (f);
 411   if (sts < 0)
 412     bfd_set_error (bfd_error_system_call);
 413   return sts;
 414 }
 415
 416 static int
 417 cache_bstat (struct bfd *abfd, struct stat *sb)
 418 {
 419   int sts;
 420   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 421
 422   if (f == NULL)
 423     return -1;
 424   sts = fstat (fileno (f), sb);
 425   if (sts < 0)
 426     bfd_set_error (bfd_error_system_call);
 427   return sts;
 428 }
 429
 430 static void *
 431 cache_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 432              void *addr ATTRIBUTE_UNUSED,
 433              bfd_size_type len ATTRIBUTE_UNUSED,
 434              int prot ATTRIBUTE_UNUSED,
 435              int flags ATTRIBUTE_UNUSED,
 436              file_ptr offset ATTRIBUTE_UNUSED,
 437              void **map_addr ATTRIBUTE_UNUSED,
 438              bfd_size_type *map_len ATTRIBUTE_UNUSED)
 439 {
 440   void *ret = (void *) -1;
 441
 442   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 443     abort ();
 444 #ifdef HAVE_MMAP
 445   else
 446     {
 447       static uintptr_t pagesize_m1;
 448       FILE *f;
 449       file_ptr pg_offset;
 450       bfd_size_type pg_len;
 451
 452       f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 453       if (f == NULL)
 454         return ret;
 455
 456       if (pagesize_m1 == 0)
 457         pagesize_m1 = getpagesize () - 1;
 458
 459       /* Align.  */
 460       pg_offset = offset & ~pagesize_m1;
 461       pg_len = (len + (offset - pg_offset) + pagesize_m1) & ~pagesize_m1;
 462
 463       ret = mmap (addr, pg_len, prot, flags, fileno (f), pg_offset);
 464       if (ret == (void *) -1)
 465         bfd_set_error (bfd_error_system_call);
 466       else
 467         {
 468           *map_addr = ret;
 469           *map_len = pg_len;
 470           ret = (char *) ret + (offset & pagesize_m1);
 471         }
 472     }
 473 #endif
 474
 475   return ret;
 476 }
 477
 478 static const struct bfd_iovec cache_iovec =
 479 {
 480   &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
 481   &cache_bclose, &cache_bflush, &cache_bstat, &cache_bmmap
 482 };
 483
 484 /*
 485 INTERNAL_FUNCTION
 486         bfd_cache_init
 487
 488 SYNOPSIS
 489         bfd_boolean bfd_cache_init (bfd *abfd);
 490
 491 DESCRIPTION
 492         Add a newly opened BFD to the cache.
 493 */
 494
 495 bfd_boolean
 496 bfd_cache_init (bfd *abfd)
 497 {
 498   BFD_ASSERT (abfd->iostream != NULL);
 499   if (open_files >= bfd_cache_max_open ())
 500     {
 501       if (! close_one ())
 502         return FALSE;
 503     }
 504   abfd->iovec = &cache_iovec;
 505   insert (abfd);
 506   ++open_files;
 507   return TRUE;
 508 }
 509
 510 /*
 511 INTERNAL_FUNCTION
 512         bfd_cache_close
 513
 514 SYNOPSIS
 515         bfd_boolean bfd_cache_close (bfd *abfd);
 516
 517 DESCRIPTION
 518         Remove the BFD @var{abfd} from the cache. If the attached file is open,
 519         then close it too.
 520
 521 RETURNS
 522         <<FALSE>> is returned if closing the file fails, <<TRUE>> is
 523         returned if all is well.
 524 */
 525
 526 bfd_boolean
 527 bfd_cache_close (bfd *abfd)
 528 {
 529   if (abfd->iovec != &cache_iovec)
 530     return TRUE;
 531
 532   if (abfd->iostream == NULL)
 533     /* Previously closed.  */
 534     return TRUE;
 535
 536   return bfd_cache_delete (abfd);
 537 }
 538
 539 /*
 540 FUNCTION
 541         bfd_cache_close_all
 542
 543 SYNOPSIS
 544         bfd_boolean bfd_cache_close_all (void);
 545
 546 DESCRIPTION
 547         Remove all BFDs from the cache. If the attached file is open,
 548         then close it too.
 549
 550 RETURNS
 551         <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
 552         returned if all is well.
 553 */
 554
 555 bfd_boolean
 556 bfd_cache_close_all (void)
 557 {
 558   bfd_boolean ret = TRUE;
 559
 560   while (bfd_last_cache != NULL)
 561     ret &= bfd_cache_close (bfd_last_cache);
 562
 563   return ret;
 564 }
 565
 566 /*
 567 INTERNAL_FUNCTION
 568         bfd_open_file
 569
 570 SYNOPSIS
 571         FILE* bfd_open_file (bfd *abfd);
 572
 573 DESCRIPTION
 574         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
 575         (possibly <<NULL>>) that results from this operation.  Set up the
 576         BFD so that future accesses know the file is open. If the <<FILE *>>
 577         returned is <<NULL>>, then it won't have been put in the
 578         cache, so it won't have to be removed from it.
 579 */
 580
 581 FILE *
 582 bfd_open_file (bfd *abfd)
 583 {
 584   abfd->cacheable = TRUE;       /* Allow it to be closed later.  */
 585
 586   if (open_files >= bfd_cache_max_open ())
 587     {
 588       if (! close_one ())
 589         return NULL;
 590     }
 591
 592   switch (abfd->direction)
 593     {
 594     case read_direction:
 595     case no_direction:
 596       abfd->iostream = _bfd_real_fopen (abfd->filename, FOPEN_RB);
 597       break;
 598     case both_direction:
 599     case write_direction:
 600       if (abfd->opened_once)
 601         {
 602           abfd->iostream = _bfd_real_fopen (abfd->filename, FOPEN_RUB);
 603           if (abfd->iostream == NULL)
 604             abfd->iostream = _bfd_real_fopen (abfd->filename, FOPEN_WUB);
 605         }
 606       else
 607         {
 608           /* Create the file.
 609
 610              Some operating systems won't let us overwrite a running
 611              binary.  For them, we want to unlink the file first.
 612
 613              However, gcc 2.95 will create temporary files using
 614              O_EXCL and tight permissions to prevent other users from
 615              substituting other .o files during the compilation.  gcc
 616              will then tell the assembler to use the newly created
 617              file as an output file.  If we unlink the file here, we
 618              open a brief window when another user could still
 619              substitute a file.
 620
 621              So we unlink the output file if and only if it has
 622              non-zero size.  */
 623 #ifndef __MSDOS__
 624           /* Don't do this for MSDOS: it doesn't care about overwriting
 625              a running binary, but if this file is already open by
 626              another BFD, we will be in deep trouble if we delete an
 627              open file.  In fact, objdump does just that if invoked with
 628              the --info option.  */
 629           struct stat s;
 630
 631           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
 632             unlink_if_ordinary (abfd->filename);
 633 #endif
 634           abfd->iostream = _bfd_real_fopen (abfd->filename, FOPEN_WUB);
 635           abfd->opened_once = TRUE;
 636         }
 637       break;
 638     }
 639
 640   if (abfd->iostream == NULL)
 641     bfd_set_error (bfd_error_system_call);
 642   else
 643     {
 644       if (! bfd_cache_init (abfd))
 645         return NULL;
 646     }
 647
 648   return (FILE *) abfd->iostream;
 649 }