bfd/cache.c

   1 /* BFD library -- caching of file descriptors.
   2    Copyright 1990, 91, 92, 93, 94, 95, 1996, 2000
   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
  97 /* Insert a BFD into the cache.  */
  98
  99 static INLINE void
 100 insert (abfd)
 101      bfd *abfd;
 102 {
 103   if (bfd_last_cache == NULL)
 104     {
 105       abfd->lru_next = abfd;
 106       abfd->lru_prev = abfd;
 107     }
 108   else
 109     {
 110       abfd->lru_next = bfd_last_cache;
 111       abfd->lru_prev = bfd_last_cache->lru_prev;
 112       abfd->lru_prev->lru_next = abfd;
 113       abfd->lru_next->lru_prev = abfd;
 114     }
 115   bfd_last_cache = abfd;
 116 }
 117
 118 /* Remove a BFD from the cache.  */
 119
 120 static INLINE void
 121 snip (abfd)
 122      bfd *abfd;
 123 {
 124   abfd->lru_prev->lru_next = abfd->lru_next;
 125   abfd->lru_next->lru_prev = abfd->lru_prev;
 126   if (abfd == bfd_last_cache)
 127     {
 128       bfd_last_cache = abfd->lru_next;
 129       if (abfd == bfd_last_cache)
 130         bfd_last_cache = NULL;
 131     }
 132 }
 133
 134 /* We need to open a new file, and the cache is full.  Find the least
 135    recently used cacheable BFD and close it.  */
 136
 137 static boolean
 138 close_one ()
 139 {
 140   register bfd *kill;
 141
 142   if (bfd_last_cache == NULL)
 143     kill = NULL;
 144   else
 145     {
 146       for (kill = bfd_last_cache->lru_prev;
 147            ! kill->cacheable;
 148            kill = kill->lru_prev)
 149         {
 150           if (kill == bfd_last_cache)
 151             {
 152               kill = NULL;
 153               break;
 154             }
 155         }
 156     }
 157
 158   if (kill == NULL)
 159     {
 160       /* There are no open cacheable BFD's.  */
 161       return true;
 162     }
 163
 164   kill->where = ftell ((FILE *) kill->iostream);
 165
 166   return bfd_cache_delete (kill);
 167 }
 168
 169 /* Close a BFD and remove it from the cache.  */
 170
 171 static boolean
 172 bfd_cache_delete (abfd)
 173      bfd *abfd;
 174 {
 175   boolean ret;
 176
 177   if (fclose ((FILE *) abfd->iostream) == 0)
 178     ret = true;
 179   else
 180     {
 181       ret = false;
 182       bfd_set_error (bfd_error_system_call);
 183     }
 184
 185   snip (abfd);
 186
 187   abfd->iostream = NULL;
 188   --open_files;
 189
 190   return ret;
 191 }
 192
 193 /*
 194 INTERNAL_FUNCTION
 195         bfd_cache_init
 196
 197 SYNOPSIS
 198         boolean bfd_cache_init (bfd *abfd);
 199
 200 DESCRIPTION
 201         Add a newly opened BFD to the cache.
 202 */
 203
 204 boolean
 205 bfd_cache_init (abfd)
 206      bfd *abfd;
 207 {
 208   BFD_ASSERT (abfd->iostream != NULL);
 209   if (open_files >= BFD_CACHE_MAX_OPEN)
 210     {
 211       if (! close_one ())
 212         return false;
 213     }
 214   insert (abfd);
 215   ++open_files;
 216   return true;
 217 }
 218
 219 /*
 220 INTERNAL_FUNCTION
 221         bfd_cache_close
 222
 223 SYNOPSIS
 224         boolean bfd_cache_close (bfd *abfd);
 225
 226 DESCRIPTION
 227         Remove the BFD @var{abfd} from the cache. If the attached file is open,
 228         then close it too.
 229
 230 RETURNS
 231         <<false>> is returned if closing the file fails, <<true>> is
 232         returned if all is well.
 233 */
 234
 235 boolean
 236 bfd_cache_close (abfd)
 237      bfd *abfd;
 238 {
 239   if (abfd->iostream == NULL
 240       || (abfd->flags & BFD_IN_MEMORY) != 0)
 241     return true;
 242
 243   return bfd_cache_delete (abfd);
 244 }
 245
 246 /*
 247 INTERNAL_FUNCTION
 248         bfd_open_file
 249
 250 SYNOPSIS
 251         FILE* bfd_open_file(bfd *abfd);
 252
 253 DESCRIPTION
 254         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
 255         (possibly <<NULL>>) that results from this operation.  Set up the
 256         BFD so that future accesses know the file is open. If the <<FILE *>>
 257         returned is <<NULL>>, then it won't have been put in the
 258         cache, so it won't have to be removed from it.
 259 */
 260
 261 FILE *
 262 bfd_open_file (abfd)
 263      bfd *abfd;
 264 {
 265   abfd->cacheable = true;       /* Allow it to be closed later. */
 266
 267   if (open_files >= BFD_CACHE_MAX_OPEN)
 268     {
 269       if (! close_one ())
 270         return NULL;
 271     }
 272
 273   switch (abfd->direction)
 274     {
 275     case read_direction:
 276     case no_direction:
 277       abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RB);
 278       break;
 279     case both_direction:
 280     case write_direction:
 281       if (abfd->opened_once == true)
 282         {
 283           abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RUB);
 284           if (abfd->iostream == NULL)
 285             abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
 286         }
 287       else
 288         {
 289           /* Create the file.
 290
 291              Some operating systems won't let us overwrite a running
 292              binary.  For them, we want to unlink the file first.
 293
 294              However, gcc 2.95 will create temporary files using
 295              O_EXCL and tight permissions to prevent other users from
 296              substituting other .o files during the compilation.  gcc
 297              will then tell the assembler to use the newly created
 298              file as an output file.  If we unlink the file here, we
 299              open a brief window when another user could still
 300              substitute a file.
 301
 302              So we unlink the output file if and only if it has
 303              non-zero size.  */
 304 #ifndef __MSDOS__
 305           /* Don't do this for MSDOS: it doesn't care about overwriting
 306              a running binary, but if this file is already open by
 307              another BFD, we will be in deep trouble if we delete an
 308              open file.  In fact, objdump does just that if invoked with
 309              the --info option.  */
 310           struct stat s;
 311
 312           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
 313             unlink (abfd->filename);
 314 #endif
 315           abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WB);
 316           abfd->opened_once = true;
 317         }
 318       break;
 319     }
 320
 321   if (abfd->iostream != NULL)
 322     {
 323       if (! bfd_cache_init (abfd))
 324         return NULL;
 325     }
 326
 327   return (FILE *) abfd->iostream;
 328 }
 329
 330 /*
 331 INTERNAL_FUNCTION
 332         bfd_cache_lookup_worker
 333
 334 SYNOPSIS
 335         FILE *bfd_cache_lookup_worker(bfd *abfd);
 336
 337 DESCRIPTION
 338         Called when the macro <<bfd_cache_lookup>> fails to find a
 339         quick answer.  Find a file descriptor for @var{abfd}.  If
 340         necessary, it open it.  If there are already more than
 341         <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
 342         avoid running out of file descriptors.
 343 */
 344
 345 FILE *
 346 bfd_cache_lookup_worker (abfd)
 347      bfd *abfd;
 348 {
 349   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 350     abort ();
 351
 352   if (abfd->my_archive)
 353     abfd = abfd->my_archive;
 354
 355   if (abfd->iostream != NULL)
 356     {
 357       /* Move the file to the start of the cache.  */
 358       if (abfd != bfd_last_cache)
 359         {
 360           snip (abfd);
 361           insert (abfd);
 362         }
 363     }
 364   else
 365     {
 366       if (bfd_open_file (abfd) == NULL)
 367         return NULL;
 368       if (fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0)
 369         return NULL;
 370     }
 371
 372   return (FILE *) abfd->iostream;
 373 }