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
8This file is part of BFD, the Binary File Descriptor library.
9
10This program is free software; you can redistribute it and/or modify
11it under the terms of the GNU General Public License as published by
12the Free Software Foundation; either version 2 of the License, or
13(at your option) any later version.
14
15This program is distributed in the hope that it will be useful,
16but WITHOUT ANY WARRANTY; without even the implied warranty of
17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18GNU General Public License for more details.
19
20You should have received a copy of the GNU General Public License
21along with this program; if not, write to the Free Software
22Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
23
24/*
25SECTION
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
45static bfd_boolean bfd_cache_delete (bfd *);
46
47
48static file_ptr
49cache_btell (struct bfd *abfd)
50{
51  return real_ftell (bfd_cache_lookup (abfd));
52}
53
54static int
55cache_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
67static file_ptr
68cache_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
109static file_ptr
110cache_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
121static int
122cache_bclose (struct bfd *abfd)
123{
124  return bfd_cache_close (abfd);
125}
126
127static int
128cache_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
136static int
137cache_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
145static 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/*
151INTERNAL_FUNCTION
152	BFD_CACHE_MAX_OPEN macro
153
154DESCRIPTION
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
164static int open_files;
165
166/*
167INTERNAL_FUNCTION
168	bfd_last_cache
169
170SYNOPSIS
171	extern bfd *bfd_last_cache;
172
173DESCRIPTION
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
179bfd *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
200static void
201insert (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
220static void
221snip (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
236static bfd_boolean
237close_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
270static bfd_boolean
271bfd_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/*
292INTERNAL_FUNCTION
293	bfd_cache_init
294
295SYNOPSIS
296	bfd_boolean bfd_cache_init (bfd *abfd);
297
298DESCRIPTION
299	Add a newly opened BFD to the cache.
300*/
301
302bfd_boolean
303bfd_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/*
318INTERNAL_FUNCTION
319	bfd_cache_close
320
321SYNOPSIS
322	bfd_boolean bfd_cache_close (bfd *abfd);
323
324DESCRIPTION
325	Remove the BFD @var{abfd} from the cache. If the attached file is open,
326	then close it too.
327
328RETURNS
329	<<FALSE>> is returned if closing the file fails, <<TRUE>> is
330	returned if all is well.
331*/
332
333bfd_boolean
334bfd_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/*
347FUNCTION
348	bfd_cache_close_all
349
350SYNOPSIS
351	bfd_boolean bfd_cache_close_all (void);
352
353DESCRIPTION
354	Remove all BFDs from the cache. If the attached file is open,
355	then close it too.
356
357RETURNS
358	<<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
359	returned if all is well.
360*/
361
362bfd_boolean
363bfd_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/*
374INTERNAL_FUNCTION
375	bfd_open_file
376
377SYNOPSIS
378	FILE* bfd_open_file (bfd *abfd);
379
380DESCRIPTION
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
388FILE *
389bfd_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/*
457INTERNAL_FUNCTION
458	bfd_cache_lookup_worker
459
460SYNOPSIS
461	FILE *bfd_cache_lookup_worker (bfd *abfd);
462
463DESCRIPTION
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
472FILE *
473bfd_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}
500