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 return bfd_cache_delete (kill
);
172 /* Check to see if the required BFD is the same as the last one
173 looked up. If so, then it can use the stream in the BFD with
174 impunity, since it can't have changed since the last lookup;
175 otherwise, it has to perform the complicated lookup function. */
177 #define bfd_cache_lookup(x, flag) \
178 ((x) == bfd_last_cache \
179 ? (FILE *) (bfd_last_cache->iostream) \
180 : bfd_cache_lookup_worker (x, flag))
182 /* Called when the macro <<bfd_cache_lookup>> fails to find a
183 quick answer. Find a file descriptor for @var{abfd}. If
184 necessary, it open it. If there are already more than
185 <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
186 avoid running out of file descriptors. It will return NULL
187 if it is unable to (re)open the @var{abfd}. */
190 bfd_cache_lookup_worker (bfd
*abfd
, enum cache_flag flag
)
192 bfd
*orig_bfd
= abfd
;
193 if ((abfd
->flags
& BFD_IN_MEMORY
) != 0)
196 if (abfd
->my_archive
)
197 abfd
= abfd
->my_archive
;
199 if (abfd
->iostream
!= NULL
)
201 /* Move the file to the start of the cache. */
202 if (abfd
!= bfd_last_cache
)
207 return (FILE *) abfd
->iostream
;
210 if (flag
& CACHE_NO_OPEN
)
213 if (bfd_open_file (abfd
) == NULL
)
215 else if (!(flag
& CACHE_NO_SEEK
)
216 && real_fseek ((FILE *) abfd
->iostream
, abfd
->where
, SEEK_SET
) != 0
217 && !(flag
& CACHE_NO_SEEK_ERROR
))
218 bfd_set_error (bfd_error_system_call
);
220 return (FILE *) abfd
->iostream
;
222 (*_bfd_error_handler
) (_("reopening %B: %s\n"),
223 orig_bfd
, bfd_errmsg (bfd_get_error ()));
228 cache_btell (struct bfd
*abfd
)
230 FILE *f
= bfd_cache_lookup (abfd
, CACHE_NO_OPEN
);
233 return real_ftell (f
);
237 cache_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
239 FILE *f
= bfd_cache_lookup (abfd
, whence
!= SEEK_CUR
? CACHE_NO_SEEK
: 0);
242 return real_fseek (f
, offset
, whence
);
245 /* Note that archive entries don't have streams; they share their parent's.
246 This allows someone to play with the iostream behind BFD's back.
248 Also, note that the origin pointer points to the beginning of a file's
249 contents (0 for non-archive elements). For archive entries this is the
250 first octet in the file, NOT the beginning of the archive header. */
253 cache_bread_1 (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
257 /* FIXME - this looks like an optimization, but it's really to cover
258 up for a feature of some OSs (not solaris - sigh) that
259 ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
260 internally and tries to link against them. BFD seems to be smart
261 enough to realize there are no symbol records in the "file" that
262 doesn't exist but attempts to read them anyway. On Solaris,
263 attempting to read zero bytes from a NULL file results in a core
264 dump, but on other platforms it just returns zero bytes read.
265 This makes it to something reasonable. - DJ */
269 f
= bfd_cache_lookup (abfd
, 0);
273 #if defined (__VAX) && defined (VMS)
274 /* Apparently fread on Vax VMS does not keep the record length
276 nread
= read (fileno (f
), buf
, nbytes
);
277 /* Set bfd_error if we did not read as much data as we expected. If
278 the read failed due to an error set the bfd_error_system_call,
279 else set bfd_error_file_truncated. */
280 if (nread
== (file_ptr
)-1)
282 bfd_set_error (bfd_error_system_call
);
286 nread
= fread (buf
, 1, nbytes
, f
);
287 /* Set bfd_error if we did not read as much data as we expected. If
288 the read failed due to an error set the bfd_error_system_call,
289 else set bfd_error_file_truncated. */
290 if (nread
< nbytes
&& ferror (f
))
292 bfd_set_error (bfd_error_system_call
);
297 /* This may or may not be an error, but in case the calling code
298 bails out because of it, set the right error code. */
299 bfd_set_error (bfd_error_file_truncated
);
304 cache_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
308 /* Some filesystems are unable to handle reads that are too large
309 (for instance, NetApp shares with oplocks turned off). To avoid
310 hitting this limitation, we read the buffer in chunks of 8MB max. */
311 while (nread
< nbytes
)
313 const file_ptr max_chunk_size
= 0x800000;
314 file_ptr chunk_size
= nbytes
- nread
;
315 file_ptr chunk_nread
;
317 if (chunk_size
> max_chunk_size
)
318 chunk_size
= max_chunk_size
;
320 chunk_nread
= cache_bread_1 (abfd
, (char *) buf
+ nread
, chunk_size
);
322 /* Update the nread count.
324 We just have to be careful of the case when cache_bread_1 returns
325 a negative count: If this is our first read, then set nread to
326 that negative count in order to return that negative value to the
327 caller. Otherwise, don't add it to our total count, or we would
328 end up returning a smaller number of bytes read than we actually
330 if (nread
== 0 || chunk_nread
> 0)
331 nread
+= chunk_nread
;
333 if (chunk_nread
< chunk_size
)
341 cache_bwrite (struct bfd
*abfd
, const void *where
, file_ptr nbytes
)
344 FILE *f
= bfd_cache_lookup (abfd
, 0);
348 nwrite
= fwrite (where
, 1, nbytes
, f
);
349 if (nwrite
< nbytes
&& ferror (f
))
351 bfd_set_error (bfd_error_system_call
);
358 cache_bclose (struct bfd
*abfd
)
360 return bfd_cache_close (abfd
);
364 cache_bflush (struct bfd
*abfd
)
367 FILE *f
= bfd_cache_lookup (abfd
, CACHE_NO_OPEN
);
373 bfd_set_error (bfd_error_system_call
);
378 cache_bstat (struct bfd
*abfd
, struct stat
*sb
)
381 FILE *f
= bfd_cache_lookup (abfd
, CACHE_NO_SEEK_ERROR
);
385 sts
= fstat (fileno (f
), sb
);
387 bfd_set_error (bfd_error_system_call
);
391 static const struct bfd_iovec cache_iovec
=
393 &cache_bread
, &cache_bwrite
, &cache_btell
, &cache_bseek
,
394 &cache_bclose
, &cache_bflush
, &cache_bstat
402 bfd_boolean bfd_cache_init (bfd *abfd);
405 Add a newly opened BFD to the cache.
409 bfd_cache_init (bfd
*abfd
)
411 BFD_ASSERT (abfd
->iostream
!= NULL
);
412 if (open_files
>= BFD_CACHE_MAX_OPEN
)
417 abfd
->iovec
= &cache_iovec
;
428 bfd_boolean bfd_cache_close (bfd *abfd);
431 Remove the BFD @var{abfd} from the cache. If the attached file is open,
435 <<FALSE>> is returned if closing the file fails, <<TRUE>> is
436 returned if all is well.
440 bfd_cache_close (bfd
*abfd
)
442 if (abfd
->iovec
!= &cache_iovec
)
445 if (abfd
->iostream
== NULL
)
446 /* Previously closed. */
449 return bfd_cache_delete (abfd
);
457 bfd_boolean bfd_cache_close_all (void);
460 Remove all BFDs from the cache. If the attached file is open,
464 <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
465 returned if all is well.
469 bfd_cache_close_all ()
471 bfd_boolean ret
= TRUE
;
473 while (bfd_last_cache
!= NULL
)
474 ret
&= bfd_cache_close (bfd_last_cache
);
484 FILE* bfd_open_file (bfd *abfd);
487 Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
488 (possibly <<NULL>>) that results from this operation. Set up the
489 BFD so that future accesses know the file is open. If the <<FILE *>>
490 returned is <<NULL>>, then it won't have been put in the
491 cache, so it won't have to be removed from it.
495 bfd_open_file (bfd
*abfd
)
497 abfd
->cacheable
= TRUE
; /* Allow it to be closed later. */
499 if (open_files
>= BFD_CACHE_MAX_OPEN
)
505 switch (abfd
->direction
)
509 abfd
->iostream
= (PTR
) real_fopen (abfd
->filename
, FOPEN_RB
);
512 case write_direction
:
513 if (abfd
->opened_once
)
515 abfd
->iostream
= (PTR
) real_fopen (abfd
->filename
, FOPEN_RUB
);
516 if (abfd
->iostream
== NULL
)
517 abfd
->iostream
= (PTR
) real_fopen (abfd
->filename
, FOPEN_WUB
);
523 Some operating systems won't let us overwrite a running
524 binary. For them, we want to unlink the file first.
526 However, gcc 2.95 will create temporary files using
527 O_EXCL and tight permissions to prevent other users from
528 substituting other .o files during the compilation. gcc
529 will then tell the assembler to use the newly created
530 file as an output file. If we unlink the file here, we
531 open a brief window when another user could still
534 So we unlink the output file if and only if it has
537 /* Don't do this for MSDOS: it doesn't care about overwriting
538 a running binary, but if this file is already open by
539 another BFD, we will be in deep trouble if we delete an
540 open file. In fact, objdump does just that if invoked with
541 the --info option. */
544 if (stat (abfd
->filename
, &s
) == 0 && s
.st_size
!= 0)
545 unlink_if_ordinary (abfd
->filename
);
547 abfd
->iostream
= (PTR
) real_fopen (abfd
->filename
, FOPEN_WUB
);
548 abfd
->opened_once
= TRUE
;
553 if (abfd
->iostream
== NULL
)
554 bfd_set_error (bfd_error_system_call
);
557 if (! bfd_cache_init (abfd
))
561 return (FILE *) abfd
->iostream
;
This page took 0.039941 seconds and 4 git commands to generate.