bfd/cache.c

   1 /* BFD library -- caching of file descriptors.
   2
   3    Copyright (C) 1990-2022 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
  48 #ifdef HAVE_MMAP
  49 #include <sys/mman.h>
  50 #endif
  51
  52 /* In some cases we can optimize cache operation when reopening files.
  53    For instance, a flush is entirely unnecessary if the file is already
  54    closed, so a flush would use CACHE_NO_OPEN.  Similarly, a seek using
  55    SEEK_SET or SEEK_END need not first seek to the current position.
  56    For stat we ignore seek errors, just in case the file has changed
  57    while we weren't looking.  If it has, then it's possible that the
  58    file is shorter and we don't want a seek error to prevent us doing
  59    the stat.  */
  60 enum cache_flag {
  61   CACHE_NORMAL = 0,
  62   CACHE_NO_OPEN = 1,
  63   CACHE_NO_SEEK = 2,
  64   CACHE_NO_SEEK_ERROR = 4
  65 };
  66
  67 /* The maximum number of files which the cache will keep open at
  68    one time.  When needed call bfd_cache_max_open to initialize.  */
  69
  70 static int max_open_files = 0;
  71
  72 /* Set max_open_files, if not already set, to 12.5% of the allowed open
  73    file descriptors, but at least 10, and return the value.  */
  74 static int
  75 bfd_cache_max_open (void)
  76 {
  77   if (max_open_files == 0)
  78     {
  79       int max;
  80 #if defined(__sun) && !defined(__sparcv9) && !defined(__x86_64__)
  81       /* PR ld/19260: 32-bit Solaris has very inelegant handling of the 255
  82          file descriptor limit.  The problem is that setrlimit(2) can raise
  83          RLIMIT_NOFILE to a value that is not supported by libc, resulting
  84          in "Too many open files" errors.  This can happen here even though
  85          max_open_files is set to rlim.rlim_cur / 8.  For example, if
  86          a parent process has set rlim.rlim_cur to 65536, then max_open_files
  87          will be computed as 8192.
  88
  89          This check essentially reverts to the behavior from binutils 2.23.1
  90          for 32-bit Solaris only.  (It is hoped that the 32-bit libc
  91          limitation will be removed soon).  64-bit Solaris libc does not have
  92          this limitation.  */
  93       max = 16;
  94 #else
  95 #ifdef HAVE_GETRLIMIT
  96       struct rlimit rlim;
  97
  98       if (getrlimit (RLIMIT_NOFILE, &rlim) == 0
  99           && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
 100         max = rlim.rlim_cur / 8;
 101       else
 102 #endif
 103 #ifdef _SC_OPEN_MAX
 104         max = sysconf (_SC_OPEN_MAX) / 8;
 105 #else
 106         max = 10;
 107 #endif
 108 #endif /* not 32-bit Solaris */
 109
 110       max_open_files = max < 10 ? 10 : max;
 111     }
 112
 113   return max_open_files;
 114 }
 115
 116 /* The number of BFD files we have open.  */
 117
 118 static int open_files;
 119
 120 /* Zero, or a pointer to the topmost BFD on the chain.  This is
 121    used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
 122    determine when it can avoid a function call.  */
 123
 124 static bfd *bfd_last_cache = NULL;
 125
 126 /* Insert a BFD into the cache.  */
 127
 128 static void
 129 insert (bfd *abfd)
 130 {
 131   if (bfd_last_cache == NULL)
 132     {
 133       abfd->lru_next = abfd;
 134       abfd->lru_prev = abfd;
 135     }
 136   else
 137     {
 138       abfd->lru_next = bfd_last_cache;
 139       abfd->lru_prev = bfd_last_cache->lru_prev;
 140       abfd->lru_prev->lru_next = abfd;
 141       abfd->lru_next->lru_prev = abfd;
 142     }
 143   bfd_last_cache = abfd;
 144 }
 145
 146 /* Remove a BFD from the cache.  */
 147
 148 static void
 149 snip (bfd *abfd)
 150 {
 151   abfd->lru_prev->lru_next = abfd->lru_next;
 152   abfd->lru_next->lru_prev = abfd->lru_prev;
 153   if (abfd == bfd_last_cache)
 154     {
 155       bfd_last_cache = abfd->lru_next;
 156       if (abfd == bfd_last_cache)
 157         bfd_last_cache = NULL;
 158     }
 159 }
 160
 161 /* Close a BFD and remove it from the cache.  */
 162
 163 static bool
 164 bfd_cache_delete (bfd *abfd)
 165 {
 166   bool ret;
 167
 168   if (fclose ((FILE *) abfd->iostream) == 0)
 169     ret = true;
 170   else
 171     {
 172       ret = false;
 173       bfd_set_error (bfd_error_system_call);
 174     }
 175
 176   snip (abfd);
 177
 178   abfd->iostream = NULL;
 179   --open_files;
 180   abfd->flags |= BFD_CLOSED_BY_CACHE;
 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 bool
 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     {
 270       abfd->flags &= ~BFD_CLOSED_BY_CACHE;
 271       return (FILE *) abfd->iostream;
 272     }
 273
 274   /* xgettext:c-format */
 275   _bfd_error_handler (_("reopening %pB: %s"),
 276                       abfd, bfd_errmsg (bfd_get_error ()));
 277   return NULL;
 278 }
 279
 280 static file_ptr
 281 cache_btell (struct bfd *abfd)
 282 {
 283   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 284   if (f == NULL)
 285     return abfd->where;
 286   return _bfd_real_ftell (f);
 287 }
 288
 289 static int
 290 cache_bseek (struct bfd *abfd, file_ptr offset, int whence)
 291 {
 292   FILE *f = bfd_cache_lookup (abfd, whence != SEEK_CUR ? CACHE_NO_SEEK : CACHE_NORMAL);
 293   if (f == NULL)
 294     return -1;
 295   return _bfd_real_fseek (f, offset, whence);
 296 }
 297
 298 /* Note that archive entries don't have streams; they share their parent's.
 299    This allows someone to play with the iostream behind BFD's back.
 300
 301    Also, note that the origin pointer points to the beginning of a file's
 302    contents (0 for non-archive elements).  For archive entries this is the
 303    first octet in the file, NOT the beginning of the archive header.  */
 304
 305 static file_ptr
 306 cache_bread_1 (FILE *f, void *buf, file_ptr nbytes)
 307 {
 308   file_ptr nread;
 309
 310 #if defined (__VAX) && defined (VMS)
 311   /* Apparently fread on Vax VMS does not keep the record length
 312      information.  */
 313   nread = read (fileno (f), buf, nbytes);
 314   /* Set bfd_error if we did not read as much data as we expected.  If
 315      the read failed due to an error set the bfd_error_system_call,
 316      else set bfd_error_file_truncated.  */
 317   if (nread == (file_ptr)-1)
 318     {
 319       bfd_set_error (bfd_error_system_call);
 320       return nread;
 321     }
 322 #else
 323   nread = fread (buf, 1, nbytes, f);
 324   /* Set bfd_error if we did not read as much data as we expected.  If
 325      the read failed due to an error set the bfd_error_system_call,
 326      else set bfd_error_file_truncated.  */
 327   if (nread < nbytes && ferror (f))
 328     {
 329       bfd_set_error (bfd_error_system_call);
 330       return nread;
 331     }
 332 #endif
 333   if (nread < nbytes)
 334     /* This may or may not be an error, but in case the calling code
 335        bails out because of it, set the right error code.  */
 336     bfd_set_error (bfd_error_file_truncated);
 337   return nread;
 338 }
 339
 340 static file_ptr
 341 cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 342 {
 343   file_ptr nread = 0;
 344   FILE *f;
 345
 346   f = bfd_cache_lookup (abfd, CACHE_NORMAL);
 347   if (f == NULL)
 348     return -1;
 349
 350   /* Some filesystems are unable to handle reads that are too large
 351      (for instance, NetApp shares with oplocks turned off).  To avoid
 352      hitting this limitation, we read the buffer in chunks of 8MB max.  */
 353   while (nread < nbytes)
 354     {
 355       const file_ptr max_chunk_size = 0x800000;
 356       file_ptr chunk_size = nbytes - nread;
 357       file_ptr chunk_nread;
 358
 359       if (chunk_size > max_chunk_size)
 360         chunk_size = max_chunk_size;
 361
 362       chunk_nread = cache_bread_1 (f, (char *) buf + nread, chunk_size);
 363
 364       /* Update the nread count.
 365
 366          We just have to be careful of the case when cache_bread_1 returns
 367          a negative count:  If this is our first read, then set nread to
 368          that negative count in order to return that negative value to the
 369          caller.  Otherwise, don't add it to our total count, or we would
 370          end up returning a smaller number of bytes read than we actually
 371          did.  */
 372       if (nread == 0 || chunk_nread > 0)
 373         nread += chunk_nread;
 374
 375       if (chunk_nread < chunk_size)
 376         break;
 377     }
 378
 379   return nread;
 380 }
 381
 382 static file_ptr
 383 cache_bwrite (struct bfd *abfd, const void *from, file_ptr nbytes)
 384 {
 385   file_ptr nwrite;
 386   FILE *f = bfd_cache_lookup (abfd, CACHE_NORMAL);
 387
 388   if (f == NULL)
 389     return 0;
 390   nwrite = fwrite (from, 1, nbytes, f);
 391   if (nwrite < nbytes && ferror (f))
 392     {
 393       bfd_set_error (bfd_error_system_call);
 394       return -1;
 395     }
 396   return nwrite;
 397 }
 398
 399 static int
 400 cache_bclose (struct bfd *abfd)
 401 {
 402   return bfd_cache_close (abfd) - 1;
 403 }
 404
 405 static int
 406 cache_bflush (struct bfd *abfd)
 407 {
 408   int sts;
 409   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 410
 411   if (f == NULL)
 412     return 0;
 413   sts = fflush (f);
 414   if (sts < 0)
 415     bfd_set_error (bfd_error_system_call);
 416   return sts;
 417 }
 418
 419 static int
 420 cache_bstat (struct bfd *abfd, struct stat *sb)
 421 {
 422   int sts;
 423   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 424
 425   if (f == NULL)
 426     return -1;
 427   sts = fstat (fileno (f), sb);
 428   if (sts < 0)
 429     bfd_set_error (bfd_error_system_call);
 430   return sts;
 431 }
 432
 433 static void *
 434 cache_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
 435              void *addr ATTRIBUTE_UNUSED,
 436              bfd_size_type len ATTRIBUTE_UNUSED,
 437              int prot ATTRIBUTE_UNUSED,
 438              int flags ATTRIBUTE_UNUSED,
 439              file_ptr offset ATTRIBUTE_UNUSED,
 440              void **map_addr ATTRIBUTE_UNUSED,
 441              bfd_size_type *map_len ATTRIBUTE_UNUSED)
 442 {
 443   void *ret = (void *) -1;
 444
 445   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 446     abort ();
 447 #ifdef HAVE_MMAP
 448   else
 449     {
 450       static uintptr_t pagesize_m1;
 451       FILE *f;
 452       file_ptr pg_offset;
 453       bfd_size_type pg_len;
 454
 455       f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 456       if (f == NULL)
 457         return ret;
 458
 459       if (pagesize_m1 == 0)
 460         pagesize_m1 = getpagesize () - 1;
 461
 462       /* Align.  */
 463       pg_offset = offset & ~pagesize_m1;
 464       pg_len = (len + (offset - pg_offset) + pagesize_m1) & ~pagesize_m1;
 465
 466       ret = mmap (addr, pg_len, prot, flags, fileno (f), pg_offset);
 467       if (ret == (void *) -1)
 468         bfd_set_error (bfd_error_system_call);
 469       else
 470         {
 471           *map_addr = ret;
 472           *map_len = pg_len;
 473           ret = (char *) ret + (offset & pagesize_m1);
 474         }
 475     }
 476 #endif
 477
 478   return ret;
 479 }
 480
 481 static const struct bfd_iovec cache_iovec =
 482 {
 483   &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
 484   &cache_bclose, &cache_bflush, &cache_bstat, &cache_bmmap
 485 };
 486
 487 /*
 488 INTERNAL_FUNCTION
 489         bfd_cache_init
 490
 491 SYNOPSIS
 492         bool bfd_cache_init (bfd *abfd);
 493
 494 DESCRIPTION
 495         Add a newly opened BFD to the cache.
 496 */
 497
 498 bool
 499 bfd_cache_init (bfd *abfd)
 500 {
 501   BFD_ASSERT (abfd->iostream != NULL);
 502   if (open_files >= bfd_cache_max_open ())
 503     {
 504       if (! close_one ())
 505         return false;
 506     }
 507   abfd->iovec = &cache_iovec;
 508   insert (abfd);
 509   ++open_files;
 510   return true;
 511 }
 512
 513 /*
 514 INTERNAL_FUNCTION
 515         bfd_cache_close
 516
 517 SYNOPSIS
 518         bool bfd_cache_close (bfd *abfd);
 519
 520 DESCRIPTION
 521         Remove the BFD @var{abfd} from the cache. If the attached file is open,
 522         then close it too.
 523
 524 RETURNS
 525         <<FALSE>> is returned if closing the file fails, <<TRUE>> is
 526         returned if all is well.
 527 */
 528
 529 bool
 530 bfd_cache_close (bfd *abfd)
 531 {
 532   if (abfd->iovec != &cache_iovec)
 533     return true;
 534
 535   if (abfd->iostream == NULL)
 536     /* Previously closed.  */
 537     return true;
 538
 539   return bfd_cache_delete (abfd);
 540 }
 541
 542 /*
 543 FUNCTION
 544         bfd_cache_close_all
 545
 546 SYNOPSIS
 547         bool bfd_cache_close_all (void);
 548
 549 DESCRIPTION
 550         Remove all BFDs from the cache. If the attached file is open,
 551         then close it too.
 552
 553 RETURNS
 554         <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
 555         returned if all is well.
 556 */
 557
 558 bool
 559 bfd_cache_close_all (void)
 560 {
 561   bool ret = true;
 562
 563   while (bfd_last_cache != NULL)
 564     ret &= bfd_cache_close (bfd_last_cache);
 565
 566   return ret;
 567 }
 568
 569 /*
 570 INTERNAL_FUNCTION
 571         bfd_open_file
 572
 573 SYNOPSIS
 574         FILE* bfd_open_file (bfd *abfd);
 575
 576 DESCRIPTION
 577         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
 578         (possibly <<NULL>>) that results from this operation.  Set up the
 579         BFD so that future accesses know the file is open. If the <<FILE *>>
 580         returned is <<NULL>>, then it won't have been put in the
 581         cache, so it won't have to be removed from it.
 582 */
 583
 584 FILE *
 585 bfd_open_file (bfd *abfd)
 586 {
 587   abfd->cacheable = true;       /* Allow it to be closed later.  */
 588
 589   if (open_files >= bfd_cache_max_open ())
 590     {
 591       if (! close_one ())
 592         return NULL;
 593     }
 594
 595   switch (abfd->direction)
 596     {
 597     case read_direction:
 598     case no_direction:
 599       abfd->iostream = _bfd_real_fopen (bfd_get_filename (abfd), FOPEN_RB);
 600       break;
 601     case both_direction:
 602     case write_direction:
 603       if (abfd->opened_once)
 604         {
 605           abfd->iostream = _bfd_real_fopen (bfd_get_filename (abfd),
 606                                             FOPEN_RUB);
 607           if (abfd->iostream == NULL)
 608             abfd->iostream = _bfd_real_fopen (bfd_get_filename (abfd),
 609                                               FOPEN_WUB);
 610         }
 611       else
 612         {
 613           /* Create the file.
 614
 615              Some operating systems won't let us overwrite a running
 616              binary.  For them, we want to unlink the file first.
 617
 618              However, gcc 2.95 will create temporary files using
 619              O_EXCL and tight permissions to prevent other users from
 620              substituting other .o files during the compilation.  gcc
 621              will then tell the assembler to use the newly created
 622              file as an output file.  If we unlink the file here, we
 623              open a brief window when another user could still
 624              substitute a file.
 625
 626              So we unlink the output file if and only if it has
 627              non-zero size.  */
 628 #ifndef __MSDOS__
 629           /* Don't do this for MSDOS: it doesn't care about overwriting
 630              a running binary, but if this file is already open by
 631              another BFD, we will be in deep trouble if we delete an
 632              open file.  In fact, objdump does just that if invoked with
 633              the --info option.  */
 634           struct stat s;
 635
 636           if (stat (bfd_get_filename (abfd), &s) == 0 && s.st_size != 0)
 637             unlink_if_ordinary (bfd_get_filename (abfd));
 638 #endif
 639           abfd->iostream = _bfd_real_fopen (bfd_get_filename (abfd),
 640                                             FOPEN_WUB);
 641           abfd->opened_once = true;
 642         }
 643       break;
 644     }
 645
 646   if (abfd->iostream == NULL)
 647     bfd_set_error (bfd_error_system_call);
 648   else
 649     {
 650       if (! bfd_cache_init (abfd))
 651         return NULL;
 652     }
 653
 654   return (FILE *) abfd->iostream;
 655 }