daily update
[binutils.git] / bfd / cache.c
blob50674e88b0ece0b58f580dc5d07b179b56e4b75e
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. */
26 SECTION
27 File caching
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.
40 SUBSECTION
41 Caching functions
44 #include "sysdep.h"
45 #include "bfd.h"
46 #include "libbfd.h"
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
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
64 /* The maximum number of files which the cache will keep open at
65 one time. */
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. */
81 static void
82 insert (bfd *abfd)
84 if (bfd_last_cache == NULL)
86 abfd->lru_next = abfd;
87 abfd->lru_prev = abfd;
89 else
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. */
101 static void
102 snip (bfd *abfd)
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. */
116 static bfd_boolean
117 bfd_cache_delete (bfd *abfd)
119 bfd_boolean ret;
121 if (fclose ((FILE *) abfd->iostream) == 0)
122 ret = TRUE;
123 else
125 ret = FALSE;
126 bfd_set_error (bfd_error_system_call);
129 snip (abfd);
131 abfd->iostream = NULL;
132 --open_files;
134 return ret;
137 /* We need to open a new file, and the cache is full. Find the least
138 recently used cacheable BFD and close it. */
140 static bfd_boolean
141 close_one (void)
143 register bfd *kill;
145 if (bfd_last_cache == NULL)
146 kill = NULL;
147 else
149 for (kill = bfd_last_cache->lru_prev;
150 ! kill->cacheable;
151 kill = kill->lru_prev)
153 if (kill == bfd_last_cache)
155 kill = NULL;
156 break;
161 if (kill == NULL)
163 /* There are no open cacheable BFD's. */
164 return TRUE;
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}. */
189 static FILE *
190 bfd_cache_lookup_worker (bfd *abfd, enum cache_flag flag)
192 bfd *orig_bfd = abfd;
193 if ((abfd->flags & BFD_IN_MEMORY) != 0)
194 abort ();
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)
204 snip (abfd);
205 insert (abfd);
207 return (FILE *) abfd->iostream;
210 if (flag & CACHE_NO_OPEN)
211 return NULL;
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);
219 else
220 return (FILE *) abfd->iostream;
222 (*_bfd_error_handler) (_("reopening %B: %s\n"),
223 orig_bfd, bfd_errmsg (bfd_get_error ()));
224 return NULL;
227 static file_ptr
228 cache_btell (struct bfd *abfd)
230 FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
231 if (f == NULL)
232 return abfd->where;
233 return real_ftell (f);
236 static int
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);
240 if (f == NULL)
241 return -1;
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. */
252 static file_ptr
253 cache_bread_1 (struct bfd *abfd, void *buf, file_ptr nbytes)
255 FILE *f;
256 file_ptr nread;
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 */
266 if (nbytes == 0)
267 return 0;
269 f = bfd_cache_lookup (abfd, 0);
270 if (f == NULL)
271 return 0;
273 #if defined (__VAX) && defined (VMS)
274 /* Apparently fread on Vax VMS does not keep the record length
275 information. */
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);
283 return -1;
285 #else
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);
293 return -1;
295 #endif
296 if (nread < nbytes)
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);
300 return nread;
303 static file_ptr
304 cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
306 file_ptr nread = 0;
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
329 did. */
330 if (nread == 0 || chunk_nread > 0)
331 nread += chunk_nread;
333 if (chunk_nread < chunk_size)
334 break;
337 return nread;
340 static file_ptr
341 cache_bwrite (struct bfd *abfd, const void *where, file_ptr nbytes)
343 file_ptr nwrite;
344 FILE *f = bfd_cache_lookup (abfd, 0);
346 if (f == NULL)
347 return 0;
348 nwrite = fwrite (where, 1, nbytes, f);
349 if (nwrite < nbytes && ferror (f))
351 bfd_set_error (bfd_error_system_call);
352 return -1;
354 return nwrite;
357 static int
358 cache_bclose (struct bfd *abfd)
360 return bfd_cache_close (abfd);
363 static int
364 cache_bflush (struct bfd *abfd)
366 int sts;
367 FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN);
369 if (f == NULL)
370 return 0;
371 sts = fflush (f);
372 if (sts < 0)
373 bfd_set_error (bfd_error_system_call);
374 return sts;
377 static int
378 cache_bstat (struct bfd *abfd, struct stat *sb)
380 int sts;
381 FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR);
383 if (f == NULL)
384 return -1;
385 sts = fstat (fileno (f), sb);
386 if (sts < 0)
387 bfd_set_error (bfd_error_system_call);
388 return sts;
391 static const struct bfd_iovec cache_iovec =
393 &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
394 &cache_bclose, &cache_bflush, &cache_bstat
398 INTERNAL_FUNCTION
399 bfd_cache_init
401 SYNOPSIS
402 bfd_boolean bfd_cache_init (bfd *abfd);
404 DESCRIPTION
405 Add a newly opened BFD to the cache.
408 bfd_boolean
409 bfd_cache_init (bfd *abfd)
411 BFD_ASSERT (abfd->iostream != NULL);
412 if (open_files >= BFD_CACHE_MAX_OPEN)
414 if (! close_one ())
415 return FALSE;
417 abfd->iovec = &cache_iovec;
418 insert (abfd);
419 ++open_files;
420 return TRUE;
424 INTERNAL_FUNCTION
425 bfd_cache_close
427 SYNOPSIS
428 bfd_boolean bfd_cache_close (bfd *abfd);
430 DESCRIPTION
431 Remove the BFD @var{abfd} from the cache. If the attached file is open,
432 then close it too.
434 RETURNS
435 <<FALSE>> is returned if closing the file fails, <<TRUE>> is
436 returned if all is well.
439 bfd_boolean
440 bfd_cache_close (bfd *abfd)
442 if (abfd->iovec != &cache_iovec)
443 return TRUE;
445 if (abfd->iostream == NULL)
446 /* Previously closed. */
447 return TRUE;
449 return bfd_cache_delete (abfd);
453 FUNCTION
454 bfd_cache_close_all
456 SYNOPSIS
457 bfd_boolean bfd_cache_close_all (void);
459 DESCRIPTION
460 Remove all BFDs from the cache. If the attached file is open,
461 then close it too.
463 RETURNS
464 <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
465 returned if all is well.
468 bfd_boolean
469 bfd_cache_close_all ()
471 bfd_boolean ret = TRUE;
473 while (bfd_last_cache != NULL)
474 ret &= bfd_cache_close (bfd_last_cache);
476 return ret;
480 INTERNAL_FUNCTION
481 bfd_open_file
483 SYNOPSIS
484 FILE* bfd_open_file (bfd *abfd);
486 DESCRIPTION
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.
494 FILE *
495 bfd_open_file (bfd *abfd)
497 abfd->cacheable = TRUE; /* Allow it to be closed later. */
499 if (open_files >= BFD_CACHE_MAX_OPEN)
501 if (! close_one ())
502 return NULL;
505 switch (abfd->direction)
507 case read_direction:
508 case no_direction:
509 abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_RB);
510 break;
511 case both_direction:
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);
519 else
521 /* Create the file.
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
532 substitute a file.
534 So we unlink the output file if and only if it has
535 non-zero size. */
536 #ifndef __MSDOS__
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. */
542 struct stat s;
544 if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
545 unlink_if_ordinary (abfd->filename);
546 #endif
547 abfd->iostream = (PTR) real_fopen (abfd->filename, FOPEN_WUB);
548 abfd->opened_once = TRUE;
550 break;
553 if (abfd->iostream == NULL)
554 bfd_set_error (bfd_error_system_call);
555 else
557 if (! bfd_cache_init (abfd))
558 return NULL;
561 return (FILE *) abfd->iostream;