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 /* In some cases we can optimize cache operation when reopening files.
  50    For instance, a flush is entirely unnecessary if the file is already
  51    closed, so a flush would use CACHE_NO_OPEN.  Similarly, a seek using
  52    SEEK_SET or SEEK_END need not first seek to the current position.
  53    For stat we ignore seek errors, just in case the file has changed
  54    while we weren't looking.  If it has, then it's possible that the
  55    file is shorter and we don't want a seek error to prevent us doing
  56    the stat.  */
  57 enum cache_flag {
  58   CACHE_NORMAL = 0,
  59   CACHE_NO_OPEN = 1,
  60   CACHE_NO_SEEK = 2,
  61   CACHE_NO_SEEK_ERROR = 4
  62 };
  63
  64 /* The maximum number of files which the cache will keep open at
  65    one time.  */
  66
  67 #define BFD_CACHE_MAX_OPEN 10
  68
  69 /* The number of BFD files we have open.  */
  70
  71 static int open_files;
  72
  73 /* Zero, or a pointer to the topmost BFD on the chain.  This is
  74    used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
  75    determine when it can avoid a function call.  */
  76
  77 static bfd *bfd_last_cache = NULL;
  78
  79 /* Insert a BFD into the cache.  */
  80
  81 static void
  82 insert (bfd *abfd)
  83 {
  84   if (bfd_last_cache == NULL)
  85     {
  86       abfd->lru_next = abfd;
  87       abfd->lru_prev = abfd;
  88     }
  89   else
  90     {
  91       abfd->lru_next = bfd_last_cache;
  92       abfd->lru_prev = bfd_last_cache->lru_prev;
  93       abfd->lru_prev->lru_next = abfd;
  94       abfd->lru_next->lru_prev = abfd;
  95     }
  96   bfd_last_cache = abfd;
  97 }
  98
  99 /* Remove a BFD from the cache.  */
 100
 101 static void
 102 snip (bfd *abfd)
 103 {
 104   abfd->lru_prev->lru_next = abfd->lru_next;
 105   abfd->lru_next->lru_prev = abfd->lru_prev;
 106   if (abfd == bfd_last_cache)
 107     {
 108       bfd_last_cache = abfd->lru_next;
 109       if (abfd == bfd_last_cache)
 110         bfd_last_cache = NULL;
 111     }
 112 }
 113
 114 /* Close a BFD and remove it from the cache.  */
 115
 116 static bfd_boolean
 117 bfd_cache_delete (bfd *abfd)
 118 {
 119   bfd_boolean ret;
 120
 121   if (fclose ((FILE *) abfd->iostream) == 0)
 122     ret = TRUE;
 123   else
 124     {
 125       ret = FALSE;
 126       bfd_set_error (bfd_error_system_call);
 127     }
 128
 129   snip (abfd);
 130
 131   abfd->iostream = NULL;
 132   --open_files;
 133
 134   return ret;
 135 }
 136
 137 /* We need to open a new file, and the cache is full.  Find the least
 138    recently used cacheable BFD and close it.  */
 139
 140 static bfd_boolean
 141 close_one (void)
 142 {
 143   register bfd *kill;
 144
 145   if (bfd_last_cache == NULL)
 146     kill = NULL;
 147   else
 148     {
 149       for (kill = bfd_last_cache->lru_prev;
 150            ! kill->cacheable;
 151            kill = kill->lru_prev)
 152         {
 153           if (kill == bfd_last_cache)
 154             {
 155               kill = NULL;
 156               break;
 157             }
 158         }
 159     }
 160
 161   if (kill == NULL)
 162     {
 163       /* There are no open cacheable BFD's.  */
 164       return TRUE;
 165     }
 166
 167   kill->where = real_ftell ((FILE *) kill->iostream);
 168
 169   /* Save the file st_mtime.  This is a hack so that gdb can detect when
 170      an executable has been deleted and recreated.  The only thing that
 171      makes this reasonable is that st_mtime doesn't change when a file
 172      is unlinked, so saving st_mtime makes BFD's file cache operation
 173      a little more transparent for this particular usage pattern.  If we
 174      hadn't closed the file then we would not have lost the original
 175      contents, st_mtime etc.  Of course, if something is writing to an
 176      existing file, then this is the wrong thing to do.
 177      FIXME: gdb should save these times itself on first opening a file,
 178      and this hack be removed.  */
 179   if (kill->direction == no_direction || kill->direction == read_direction)
 180     {
 181       bfd_get_mtime (kill);
 182       kill->mtime_set = TRUE;
 183     }
 184
 185   return bfd_cache_delete (kill);
 186 }
 187
 188 /* Check to see if the required BFD is the same as the last one
 189    looked up. If so, then it can use the stream in the BFD with
 190    impunity, since it can't have changed since the last lookup;
 191    otherwise, it has to perform the complicated lookup function.  */
 192
 193 #define bfd_cache_lookup(x, flag) \
 194   ((x) == bfd_last_cache                        \
 195    ? (FILE *) (bfd_last_cache->iostream)        \
 196    : bfd_cache_lookup_worker (x, flag))
 197
 198 /* Called when the macro <<bfd_cache_lookup>> fails to find a
 199    quick answer.  Find a file descriptor for @var{abfd}.  If
 200    necessary, it open it.  If there are already more than
 201    <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
 202    avoid running out of file descriptors.  It will return NULL
 203    if it is unable to (re)open the @var{abfd}.  */
 204
 205 static FILE *
 206 bfd_cache_lookup_worker (bfd *abfd, enum cache_flag flag)
 207 {
 208   bfd *orig_bfd = abfd;
 209   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 210     abort ();
 211
 212   if (abfd->my_archive)
 213     abfd = abfd->my_archive;
 214
 215   if (abfd->iostream != NULL)
 216     {
 217       /* Move the file to the start of the cache.  */
 218       if (abfd != bfd_last_cache)
 219         {
 220           snip (abfd);
 221           insert (abfd);
 222         }
 223       return (FILE *) abfd->iostream;
 224     }
 225
 226   if (flag & CACHE_NO_OPEN)
 227     return NULL;
 228
 229   if (bfd_open_file (abfd) == NULL)
 230     ;
 231   else if (!(flag & CACHE_NO_SEEK)
 232            && real_fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0
 233            && !(flag & CACHE_NO_SEEK_ERROR))
 234     bfd_set_error (bfd_error_system_call);
 235   else
 236     return (FILE *) abfd->iostream;
 237
 238   (*_bfd_error_handler) (_("reopening %B: %s\n"),
 239                          orig_bfd, bfd_errmsg (bfd_get_error ()));
 240   return NULL;
 241 }
 242
 243 static file_ptr
 244 cache_btell (struct bfd *abfd)
 245 {
 246   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 247   if (f == NULL)
 248     return abfd->where;
 249   return real_ftell (f);
 250 }
 251
 252 static int
 253 cache_bseek (struct bfd *abfd, file_ptr offset, int whence)
 254 {
 255   FILE *f = bfd_cache_lookup (abfd, whence != SEEK_CUR ? CACHE_NO_SEEK : 0);
 256   if (f == NULL)
 257     return -1;
 258   return real_fseek (f, offset, whence);
 259 }
 260
 261 /* Note that archive entries don't have streams; they share their parent's.
 262    This allows someone to play with the iostream behind BFD's back.
 263
 264    Also, note that the origin pointer points to the beginning of a file's
 265    contents (0 for non-archive elements).  For archive entries this is the
 266    first octet in the file, NOT the beginning of the archive header.  */
 267
 268 static file_ptr
 269 cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
 270 {
 271   FILE *f;
 272   file_ptr nread;
 273   /* FIXME - this looks like an optimization, but it's really to cover
 274      up for a feature of some OSs (not solaris - sigh) that
 275      ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
 276      internally and tries to link against them.  BFD seems to be smart
 277      enough to realize there are no symbol records in the "file" that
 278      doesn't exist but attempts to read them anyway.  On Solaris,
 279      attempting to read zero bytes from a NULL file results in a core
 280      dump, but on other platforms it just returns zero bytes read.
 281      This makes it to something reasonable. - DJ */
 282   if (nbytes == 0)
 283     return 0;
 284
 285   f = bfd_cache_lookup (abfd, 0);
 286   if (f == NULL)
 287     return 0;
 288
 289 #if defined (__VAX) && defined (VMS)
 290   /* Apparently fread on Vax VMS does not keep the record length
 291      information.  */
 292   nread = read (fileno (f), buf, nbytes);
 293   /* Set bfd_error if we did not read as much data as we expected.  If
 294      the read failed due to an error set the bfd_error_system_call,
 295      else set bfd_error_file_truncated.  */
 296   if (nread == (file_ptr)-1)
 297     {
 298       bfd_set_error (bfd_error_system_call);
 299       return -1;
 300     }
 301 #else
 302   nread = fread (buf, 1, nbytes, f);
 303   /* Set bfd_error if we did not read as much data as we expected.  If
 304      the read failed due to an error set the bfd_error_system_call,
 305      else set bfd_error_file_truncated.  */
 306   if (nread < nbytes && ferror (f))
 307     {
 308       bfd_set_error (bfd_error_system_call);
 309       return -1;
 310     }
 311 #endif
 312   if (nread < nbytes)
 313     /* This may or may not be an error, but in case the calling code
 314        bails out because of it, set the right error code.  */
 315     bfd_set_error (bfd_error_file_truncated);
 316   return nread;
 317 }
 318
 319 static file_ptr
 320 cache_bwrite (struct bfd *abfd, const void *where, file_ptr nbytes)
 321 {
 322   file_ptr nwrite;
 323   FILE *f = bfd_cache_lookup (abfd, 0);
 324   if (f == NULL)
 325     return 0;
 326   nwrite = fwrite (where, 1, nbytes, f);
 327   if (nwrite < nbytes && ferror (f))
 328     {
 329       bfd_set_error (bfd_error_system_call);
 330       return -1;
 331     }
 332   return nwrite;
 333 }
 334
 335 static int
 336 cache_bclose (struct bfd *abfd)
 337 {
 338   return bfd_cache_close (abfd);
 339 }
 340
 341 static int
 342 cache_bflush (struct bfd *abfd)
 343 {
 344   int sts;
 345   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
 346   if (f == NULL)
 347     return 0;
 348   sts = fflush (f);
 349   if (sts < 0)
 350     bfd_set_error (bfd_error_system_call);
 351   return sts;
 352 }
 353
 354 static int
 355 cache_bstat (struct bfd *abfd, struct stat *sb)
 356 {
 357   int sts;
 358   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
 359   if (f == NULL)
 360     return -1;
 361   sts = fstat (fileno (f), sb);
 362   if (sts < 0)
 363     bfd_set_error (bfd_error_system_call);
 364   return sts;
 365 }
 366
 367 static const struct bfd_iovec cache_iovec = {
 368   &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
 369   &cache_bclose, &cache_bflush, &cache_bstat
 370 };
 371
 372 /*
 373 INTERNAL_FUNCTION
 374         bfd_cache_init
 375
 376 SYNOPSIS
 377         bfd_boolean bfd_cache_init (bfd *abfd);
 378
 379 DESCRIPTION
 380         Add a newly opened BFD to the cache.
 381 */
 382
 383 bfd_boolean
 384 bfd_cache_init (bfd *abfd)
 385 {
 386   BFD_ASSERT (abfd->iostream != NULL);
 387   if (open_files >= BFD_CACHE_MAX_OPEN)
 388     {
 389       if (! close_one ())
 390         return FALSE;
 391     }
 392   abfd->iovec = &cache_iovec;
 393   insert (abfd);
 394   ++open_files;
 395   return TRUE;
 396 }
 397
 398 /*
 399 INTERNAL_FUNCTION
 400         bfd_cache_close
 401
 402 SYNOPSIS
 403         bfd_boolean bfd_cache_close (bfd *abfd);
 404
 405 DESCRIPTION
 406         Remove the BFD @var{abfd} from the cache. If the attached file is open,
 407         then close it too.
 408
 409 RETURNS
 410         <<FALSE>> is returned if closing the file fails, <<TRUE>> is
 411         returned if all is well.
 412 */
 413
 414 bfd_boolean
 415 bfd_cache_close (bfd *abfd)
 416 {
 417   if (abfd->iovec != &cache_iovec)
 418     return TRUE;
 419
 420   if (abfd->iostream == NULL)
 421     /* Previously closed.  */
 422     return TRUE;
 423
 424   return bfd_cache_delete (abfd);
 425 }
 426
 427 /*
 428 FUNCTION
 429         bfd_cache_close_all
 430
 431 SYNOPSIS
 432         bfd_boolean bfd_cache_close_all (void);
 433
 434 DESCRIPTION
 435         Remove all BFDs from the cache. If the attached file is open,
 436         then close it too.
 437
 438 RETURNS
 439         <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
 440         returned if all is well.
 441 */
 442
 443 bfd_boolean
 444 bfd_cache_close_all ()
 445 {
 446   bfd_boolean ret = TRUE;
 447
 448   while (bfd_last_cache != NULL)
 449     ret &= bfd_cache_close (bfd_last_cache);
 450
 451   return ret;
 452 }
 453
 454 /*
 455 INTERNAL_FUNCTION
 456         bfd_open_file
 457
 458 SYNOPSIS
 459         FILE* bfd_open_file (bfd *abfd);
 460
 461 DESCRIPTION
 462         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
 463         (possibly <<NULL>>) that results from this operation.  Set up the
 464         BFD so that future accesses know the file is open. If the <<FILE *>>
 465         returned is <<NULL>>, then it won't have been put in the
 466         cache, so it won't have to be removed from it.
 467 */
 468
 469 FILE *
 470 bfd_open_file (bfd *abfd)
 471 {
 472   abfd->cacheable = TRUE;       /* Allow it to be closed later.  */
 473
 474   if (open_files >= BFD_CACHE_MAX_OPEN)
 475     {
 476       if (! close_one ())
 477         return NULL;
 478     }
 479
 480   switch (abfd->direction)
 481     {
 482     case read_direction:
 483     case no_direction:
 484       abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_RB);
 485       break;
 486     case both_direction:
 487     case write_direction:
 488       if (abfd->opened_once)
 489         {
 490           abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_RUB);
 491           if (abfd->iostream == NULL)
 492             abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_WUB);
 493         }
 494       else
 495         {
 496           /* Create the file.
 497
 498              Some operating systems won't let us overwrite a running
 499              binary.  For them, we want to unlink the file first.
 500
 501              However, gcc 2.95 will create temporary files using
 502              O_EXCL and tight permissions to prevent other users from
 503              substituting other .o files during the compilation.  gcc
 504              will then tell the assembler to use the newly created
 505              file as an output file.  If we unlink the file here, we
 506              open a brief window when another user could still
 507              substitute a file.
 508
 509              So we unlink the output file if and only if it has
 510              non-zero size.  */
 511 #ifndef __MSDOS__
 512           /* Don't do this for MSDOS: it doesn't care about overwriting
 513              a running binary, but if this file is already open by
 514              another BFD, we will be in deep trouble if we delete an
 515              open file.  In fact, objdump does just that if invoked with
 516              the --info option.  */
 517           struct stat s;
 518
 519           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
 520             unlink_if_ordinary (abfd->filename);
 521 #endif
 522           abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_WUB);
 523           abfd->opened_once = TRUE;
 524         }
 525       break;
 526     }
 527
 528   if (abfd->iostream == NULL)
 529     bfd_set_error (bfd_error_system_call);
 530   else
 531     {
 532       if (! bfd_cache_init (abfd))
 533         return NULL;
 534     }
 535
 536   return (FILE *) abfd->iostream;
 537 }