bfd/cache.c

   1 /* BFD library -- caching of file descriptors.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4    Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23 SECTION
  24         File caching
  25
  26         The file caching mechanism is embedded within BFD and allows
  27         the application to open as many BFDs as it wants without
  28         regard to the underlying operating system's file descriptor
  29         limit (often as low as 20 open files).  The module in
  30         <<cache.c>> maintains a least recently used list of
  31         <<BFD_CACHE_MAX_OPEN>> files, and exports the name
  32         <<bfd_cache_lookup>>, which runs around and makes sure that
  33         the required BFD is open. If not, then it chooses a file to
  34         close, closes it and opens the one wanted, returning its file
  35         handle.
  36
  37 */
  38
  39 #include "bfd.h"
  40 #include "sysdep.h"
  41 #include "libbfd.h"
  42
  43 static void insert PARAMS ((bfd *));
  44 static void snip PARAMS ((bfd *));
  45 static boolean close_one PARAMS ((void));
  46 static boolean bfd_cache_delete PARAMS ((bfd *));
  47
  48 /*
  49 INTERNAL_FUNCTION
  50         BFD_CACHE_MAX_OPEN macro
  51
  52 DESCRIPTION
  53         The maximum number of files which the cache will keep open at
  54         one time.
  55
  56 .#define BFD_CACHE_MAX_OPEN 10
  57
  58 */
  59
  60 /* The number of BFD files we have open.  */
  61
  62 static int open_files;
  63
  64 /*
  65 INTERNAL_FUNCTION
  66         bfd_last_cache
  67
  68 SYNOPSIS
  69         extern bfd *bfd_last_cache;
  70
  71 DESCRIPTION
  72         Zero, or a pointer to the topmost BFD on the chain.  This is
  73         used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
  74         determine when it can avoid a function call.
  75 */
  76
  77 bfd *bfd_last_cache;
  78
  79 /*
  80   INTERNAL_FUNCTION
  81         bfd_cache_lookup
  82
  83   DESCRIPTION
  84         Check to see if the required BFD is the same as the last one
  85         looked up. If so, then it can use the stream in the BFD with
  86         impunity, since it can't have changed since the last lookup;
  87         otherwise, it has to perform the complicated lookup function.
  88
  89   .#define bfd_cache_lookup(x) \
  90   .    ((x)==bfd_last_cache? \
  91   .      (FILE*) (bfd_last_cache->iostream): \
  92   .       bfd_cache_lookup_worker(x))
  93
  94  */
  95
  96 /* Insert a BFD into the cache.  */
  97
  98 static INLINE void
  99 insert (abfd)
 100      bfd *abfd;
 101 {
 102   if (bfd_last_cache == NULL)
 103     {
 104       abfd->lru_next = abfd;
 105       abfd->lru_prev = abfd;
 106     }
 107   else
 108     {
 109       abfd->lru_next = bfd_last_cache;
 110       abfd->lru_prev = bfd_last_cache->lru_prev;
 111       abfd->lru_prev->lru_next = abfd;
 112       abfd->lru_next->lru_prev = abfd;
 113     }
 114   bfd_last_cache = abfd;
 115 }
 116
 117 /* Remove a BFD from the cache.  */
 118
 119 static INLINE void
 120 snip (abfd)
 121      bfd *abfd;
 122 {
 123   abfd->lru_prev->lru_next = abfd->lru_next;
 124   abfd->lru_next->lru_prev = abfd->lru_prev;
 125   if (abfd == bfd_last_cache)
 126     {
 127       bfd_last_cache = abfd->lru_next;
 128       if (abfd == bfd_last_cache)
 129         bfd_last_cache = NULL;
 130     }
 131 }
 132
 133 /* We need to open a new file, and the cache is full.  Find the least
 134    recently used cacheable BFD and close it.  */
 135
 136 static boolean
 137 close_one ()
 138 {
 139   register bfd *kill;
 140
 141   if (bfd_last_cache == NULL)
 142     kill = NULL;
 143   else
 144     {
 145       for (kill = bfd_last_cache->lru_prev;
 146            ! kill->cacheable;
 147            kill = kill->lru_prev)
 148         {
 149           if (kill == bfd_last_cache)
 150             {
 151               kill = NULL;
 152               break;
 153             }
 154         }
 155     }
 156
 157   if (kill == NULL)
 158     {
 159       /* There are no open cacheable BFD's.  */
 160       return true;
 161     }
 162
 163   kill->where = ftell ((FILE *) kill->iostream);
 164
 165   return bfd_cache_delete (kill);
 166 }
 167
 168 /* Close a BFD and remove it from the cache.  */
 169
 170 static boolean
 171 bfd_cache_delete (abfd)
 172      bfd *abfd;
 173 {
 174   boolean ret;
 175
 176   if (fclose ((FILE *) abfd->iostream) == 0)
 177     ret = true;
 178   else
 179     {
 180       ret = false;
 181       bfd_set_error (bfd_error_system_call);
 182     }
 183
 184   snip (abfd);
 185
 186   abfd->iostream = NULL;
 187   --open_files;
 188
 189   return ret;
 190 }
 191
 192 /*
 193 INTERNAL_FUNCTION
 194         bfd_cache_init
 195
 196 SYNOPSIS
 197         boolean bfd_cache_init (bfd *abfd);
 198
 199 DESCRIPTION
 200         Add a newly opened BFD to the cache.
 201 */
 202
 203 boolean
 204 bfd_cache_init (abfd)
 205      bfd *abfd;
 206 {
 207   BFD_ASSERT (abfd->iostream != NULL);
 208   if (open_files >= BFD_CACHE_MAX_OPEN)
 209     {
 210       if (! close_one ())
 211         return false;
 212     }
 213   insert (abfd);
 214   ++open_files;
 215   return true;
 216 }
 217
 218 /*
 219 INTERNAL_FUNCTION
 220         bfd_cache_close
 221
 222 SYNOPSIS
 223         boolean bfd_cache_close (bfd *abfd);
 224
 225 DESCRIPTION
 226         Remove the BFD @var{abfd} from the cache. If the attached file is open,
 227         then close it too.
 228
 229 RETURNS
 230         <<false>> is returned if closing the file fails, <<true>> is
 231         returned if all is well.
 232 */
 233
 234 boolean
 235 bfd_cache_close (abfd)
 236      bfd *abfd;
 237 {
 238   if (abfd->iostream == NULL
 239       || (abfd->flags & BFD_IN_MEMORY) != 0)
 240     return true;
 241
 242   return bfd_cache_delete (abfd);
 243 }
 244
 245 /*
 246 INTERNAL_FUNCTION
 247         bfd_open_file
 248
 249 SYNOPSIS
 250         FILE* bfd_open_file(bfd *abfd);
 251
 252 DESCRIPTION
 253         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
 254         (possibly <<NULL>>) that results from this operation.  Set up the
 255         BFD so that future accesses know the file is open. If the <<FILE *>>
 256         returned is <<NULL>>, then it won't have been put in the
 257         cache, so it won't have to be removed from it.
 258 */
 259
 260 FILE *
 261 bfd_open_file (abfd)
 262      bfd *abfd;
 263 {
 264   abfd->cacheable = true;       /* Allow it to be closed later.  */
 265
 266   if (open_files >= BFD_CACHE_MAX_OPEN)
 267     {
 268       if (! close_one ())
 269         return NULL;
 270     }
 271
 272   switch (abfd->direction)
 273     {
 274     case read_direction:
 275     case no_direction:
 276       abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RB);
 277       break;
 278     case both_direction:
 279     case write_direction:
 280       if (abfd->opened_once)
 281         {
 282           abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RUB);
 283           if (abfd->iostream == NULL)
 284             abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
 285         }
 286       else
 287         {
 288           /* Create the file.
 289
 290              Some operating systems won't let us overwrite a running
 291              binary.  For them, we want to unlink the file first.
 292
 293              However, gcc 2.95 will create temporary files using
 294              O_EXCL and tight permissions to prevent other users from
 295              substituting other .o files during the compilation.  gcc
 296              will then tell the assembler to use the newly created
 297              file as an output file.  If we unlink the file here, we
 298              open a brief window when another user could still
 299              substitute a file.
 300
 301              So we unlink the output file if and only if it has
 302              non-zero size.  */
 303 #ifndef __MSDOS__
 304           /* Don't do this for MSDOS: it doesn't care about overwriting
 305              a running binary, but if this file is already open by
 306              another BFD, we will be in deep trouble if we delete an
 307              open file.  In fact, objdump does just that if invoked with
 308              the --info option.  */
 309           struct stat s;
 310
 311           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
 312             unlink (abfd->filename);
 313 #endif
 314           abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
 315           abfd->opened_once = true;
 316         }
 317       break;
 318     }
 319
 320   if (abfd->iostream != NULL)
 321     {
 322       if (! bfd_cache_init (abfd))
 323         return NULL;
 324     }
 325
 326   return (FILE *) abfd->iostream;
 327 }
 328
 329 /*
 330 INTERNAL_FUNCTION
 331         bfd_cache_lookup_worker
 332
 333 SYNOPSIS
 334         FILE *bfd_cache_lookup_worker(bfd *abfd);
 335
 336 DESCRIPTION
 337         Called when the macro <<bfd_cache_lookup>> fails to find a
 338         quick answer.  Find a file descriptor for @var{abfd}.  If
 339         necessary, it open it.  If there are already more than
 340         <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
 341         avoid running out of file descriptors.
 342 */
 343
 344 FILE *
 345 bfd_cache_lookup_worker (abfd)
 346      bfd *abfd;
 347 {
 348   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 349     abort ();
 350
 351   if (abfd->my_archive)
 352     abfd = abfd->my_archive;
 353
 354   if (abfd->iostream != NULL)
 355     {
 356       /* Move the file to the start of the cache.  */
 357       if (abfd != bfd_last_cache)
 358         {
 359           snip (abfd);
 360           insert (abfd);
 361         }
 362     }
 363   else
 364     {
 365       if (bfd_open_file (abfd) == NULL)
 366         return NULL;
 367       if (abfd->where != (unsigned long) abfd->where)
 368         return NULL;
 369       if (fseek ((FILE *) abfd->iostream, (long) abfd->where, SEEK_SET) != 0)
 370         return NULL;
 371     }
 372
 373   return (FILE *) abfd->iostream;
 374 }