bfd/cache.c

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