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