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
8 This file is part of BFD, the Binary File Descriptor library.
9
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.
14
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.
19
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23
24 /*
25 SECTION
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
45 static bfd_boolean bfd_cache_delete (bfd *);
46
47 /*
48 INTERNAL_FUNCTION
49 BFD_CACHE_MAX_OPEN macro
50
51 DESCRIPTION
52 The maximum number of files which the cache will keep open at
53 one time.
54
55 .#define BFD_CACHE_MAX_OPEN 10
56
57 */
58
59 /* The number of BFD files we have open. */
60
61 static int open_files;
62
63 /*
64 INTERNAL_FUNCTION
65 bfd_last_cache
66
67 SYNOPSIS
68 extern bfd *bfd_last_cache;
69
70 DESCRIPTION
71 Zero, or a pointer to the topmost BFD on the chain. This is
72 used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
73 determine when it can avoid a function call.
74 */
75
76 bfd *bfd_last_cache;
77
78 /*
79 INTERNAL_FUNCTION
80 bfd_cache_lookup
81
82 DESCRIPTION
83 Check to see if the required BFD is the same as the last one
84 looked up. If so, then it can use the stream in the BFD with
85 impunity, since it can't have changed since the last lookup;
86 otherwise, it has to perform the complicated lookup function.
87
88 .#define bfd_cache_lookup(x) \
89 . ((x)==bfd_last_cache? \
90 . (FILE*) (bfd_last_cache->iostream): \
91 . bfd_cache_lookup_worker(x))
92
93 */
94
95 /* Insert a BFD into the cache. */
96
97 static void
insert(bfd * abfd)98 insert (bfd *abfd)
99 {
100 if (bfd_last_cache == NULL)
101 {
102 abfd->lru_next = abfd;
103 abfd->lru_prev = abfd;
104 }
105 else
106 {
107 abfd->lru_next = bfd_last_cache;
108 abfd->lru_prev = bfd_last_cache->lru_prev;
109 abfd->lru_prev->lru_next = abfd;
110 abfd->lru_next->lru_prev = abfd;
111 }
112 bfd_last_cache = abfd;
113 }
114
115 /* Remove a BFD from the cache. */
116
117 static void
snip(bfd * abfd)118 snip (bfd *abfd)
119 {
120 abfd->lru_prev->lru_next = abfd->lru_next;
121 abfd->lru_next->lru_prev = abfd->lru_prev;
122 if (abfd == bfd_last_cache)
123 {
124 bfd_last_cache = abfd->lru_next;
125 if (abfd == bfd_last_cache)
126 bfd_last_cache = NULL;
127 }
128 }
129
130 /* We need to open a new file, and the cache is full. Find the least
131 recently used cacheable BFD and close it. */
132
133 static bfd_boolean
close_one(void)134 close_one (void)
135 {
136 register bfd *kill;
137
138 if (bfd_last_cache == NULL)
139 kill = NULL;
140 else
141 {
142 for (kill = bfd_last_cache->lru_prev;
143 ! kill->cacheable;
144 kill = kill->lru_prev)
145 {
146 if (kill == bfd_last_cache)
147 {
148 kill = NULL;
149 break;
150 }
151 }
152 }
153
154 if (kill == NULL)
155 {
156 /* There are no open cacheable BFD's. */
157 return TRUE;
158 }
159
160 kill->where = real_ftell ((FILE *) kill->iostream);
161
162 return bfd_cache_delete (kill);
163 }
164
165 /* Close a BFD and remove it from the cache. */
166
167 static bfd_boolean
bfd_cache_delete(bfd * abfd)168 bfd_cache_delete (bfd *abfd)
169 {
170 bfd_boolean ret;
171
172 if (fclose ((FILE *) abfd->iostream) == 0)
173 ret = TRUE;
174 else
175 {
176 ret = FALSE;
177 bfd_set_error (bfd_error_system_call);
178 }
179
180 snip (abfd);
181
182 abfd->iostream = NULL;
183 --open_files;
184
185 return ret;
186 }
187
188 /*
189 INTERNAL_FUNCTION
190 bfd_cache_init
191
192 SYNOPSIS
193 bfd_boolean bfd_cache_init (bfd *abfd);
194
195 DESCRIPTION
196 Add a newly opened BFD to the cache.
197 */
198
199 bfd_boolean
bfd_cache_init(bfd * abfd)200 bfd_cache_init (bfd *abfd)
201 {
202 BFD_ASSERT (abfd->iostream != NULL);
203 if (open_files >= BFD_CACHE_MAX_OPEN)
204 {
205 if (! close_one ())
206 return FALSE;
207 }
208 insert (abfd);
209 ++open_files;
210 return TRUE;
211 }
212
213 /*
214 INTERNAL_FUNCTION
215 bfd_cache_close
216
217 SYNOPSIS
218 bfd_boolean bfd_cache_close (bfd *abfd);
219
220 DESCRIPTION
221 Remove the BFD @var{abfd} from the cache. If the attached file is open,
222 then close it too.
223
224 RETURNS
225 <<FALSE>> is returned if closing the file fails, <<TRUE>> is
226 returned if all is well.
227 */
228
229 bfd_boolean
bfd_cache_close(bfd * abfd)230 bfd_cache_close (bfd *abfd)
231 {
232 if (abfd->iostream == NULL
233 || (abfd->flags & BFD_IN_MEMORY) != 0)
234 return TRUE;
235
236 return bfd_cache_delete (abfd);
237 }
238
239 /*
240 INTERNAL_FUNCTION
241 bfd_open_file
242
243 SYNOPSIS
244 FILE* bfd_open_file (bfd *abfd);
245
246 DESCRIPTION
247 Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
248 (possibly <<NULL>>) that results from this operation. Set up the
249 BFD so that future accesses know the file is open. If the <<FILE *>>
250 returned is <<NULL>>, then it won't have been put in the
251 cache, so it won't have to be removed from it.
252 */
253
254 FILE *
bfd_open_file(bfd * abfd)255 bfd_open_file (bfd *abfd)
256 {
257 abfd->cacheable = TRUE; /* Allow it to be closed later. */
258
259 if (open_files >= BFD_CACHE_MAX_OPEN)
260 {
261 if (! close_one ())
262 return NULL;
263 }
264
265 switch (abfd->direction)
266 {
267 case read_direction:
268 case no_direction:
269 abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RB);
270 break;
271 case both_direction:
272 case write_direction:
273 if (abfd->opened_once)
274 {
275 abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RUB);
276 if (abfd->iostream == NULL)
277 abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
278 }
279 else
280 {
281 /* Create the file.
282
283 Some operating systems won't let us overwrite a running
284 binary. For them, we want to unlink the file first.
285
286 However, gcc 2.95 will create temporary files using
287 O_EXCL and tight permissions to prevent other users from
288 substituting other .o files during the compilation. gcc
289 will then tell the assembler to use the newly created
290 file as an output file. If we unlink the file here, we
291 open a brief window when another user could still
292 substitute a file.
293
294 So we unlink the output file if and only if it has
295 non-zero size. */
296 #ifndef __MSDOS__
297 /* Don't do this for MSDOS: it doesn't care about overwriting
298 a running binary, but if this file is already open by
299 another BFD, we will be in deep trouble if we delete an
300 open file. In fact, objdump does just that if invoked with
301 the --info option. */
302 struct stat s;
303
304 if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
305 unlink (abfd->filename);
306 #endif
307 abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
308 abfd->opened_once = TRUE;
309 }
310 break;
311 }
312
313 if (abfd->iostream != NULL)
314 {
315 if (! bfd_cache_init (abfd))
316 return NULL;
317 }
318
319 return (FILE *) abfd->iostream;
320 }
321
322 /*
323 INTERNAL_FUNCTION
324 bfd_cache_lookup_worker
325
326 SYNOPSIS
327 FILE *bfd_cache_lookup_worker (bfd *abfd);
328
329 DESCRIPTION
330 Called when the macro <<bfd_cache_lookup>> fails to find a
331 quick answer. Find a file descriptor for @var{abfd}. If
332 necessary, it open it. If there are already more than
333 <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
334 avoid running out of file descriptors.
335 */
336
337 FILE *
bfd_cache_lookup_worker(bfd * abfd)338 bfd_cache_lookup_worker (bfd *abfd)
339 {
340 if ((abfd->flags & BFD_IN_MEMORY) != 0)
341 abort ();
342
343 if (abfd->my_archive)
344 abfd = abfd->my_archive;
345
346 if (abfd->iostream != NULL)
347 {
348 /* Move the file to the start of the cache. */
349 if (abfd != bfd_last_cache)
350 {
351 snip (abfd);
352 insert (abfd);
353 }
354 }
355 else
356 {
357 if (bfd_open_file (abfd) == NULL)
358 return NULL;
359 if (abfd->where != (unsigned long) abfd->where)
360 return NULL;
361 if (real_fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0)
362 return NULL;
363 }
364
365 return (FILE *) abfd->iostream;
366 }
367