1 /* BFD library -- caching of file descriptors.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002,
4 2003, 2004, 2005, 2007 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 3 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,
23 MA 02110-1301, USA. */
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
47 #include "libiberty.h"
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
61 CACHE_NO_SEEK_ERROR
= 4
64 /* The maximum number of files which the cache will keep open at
67 #define BFD_CACHE_MAX_OPEN 10
69 /* The number of BFD files we have open. */
71 static int open_files
;
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. */
77 static bfd
*bfd_last_cache
= NULL
;
79 /* Insert a BFD into the cache. */
84 if (bfd_last_cache
== NULL
)
86 abfd
->lru_next
= abfd
;
87 abfd
->lru_prev
= abfd
;
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
;
96 bfd_last_cache
= abfd
;
99 /* Remove a BFD from the cache. */
104 abfd
->lru_prev
->lru_next
= abfd
->lru_next
;
105 abfd
->lru_next
->lru_prev
= abfd
->lru_prev
;
106 if (abfd
== bfd_last_cache
)
108 bfd_last_cache
= abfd
->lru_next
;
109 if (abfd
== bfd_last_cache
)
110 bfd_last_cache
= NULL
;
114 /* Close a BFD and remove it from the cache. */
117 bfd_cache_delete (bfd
*abfd
)
121 if (fclose ((FILE *) abfd
->iostream
) == 0)
126 bfd_set_error (bfd_error_system_call
);
131 abfd
->iostream
= NULL
;
137 /* We need to open a new file, and the cache is full. Find the least
138 recently used cacheable BFD and close it. */
145 if (bfd_last_cache
== NULL
)
149 for (kill
= bfd_last_cache
->lru_prev
;
151 kill
= kill
->lru_prev
)
153 if (kill
== bfd_last_cache
)
163 /* There are no open cacheable BFD's. */
167 kill
->where
= real_ftell ((FILE *) kill
->iostream
);
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
)
181 bfd_get_mtime (kill
);
182 kill
->mtime_set
= TRUE
;
185 return bfd_cache_delete (kill
);
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. */
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))
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}. */
206 bfd_cache_lookup_worker (bfd
*abfd
, enum cache_flag flag
)
208 bfd
*orig_bfd
= abfd
;
209 if ((abfd
->flags
& BFD_IN_MEMORY
) != 0)
212 if (abfd
->my_archive
)
213 abfd
= abfd
->my_archive
;
215 if (abfd
->iostream
!= NULL
)
217 /* Move the file to the start of the cache. */
218 if (abfd
!= bfd_last_cache
)
223 return (FILE *) abfd
->iostream
;
226 if (flag
& CACHE_NO_OPEN
)
229 if (bfd_open_file (abfd
) == NULL
)
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
);
236 return (FILE *) abfd
->iostream
;
238 (*_bfd_error_handler
) (_("reopening %B: %s\n"),
239 orig_bfd
, bfd_errmsg (bfd_get_error ()));
244 cache_btell (struct bfd
*abfd
)
246 FILE *f
= bfd_cache_lookup (abfd
, CACHE_NO_OPEN
);
249 return real_ftell (f
);
253 cache_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
255 FILE *f
= bfd_cache_lookup (abfd
, whence
!= SEEK_CUR
? CACHE_NO_SEEK
: 0);
258 return real_fseek (f
, offset
, whence
);
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.
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. */
269 cache_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
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 */
285 f
= bfd_cache_lookup (abfd
, 0);
289 #if defined (__VAX) && defined (VMS)
290 /* Apparently fread on Vax VMS does not keep the record length
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)
298 bfd_set_error (bfd_error_system_call
);
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
))
308 bfd_set_error (bfd_error_system_call
);
316 cache_bwrite (struct bfd
*abfd
, const void *where
, file_ptr nbytes
)
319 FILE *f
= bfd_cache_lookup (abfd
, 0);
322 nwrite
= fwrite (where
, 1, nbytes
, f
);
323 if (nwrite
< nbytes
&& ferror (f
))
325 bfd_set_error (bfd_error_system_call
);
332 cache_bclose (struct bfd
*abfd
)
334 return bfd_cache_close (abfd
);
338 cache_bflush (struct bfd
*abfd
)
341 FILE *f
= bfd_cache_lookup (abfd
, CACHE_NO_OPEN
);
346 bfd_set_error (bfd_error_system_call
);
351 cache_bstat (struct bfd
*abfd
, struct stat
*sb
)
354 FILE *f
= bfd_cache_lookup (abfd
, CACHE_NO_SEEK_ERROR
);
357 sts
= fstat (fileno (f
), sb
);
359 bfd_set_error (bfd_error_system_call
);
363 static const struct bfd_iovec cache_iovec
= {
364 &cache_bread
, &cache_bwrite
, &cache_btell
, &cache_bseek
,
365 &cache_bclose
, &cache_bflush
, &cache_bstat
373 bfd_boolean bfd_cache_init (bfd *abfd);
376 Add a newly opened BFD to the cache.
380 bfd_cache_init (bfd
*abfd
)
382 BFD_ASSERT (abfd
->iostream
!= NULL
);
383 if (open_files
>= BFD_CACHE_MAX_OPEN
)
388 abfd
->iovec
= &cache_iovec
;
399 bfd_boolean bfd_cache_close (bfd *abfd);
402 Remove the BFD @var{abfd} from the cache. If the attached file is open,
406 <<FALSE>> is returned if closing the file fails, <<TRUE>> is
407 returned if all is well.
411 bfd_cache_close (bfd
*abfd
)
413 if (abfd
->iovec
!= &cache_iovec
)
416 if (abfd
->iostream
== NULL
)
417 /* Previously closed. */
420 return bfd_cache_delete (abfd
);
428 bfd_boolean bfd_cache_close_all (void);
431 Remove all BFDs from the cache. If the attached file is open,
435 <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
436 returned if all is well.
440 bfd_cache_close_all ()
442 bfd_boolean ret
= TRUE
;
444 while (bfd_last_cache
!= NULL
)
445 ret
&= bfd_cache_close (bfd_last_cache
);
455 FILE* bfd_open_file (bfd *abfd);
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.
466 bfd_open_file (bfd
*abfd
)
468 abfd
->cacheable
= TRUE
; /* Allow it to be closed later. */
470 if (open_files
>= BFD_CACHE_MAX_OPEN
)
476 switch (abfd
->direction
)
480 abfd
->iostream
= (PTR
) real_fopen (abfd
->filename
, FOPEN_RB
);
483 case write_direction
:
484 if (abfd
->opened_once
)
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
);
494 Some operating systems won't let us overwrite a running
495 binary. For them, we want to unlink the file first.
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
505 So we unlink the output file if and only if it has
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. */
515 if (stat (abfd
->filename
, &s
) == 0 && s
.st_size
!= 0)
516 unlink_if_ordinary (abfd
->filename
);
518 abfd
->iostream
= (PTR
) real_fopen (abfd
->filename
, FOPEN_WUB
);
519 abfd
->opened_once
= TRUE
;
524 if (abfd
->iostream
== NULL
)
525 bfd_set_error (bfd_error_system_call
);
528 if (! bfd_cache_init (abfd
))
532 return (FILE *) abfd
->iostream
;
This page took 0.039945 seconds and 4 git commands to generate.