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:   return nread;
  313: }
  314: 
  315: static file_ptr
  316: cache_bwrite (struct bfd *abfd, const void *where, file_ptr nbytes)
  317: {
  318:   file_ptr nwrite;
  319:   FILE *f = bfd_cache_lookup (abfd, 0);
  320:   if (f == NULL)
  321:     return 0;
  322:   nwrite = fwrite (where, 1, nbytes, f);
  323:   if (nwrite < nbytes && ferror (f))
  324:     {
  325:       bfd_set_error (bfd_error_system_call);
  326:       return -1;
  327:     }
  328:   return nwrite;
  329: }
  330: 
  331: static int
  332: cache_bclose (struct bfd *abfd)
  333: {
  334:   return bfd_cache_close (abfd);
  335: }
  336: 
  337: static int
  338: cache_bflush (struct bfd *abfd)
  339: {
  340:   int sts;
  341:   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
  342:   if (f == NULL)
  343:     return 0;
  344:   sts = fflush (f);
  345:   if (sts < 0)
  346:     bfd_set_error (bfd_error_system_call);
  347:   return sts;
  348: }
  349: 
  350: static int
  351: cache_bstat (struct bfd *abfd, struct stat *sb)
  352: {
  353:   int sts;
  354:   FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
  355:   if (f == NULL)
  356:     return -1;
  357:   sts = fstat (fileno (f), sb);
  358:   if (sts < 0)
  359:     bfd_set_error (bfd_error_system_call);
  360:   return sts;
  361: }
  362: 
  363: static const struct bfd_iovec cache_iovec = {
  364:   &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
  365:   &cache_bclose, &cache_bflush, &cache_bstat
  366: };
  367: 
  368: /*
  369: INTERNAL_FUNCTION
  370:         bfd_cache_init
  371: 
  372: SYNOPSIS
  373:         bfd_boolean bfd_cache_init (bfd *abfd);
  374: 
  375: DESCRIPTION
  376:         Add a newly opened BFD to the cache.
  377: */
  378: 
  379: bfd_boolean
  380: bfd_cache_init (bfd *abfd)
  381: {
  382:   BFD_ASSERT (abfd->iostream != NULL);
  383:   if (open_files >= BFD_CACHE_MAX_OPEN)
  384:     {
  385:       if (! close_one ())
  386:         return FALSE;
  387:     }
  388:   abfd->iovec = &cache_iovec;
  389:   insert (abfd);
  390:   ++open_files;
  391:   return TRUE;
  392: }
  393: 
  394: /*
  395: INTERNAL_FUNCTION
  396:         bfd_cache_close
  397: 
  398: SYNOPSIS
  399:         bfd_boolean bfd_cache_close (bfd *abfd);
  400: 
  401: DESCRIPTION
  402:         Remove the BFD @var{abfd} from the cache. If the attached file is open,
  403:         then close it too.
  404: 
  405: RETURNS
  406:         <<FALSE>> is returned if closing the file fails, <<TRUE>> is
  407:         returned if all is well.
  408: */
  409: 
  410: bfd_boolean
  411: bfd_cache_close (bfd *abfd)
  412: {
  413:   if (abfd->iovec != &cache_iovec)
  414:     return TRUE;
  415: 
  416:   if (abfd->iostream == NULL)
  417:     /* Previously closed.  */
  418:     return TRUE;
  419: 
  420:   return bfd_cache_delete (abfd);
  421: }
  422: 
  423: /*
  424: FUNCTION
  425:         bfd_cache_close_all
  426: 
  427: SYNOPSIS
  428:         bfd_boolean bfd_cache_close_all (void);
  429: 
  430: DESCRIPTION
  431:         Remove all BFDs from the cache. If the attached file is open,
  432:         then close it too.
  433: 
  434: RETURNS
  435:         <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
  436:         returned if all is well.
  437: */
  438: 
  439: bfd_boolean
  440: bfd_cache_close_all ()
  441: {
  442:   bfd_boolean ret = TRUE;
  443: 
  444:   while (bfd_last_cache != NULL)
  445:     ret &= bfd_cache_close (bfd_last_cache);
  446: 
  447:   return ret;
  448: }
  449: 
  450: /*
  451: INTERNAL_FUNCTION
  452:         bfd_open_file
  453: 
  454: SYNOPSIS
  455:         FILE* bfd_open_file (bfd *abfd);
  456: 
  457: DESCRIPTION
  458:         Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
  459:         (possibly <<NULL>>) that results from this operation.  Set up the
  460:         BFD so that future accesses know the file is open. If the <<FILE *>>
  461:         returned is <<NULL>>, then it won't have been put in the
  462:         cache, so it won't have to be removed from it.
  463: */
  464: 
  465: FILE *
  466: bfd_open_file (bfd *abfd)
  467: {
  468:   abfd->cacheable = TRUE;       /* Allow it to be closed later.  */
  469: 
  470:   if (open_files >= BFD_CACHE_MAX_OPEN)
  471:     {
  472:       if (! close_one ())
  473:         return NULL;
  474:     }
  475: 
  476:   switch (abfd->direction)
  477:     {
  478:     case read_direction:
  479:     case no_direction:
  480:       abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_RB);
  481:       break;
  482:     case both_direction:
  483:     case write_direction:
  484:       if (abfd->opened_once)
  485:         {
  486:           abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_RUB);
  487:           if (abfd->iostream == NULL)
  488:             abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_WUB);
  489:         }
  490:       else
  491:         {
  492:           /* Create the file.
  493: 
  494:              Some operating systems won't let us overwrite a running
  495:              binary.  For them, we want to unlink the file first.
  496: 
  497:              However, gcc 2.95 will create temporary files using
  498:              O_EXCL and tight permissions to prevent other users from
  499:              substituting other .o files during the compilation.  gcc
  500:              will then tell the assembler to use the newly created
  501:              file as an output file.  If we unlink the file here, we
  502:              open a brief window when another user could still
  503:              substitute a file.
  504: 
  505:              So we unlink the output file if and only if it has
  506:              non-zero size.  */
  507: #ifndef __MSDOS__
  508:           /* Don't do this for MSDOS: it doesn't care about overwriting
  509:              a running binary, but if this file is already open by
  510:              another BFD, we will be in deep trouble if we delete an
  511:              open file.  In fact, objdump does just that if invoked with
  512:              the --info option.  */
  513:           struct stat s;
  514: 
  515:           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
  516:             unlink_if_ordinary (abfd->filename);
  517: #endif
  518:           abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_WUB);
  519:           abfd->opened_once = TRUE;
  520:         }
  521:       break;
  522:     }
  523: 
  524:   if (abfd->iostream == NULL)
  525:     bfd_set_error (bfd_error_system_call);
  526:   else
  527:     {
  528:       if (! bfd_cache_init (abfd))
  529:         return NULL;
  530:     }
  531: 
  532:   return (FILE *) abfd->iostream;
  533: }