1 /* BFD library -- caching of file descriptors.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002,
4 2003, 2004 Free Software Foundation, Inc.
6 Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
8 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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, MA 02110-1301, USA. */
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
46 #include "libiberty.h"
48 static bfd_boolean
bfd_cache_delete (bfd
*);
52 cache_btell (struct bfd
*abfd
)
54 return real_ftell (bfd_cache_lookup (abfd
));
58 cache_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
60 return real_fseek (bfd_cache_lookup (abfd
), offset
, whence
);
63 /* Note that archive entries don't have streams; they share their parent's.
64 This allows someone to play with the iostream behind BFD's back.
66 Also, note that the origin pointer points to the beginning of a file's
67 contents (0 for non-archive elements). For archive entries this is the
68 first octet in the file, NOT the beginning of the archive header. */
71 cache_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
74 /* FIXME - this looks like an optimization, but it's really to cover
75 up for a feature of some OSs (not solaris - sigh) that
76 ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
77 internally and tries to link against them. BFD seems to be smart
78 enough to realize there are no symbol records in the "file" that
79 doesn't exist but attempts to read them anyway. On Solaris,
80 attempting to read zero bytes from a NULL file results in a core
81 dump, but on other platforms it just returns zero bytes read.
82 This makes it to something reasonable. - DJ */
86 #if defined (__VAX) && defined (VMS)
87 /* Apparently fread on Vax VMS does not keep the record length
89 nread
= read (fileno (bfd_cache_lookup (abfd
)), buf
, nbytes
);
90 /* Set bfd_error if we did not read as much data as we expected. If
91 the read failed due to an error set the bfd_error_system_call,
92 else set bfd_error_file_truncated. */
93 if (nread
== (file_ptr
)-1)
95 bfd_set_error (bfd_error_system_call
);
99 nread
= fread (buf
, 1, nbytes
, bfd_cache_lookup (abfd
));
100 /* Set bfd_error if we did not read as much data as we expected. If
101 the read failed due to an error set the bfd_error_system_call,
102 else set bfd_error_file_truncated. */
103 if (nread
< nbytes
&& ferror (bfd_cache_lookup (abfd
)))
105 bfd_set_error (bfd_error_system_call
);
113 cache_bwrite (struct bfd
*abfd
, const void *where
, file_ptr nbytes
)
115 file_ptr nwrite
= fwrite (where
, 1, nbytes
, bfd_cache_lookup (abfd
));
116 if (nwrite
< nbytes
&& ferror (bfd_cache_lookup (abfd
)))
118 bfd_set_error (bfd_error_system_call
);
125 cache_bclose (struct bfd
*abfd
)
127 return bfd_cache_close (abfd
);
131 cache_bflush (struct bfd
*abfd
)
133 int sts
= fflush (bfd_cache_lookup (abfd
));
135 bfd_set_error (bfd_error_system_call
);
140 cache_bstat (struct bfd
*abfd
, struct stat
*sb
)
142 int sts
= fstat (fileno (bfd_cache_lookup (abfd
)), sb
);
144 bfd_set_error (bfd_error_system_call
);
148 static const struct bfd_iovec cache_iovec
= {
149 &cache_bread
, &cache_bwrite
, &cache_btell
, &cache_bseek
,
150 &cache_bclose
, &cache_bflush
, &cache_bstat
155 BFD_CACHE_MAX_OPEN macro
158 The maximum number of files which the cache will keep open at
161 .#define BFD_CACHE_MAX_OPEN 10
165 /* The number of BFD files we have open. */
167 static int open_files
;
174 extern bfd *bfd_last_cache;
177 Zero, or a pointer to the topmost BFD on the chain. This is
178 used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
179 determine when it can avoid a function call.
182 bfd
*bfd_last_cache
= NULL
;
189 Check to see if the required BFD is the same as the last one
190 looked up. If so, then it can use the stream in the BFD with
191 impunity, since it can't have changed since the last lookup;
192 otherwise, it has to perform the complicated lookup function.
194 .#define bfd_cache_lookup(x) \
195 . ((x) == bfd_last_cache ? \
196 . (FILE *) (bfd_last_cache->iostream): \
197 . bfd_cache_lookup_worker (x))
201 /* Insert a BFD into the cache. */
206 if (bfd_last_cache
== NULL
)
208 abfd
->lru_next
= abfd
;
209 abfd
->lru_prev
= abfd
;
213 abfd
->lru_next
= bfd_last_cache
;
214 abfd
->lru_prev
= bfd_last_cache
->lru_prev
;
215 abfd
->lru_prev
->lru_next
= abfd
;
216 abfd
->lru_next
->lru_prev
= abfd
;
218 bfd_last_cache
= abfd
;
221 /* Remove a BFD from the cache. */
226 abfd
->lru_prev
->lru_next
= abfd
->lru_next
;
227 abfd
->lru_next
->lru_prev
= abfd
->lru_prev
;
228 if (abfd
== bfd_last_cache
)
230 bfd_last_cache
= abfd
->lru_next
;
231 if (abfd
== bfd_last_cache
)
232 bfd_last_cache
= NULL
;
236 /* We need to open a new file, and the cache is full. Find the least
237 recently used cacheable BFD and close it. */
244 if (bfd_last_cache
== NULL
)
248 for (kill
= bfd_last_cache
->lru_prev
;
250 kill
= kill
->lru_prev
)
252 if (kill
== bfd_last_cache
)
262 /* There are no open cacheable BFD's. */
266 kill
->where
= real_ftell ((FILE *) kill
->iostream
);
268 return bfd_cache_delete (kill
);
271 /* Close a BFD and remove it from the cache. */
274 bfd_cache_delete (bfd
*abfd
)
278 if (fclose ((FILE *) abfd
->iostream
) == 0)
283 bfd_set_error (bfd_error_system_call
);
288 abfd
->iostream
= NULL
;
299 bfd_boolean bfd_cache_init (bfd *abfd);
302 Add a newly opened BFD to the cache.
306 bfd_cache_init (bfd
*abfd
)
308 BFD_ASSERT (abfd
->iostream
!= NULL
);
309 if (open_files
>= BFD_CACHE_MAX_OPEN
)
314 abfd
->iovec
= &cache_iovec
;
325 bfd_boolean bfd_cache_close (bfd *abfd);
328 Remove the BFD @var{abfd} from the cache. If the attached file is open,
332 <<FALSE>> is returned if closing the file fails, <<TRUE>> is
333 returned if all is well.
337 bfd_cache_close (bfd
*abfd
)
339 if (abfd
->iovec
!= &cache_iovec
)
342 if (abfd
->iostream
== NULL
)
343 /* Previously closed. */
346 return bfd_cache_delete (abfd
);
354 bfd_boolean bfd_cache_close_all (void);
357 Remove all BFDs from the cache. If the attached file is open,
361 <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
362 returned if all is well.
366 bfd_cache_close_all ()
368 bfd_boolean ret
= TRUE
;
370 while (bfd_last_cache
!= NULL
)
371 ret
&= bfd_cache_close (bfd_last_cache
);
381 FILE* bfd_open_file (bfd *abfd);
384 Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
385 (possibly <<NULL>>) that results from this operation. Set up the
386 BFD so that future accesses know the file is open. If the <<FILE *>>
387 returned is <<NULL>>, then it won't have been put in the
388 cache, so it won't have to be removed from it.
392 bfd_open_file (bfd
*abfd
)
394 abfd
->cacheable
= TRUE
; /* Allow it to be closed later. */
396 if (open_files
>= BFD_CACHE_MAX_OPEN
)
402 switch (abfd
->direction
)
406 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_RB
);
409 case write_direction
:
410 if (abfd
->opened_once
)
412 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_RUB
);
413 if (abfd
->iostream
== NULL
)
414 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_WUB
);
420 Some operating systems won't let us overwrite a running
421 binary. For them, we want to unlink the file first.
423 However, gcc 2.95 will create temporary files using
424 O_EXCL and tight permissions to prevent other users from
425 substituting other .o files during the compilation. gcc
426 will then tell the assembler to use the newly created
427 file as an output file. If we unlink the file here, we
428 open a brief window when another user could still
431 So we unlink the output file if and only if it has
434 /* Don't do this for MSDOS: it doesn't care about overwriting
435 a running binary, but if this file is already open by
436 another BFD, we will be in deep trouble if we delete an
437 open file. In fact, objdump does just that if invoked with
438 the --info option. */
441 if (stat (abfd
->filename
, &s
) == 0 && s
.st_size
!= 0)
442 unlink_if_ordinary (abfd
->filename
);
444 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_WUB
);
445 abfd
->opened_once
= TRUE
;
450 if (abfd
->iostream
== NULL
)
451 bfd_set_error (bfd_error_system_call
);
454 if (! bfd_cache_init (abfd
))
458 return (FILE *) abfd
->iostream
;
463 bfd_cache_lookup_worker
466 FILE *bfd_cache_lookup_worker (bfd *abfd);
469 Called when the macro <<bfd_cache_lookup>> fails to find a
470 quick answer. Find a file descriptor for @var{abfd}. If
471 necessary, it open it. If there are already more than
472 <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
473 avoid running out of file descriptors. It will abort rather than
474 returning NULL if it is unable to (re)open the @var{abfd}.
478 bfd_cache_lookup_worker (bfd
*abfd
)
480 bfd
*orig_bfd
= abfd
;
481 if ((abfd
->flags
& BFD_IN_MEMORY
) != 0)
484 if (abfd
->my_archive
)
485 abfd
= abfd
->my_archive
;
487 if (abfd
->iostream
!= NULL
)
489 /* Move the file to the start of the cache. */
490 if (abfd
!= bfd_last_cache
)
495 return (FILE *) abfd
->iostream
;
498 if (bfd_open_file (abfd
) == NULL
)
500 else if (real_fseek ((FILE *) abfd
->iostream
, abfd
->where
, SEEK_SET
) != 0)
501 bfd_set_error (bfd_error_system_call
);
503 return (FILE *) abfd
->iostream
;
505 (*_bfd_error_handler
) (_("reopening %B: %s\n"),
506 orig_bfd
, bfd_errmsg (bfd_get_error ()));
This page took 0.039858 seconds and 5 git commands to generate.