Commit | Line | Data |
---|---|---|
4a81b561 DHW |
1 | /*** cache.c -- Allows you to have more bfds open than your system has fds. */ |
2 | ||
3 | /* Copyright (C) 1990, 1991 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of BFD, the Binary File Diddler. | |
6 | ||
7 | BFD is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 1, or (at your option) | |
10 | any later version. | |
11 | ||
12 | BFD is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with BFD; see the file COPYING. If not, write to | |
19 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | ||
21 | /* $Id$ */ | |
22 | #include "sysdep.h" | |
23 | #include "bfd.h" | |
24 | #include "libbfd.h" | |
25 | ||
26 | /* These declarations should not be needed; libbfd.h's inclusion should | |
27 | have handled it. | |
28 | int fclose(); | |
29 | int fseek(); | |
30 | */ | |
31 | ||
32 | ||
33 | /* The maximum number of FDs opened by bfd */ | |
34 | #define BFD_CACHE_MAX_OPEN 10 | |
35 | ||
36 | /* when this exceeds BFD_CACHE_MAX_OPEN, we get to work */ | |
37 | static int open_files; | |
38 | ||
39 | static bfd *cache_sentinel; /* Chain of bfds with active fds we've | |
40 | opened */ | |
41 | static void | |
42 | bfd_cache_delete(); | |
43 | ||
44 | bfd *bfd_last_cache; | |
45 | \f | |
46 | ||
47 | static void | |
48 | close_one() | |
49 | { | |
50 | bfd *kill = cache_sentinel; | |
51 | if (kill == 0) /* Nothing in the cache */ | |
52 | return ; | |
53 | ||
54 | /* We can only close files that want to play this game. */ | |
55 | while (!kill->cacheable) { | |
56 | kill = kill->lru_prev; | |
57 | if (kill == cache_sentinel) /* Nobody wants to play */ | |
58 | return ; | |
59 | } | |
60 | ||
61 | kill->where = ftell((FILE *)(kill->iostream)); | |
62 | bfd_cache_delete(kill); | |
63 | ||
64 | } | |
65 | /* Cuts the bfd abfd out of the chain in the cache */ | |
66 | static void | |
67 | snip (abfd) | |
68 | bfd *abfd; | |
69 | { | |
70 | abfd->lru_prev->lru_next = abfd->lru_next; | |
71 | abfd->lru_next->lru_prev = abfd->lru_prev; | |
72 | if (cache_sentinel == abfd) cache_sentinel = (bfd *)NULL; | |
73 | } | |
74 | ||
75 | static void | |
76 | bfd_cache_delete (abfd) | |
77 | bfd *abfd; | |
78 | { | |
79 | fclose ((FILE *)(abfd->iostream)); | |
80 | snip (abfd); | |
81 | abfd->iostream = NULL; | |
82 | open_files--; | |
83 | } | |
84 | ||
85 | static bfd * | |
86 | insert(x,y) | |
87 | bfd *x; | |
88 | bfd *y; | |
89 | { | |
90 | if (y) { | |
91 | x->lru_next = y; | |
92 | x->lru_prev = y->lru_prev; | |
93 | y->lru_prev->lru_next = x; | |
94 | y->lru_prev = x; | |
95 | ||
96 | } | |
97 | else { | |
98 | x->lru_prev = x; | |
99 | x->lru_next = x; | |
100 | } | |
101 | return x; | |
102 | } | |
103 | \f | |
104 | ||
105 | /* Initialize a BFD by putting it on the cache LRU. */ | |
106 | void | |
107 | bfd_cache_init(abfd) | |
108 | bfd *abfd; | |
109 | { | |
110 | cache_sentinel = insert(abfd, cache_sentinel); | |
111 | } | |
112 | ||
113 | void | |
114 | bfd_cache_close(abfd) | |
115 | bfd *abfd; | |
116 | { | |
117 | /* If this file is open then remove from the chain */ | |
118 | if (abfd->iostream) | |
119 | { | |
120 | bfd_cache_delete(abfd); | |
121 | } | |
122 | } | |
123 | \f | |
124 | /* Call the OS to open a file for this BFD. Returns the FILE * | |
125 | (possibly null) that results from this operation. Sets up the | |
126 | BFD so that future accesses know the file is open. */ | |
127 | ||
128 | FILE * | |
129 | bfd_open_file (abfd) | |
130 | bfd *abfd; | |
131 | { | |
132 | abfd->cacheable = true; /* Allow it to be closed later. */ | |
133 | if(open_files >= BFD_CACHE_MAX_OPEN) { | |
134 | close_one(); | |
135 | } | |
136 | switch (abfd->direction) { | |
137 | case read_direction: | |
138 | case no_direction: | |
139 | abfd->iostream = (char *) fopen(abfd->filename, "r"); | |
140 | break; | |
141 | case both_direction: | |
142 | case write_direction: | |
143 | if (abfd->opened_once == true) { | |
144 | abfd->iostream = (char *) fopen(abfd->filename, "r+"); | |
145 | if (!abfd->iostream) { | |
146 | abfd->iostream = (char *) fopen(abfd->filename, "w+"); | |
147 | } | |
148 | } else { | |
149 | /*open for creat */ | |
150 | abfd->iostream = (char *) fopen(abfd->filename, "w"); | |
151 | abfd->opened_once = true; | |
152 | } | |
153 | break; | |
154 | } | |
155 | if (abfd->iostream) { | |
156 | open_files++; | |
157 | bfd_cache_init (abfd); | |
158 | } | |
159 | ||
160 | return (FILE *)(abfd->iostream); | |
161 | } | |
162 | ||
163 | /* Find a file descriptor for this BFD. If necessary, open it. | |
164 | If there are already more than BFD_CACHE_MAX_OPEN files open, try to close | |
165 | one first, to avoid running out of file descriptors. */ | |
166 | ||
167 | FILE * | |
168 | bfd_cache_lookup_worker (abfd) | |
169 | bfd *abfd; | |
170 | { | |
171 | if (abfd->my_archive) | |
172 | { | |
173 | abfd = abfd->my_archive; | |
174 | } | |
175 | /* Is this file already open .. if so then quick exit */ | |
176 | if (abfd->iostream) | |
177 | { | |
178 | if (abfd != cache_sentinel) { | |
179 | /* Place onto head of lru chain */ | |
180 | snip (abfd); | |
181 | cache_sentinel = insert(abfd, cache_sentinel); | |
182 | } | |
183 | } | |
184 | /* This is a bfd without a stream - | |
185 | so it must have been closed or never opened. | |
186 | find an empty cache entry and use it. */ | |
187 | else | |
188 | { | |
189 | ||
190 | if (open_files >= BFD_CACHE_MAX_OPEN) | |
191 | { | |
192 | close_one(); | |
193 | } | |
194 | ||
195 | BFD_ASSERT(bfd_open_file (abfd) != (FILE *)NULL) ; | |
196 | fseek((FILE *)(abfd->iostream), abfd->where, false); | |
197 | } | |
198 | bfd_last_cache = abfd; | |
199 | return (FILE *)(abfd->iostream); | |
200 | } |