1 /* BFD library -- caching of file descriptors. 2 3 Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002, 4 2003, 2004, 2005, 2007, 2008, 2009 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 3 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., 51 Franklin Street - Fifth Floor, Boston, 23 MA 02110-1301, USA. */ 24 25 /* 26 SECTION 27 File caching 28 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. 39 40 SUBSECTION 41 Caching functions 42 */ 43 44 #include "sysdep.h" 45 #include "bfd.h" 46 #include "libbfd.h" 47 #include "libiberty.h" 48 #include "bfd_stdint.h" 49 50 #ifdef HAVE_MMAP 51 #include <sys/mman.h> 52 #endif 53 54 /* In some cases we can optimize cache operation when reopening files. 55 For instance, a flush is entirely unnecessary if the file is already 56 closed, so a flush would use CACHE_NO_OPEN. Similarly, a seek using 57 SEEK_SET or SEEK_END need not first seek to the current position. 58 For stat we ignore seek errors, just in case the file has changed 59 while we weren't looking. If it has, then it's possible that the 60 file is shorter and we don't want a seek error to prevent us doing 61 the stat. */ 62 enum cache_flag { 63 CACHE_NORMAL = 0, 64 CACHE_NO_OPEN = 1, 65 CACHE_NO_SEEK = 2, 66 CACHE_NO_SEEK_ERROR = 4 67 }; 68 69 /* The maximum number of files which the cache will keep open at 70 one time. */ 71 72 #define BFD_CACHE_MAX_OPEN 10 73 74 /* The number of BFD files we have open. */ 75 76 static int open_files; 77 78 /* Zero, or a pointer to the topmost BFD on the chain. This is 79 used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to 80 determine when it can avoid a function call. */ 81 82 static bfd *bfd_last_cache = NULL; 83 84 /* Insert a BFD into the cache. */ 85 86 static void 87 insert (bfd *abfd) 88 { 89 if (bfd_last_cache == NULL) 90 { 91 abfd->lru_next = abfd; 92 abfd->lru_prev = abfd; 93 } 94 else 95 { 96 abfd->lru_next = bfd_last_cache; 97 abfd->lru_prev = bfd_last_cache->lru_prev; 98 abfd->lru_prev->lru_next = abfd; 99 abfd->lru_next->lru_prev = abfd; 100 } 101 bfd_last_cache = abfd; 102 } 103 104 /* Remove a BFD from the cache. */ 105 106 static void 107 snip (bfd *abfd) 108 { 109 abfd->lru_prev->lru_next = abfd->lru_next; 110 abfd->lru_next->lru_prev = abfd->lru_prev; 111 if (abfd == bfd_last_cache) 112 { 113 bfd_last_cache = abfd->lru_next; 114 if (abfd == bfd_last_cache) 115 bfd_last_cache = NULL; 116 } 117 } 118 119 /* Close a BFD and remove it from the cache. */ 120 121 static bfd_boolean 122 bfd_cache_delete (bfd *abfd) 123 { 124 bfd_boolean ret; 125 126 if (fclose ((FILE *) abfd->iostream) == 0) 127 ret = TRUE; 128 else 129 { 130 ret = FALSE; 131 bfd_set_error (bfd_error_system_call); 132 } 133 134 snip (abfd); 135 136 abfd->iostream = NULL; 137 --open_files; 138 139 return ret; 140 } 141 142 /* We need to open a new file, and the cache is full. Find the least 143 recently used cacheable BFD and close it. */ 144 145 static bfd_boolean 146 close_one (void) 147 { 148 register bfd *to_kill; 149 150 if (bfd_last_cache == NULL) 151 to_kill = NULL; 152 else 153 { 154 for (to_kill = bfd_last_cache->lru_prev; 155 ! to_kill->cacheable; 156 to_kill = to_kill->lru_prev) 157 { 158 if (to_kill == bfd_last_cache) 159 { 160 to_kill = NULL; 161 break; 162 } 163 } 164 } 165 166 if (to_kill == NULL) 167 { 168 /* There are no open cacheable BFD's. */ 169 return TRUE; 170 } 171 172 to_kill->where = real_ftell ((FILE *) to_kill->iostream); 173 174 return bfd_cache_delete (to_kill); 175 } 176 177 /* Check to see if the required BFD is the same as the last one 178 looked up. If so, then it can use the stream in the BFD with 179 impunity, since it can't have changed since the last lookup; 180 otherwise, it has to perform the complicated lookup function. */ 181 182 #define bfd_cache_lookup(x, flag) \ 183 ((x) == bfd_last_cache \ 184 ? (FILE *) (bfd_last_cache->iostream) \ 185 : bfd_cache_lookup_worker (x, flag)) 186 187 /* Called when the macro <<bfd_cache_lookup>> fails to find a 188 quick answer. Find a file descriptor for @var{abfd}. If 189 necessary, it open it. If there are already more than 190 <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to 191 avoid running out of file descriptors. It will return NULL 192 if it is unable to (re)open the @var{abfd}. */ 193 194 static FILE * 195 bfd_cache_lookup_worker (bfd *abfd, enum cache_flag flag) 196 { 197 bfd *orig_bfd = abfd; 198 if ((abfd->flags & BFD_IN_MEMORY) != 0) 199 abort (); 200 201 while (abfd->my_archive) 202 abfd = abfd->my_archive; 203 204 if (abfd->iostream != NULL) 205 { 206 /* Move the file to the start of the cache. */ 207 if (abfd != bfd_last_cache) 208 { 209 snip (abfd); 210 insert (abfd); 211 } 212 return (FILE *) abfd->iostream; 213 } 214 215 if (flag & CACHE_NO_OPEN) 216 return NULL; 217 218 if (bfd_open_file (abfd) == NULL) 219 ; 220 else if (!(flag & CACHE_NO_SEEK) 221 && real_fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0 222 && !(flag & CACHE_NO_SEEK_ERROR)) 223 bfd_set_error (bfd_error_system_call); 224 else 225 return (FILE *) abfd->iostream; 226 227 (*_bfd_error_handler) (_("reopening %B: %s\n"), 228 orig_bfd, bfd_errmsg (bfd_get_error ())); 229 return NULL; 230 } 231 232 static file_ptr 233 cache_btell (struct bfd *abfd) 234 { 235 FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN); 236 if (f == NULL) 237 return abfd->where; 238 return real_ftell (f); 239 } 240 241 static int 242 cache_bseek (struct bfd *abfd, file_ptr offset, int whence) 243 { 244 FILE *f = bfd_cache_lookup (abfd, whence != SEEK_CUR ? CACHE_NO_SEEK : CACHE_NORMAL); 245 if (f == NULL) 246 return -1; 247 return real_fseek (f, offset, whence); 248 } 249 250 /* Note that archive entries don't have streams; they share their parent's. 251 This allows someone to play with the iostream behind BFD's back. 252 253 Also, note that the origin pointer points to the beginning of a file's 254 contents (0 for non-archive elements). For archive entries this is the 255 first octet in the file, NOT the beginning of the archive header. */ 256 257 static file_ptr 258 cache_bread_1 (struct bfd *abfd, void *buf, file_ptr nbytes) 259 { 260 FILE *f; 261 file_ptr nread; 262 /* FIXME - this looks like an optimization, but it's really to cover 263 up for a feature of some OSs (not solaris - sigh) that 264 ld/pe-dll.c takes advantage of (apparently) when it creates BFDs 265 internally and tries to link against them. BFD seems to be smart 266 enough to realize there are no symbol records in the "file" that 267 doesn't exist but attempts to read them anyway. On Solaris, 268 attempting to read zero bytes from a NULL file results in a core 269 dump, but on other platforms it just returns zero bytes read. 270 This makes it to something reasonable. - DJ */ 271 if (nbytes == 0) 272 return 0; 273 274 f = bfd_cache_lookup (abfd, CACHE_NORMAL); 275 if (f == NULL) 276 return 0; 277 278 #if defined (__VAX) && defined (VMS) 279 /* Apparently fread on Vax VMS does not keep the record length 280 information. */ 281 nread = read (fileno (f), buf, nbytes); 282 /* Set bfd_error if we did not read as much data as we expected. If 283 the read failed due to an error set the bfd_error_system_call, 284 else set bfd_error_file_truncated. */ 285 if (nread == (file_ptr)-1) 286 { 287 bfd_set_error (bfd_error_system_call); 288 return -1; 289 } 290 #else 291 nread = fread (buf, 1, nbytes, f); 292 /* Set bfd_error if we did not read as much data as we expected. If 293 the read failed due to an error set the bfd_error_system_call, 294 else set bfd_error_file_truncated. */ 295 if (nread < nbytes && ferror (f)) 296 { 297 bfd_set_error (bfd_error_system_call); 298 return -1; 299 } 300 #endif 301 if (nread < nbytes) 302 /* This may or may not be an error, but in case the calling code 303 bails out because of it, set the right error code. */ 304 bfd_set_error (bfd_error_file_truncated); 305 return nread; 306 } 307 308 static file_ptr 309 cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes) 310 { 311 file_ptr nread = 0; 312 313 /* Some filesystems are unable to handle reads that are too large 314 (for instance, NetApp shares with oplocks turned off). To avoid 315 hitting this limitation, we read the buffer in chunks of 8MB max. */ 316 while (nread < nbytes) 317 { 318 const file_ptr max_chunk_size = 0x800000; 319 file_ptr chunk_size = nbytes - nread; 320 file_ptr chunk_nread; 321 322 if (chunk_size > max_chunk_size) 323 chunk_size = max_chunk_size; 324 325 chunk_nread = cache_bread_1 (abfd, (char *) buf + nread, chunk_size); 326 327 /* Update the nread count. 328 329 We just have to be careful of the case when cache_bread_1 returns 330 a negative count: If this is our first read, then set nread to 331 that negative count in order to return that negative value to the 332 caller. Otherwise, don't add it to our total count, or we would 333 end up returning a smaller number of bytes read than we actually 334 did. */ 335 if (nread == 0 || chunk_nread > 0) 336 nread += chunk_nread; 337 338 if (chunk_nread < chunk_size) 339 break; 340 } 341 342 return nread; 343 } 344 345 static file_ptr 346 cache_bwrite (struct bfd *abfd, const void *where, file_ptr nbytes) 347 { 348 file_ptr nwrite; 349 FILE *f = bfd_cache_lookup (abfd, CACHE_NORMAL); 350 351 if (f == NULL) 352 return 0; 353 nwrite = fwrite (where, 1, nbytes, f); 354 if (nwrite < nbytes && ferror (f)) 355 { 356 bfd_set_error (bfd_error_system_call); 357 return -1; 358 } 359 return nwrite; 360 } 361 362 static int 363 cache_bclose (struct bfd *abfd) 364 { 365 return bfd_cache_close (abfd) - 1; 366 } 367 368 static int 369 cache_bflush (struct bfd *abfd) 370 { 371 int sts; 372 FILE *f = bfd_cache_lookup (abfd, CACHE_NO_OPEN); 373 374 if (f == NULL) 375 return 0; 376 sts = fflush (f); 377 if (sts < 0) 378 bfd_set_error (bfd_error_system_call); 379 return sts; 380 } 381 382 static int 383 cache_bstat (struct bfd *abfd, struct stat *sb) 384 { 385 int sts; 386 FILE *f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR); 387 388 if (f == NULL) 389 return -1; 390 sts = fstat (fileno (f), sb); 391 if (sts < 0) 392 bfd_set_error (bfd_error_system_call); 393 return sts; 394 } 395 396 static void * 397 cache_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED, 398 void *addr ATTRIBUTE_UNUSED, 399 bfd_size_type len ATTRIBUTE_UNUSED, 400 int prot ATTRIBUTE_UNUSED, 401 int flags ATTRIBUTE_UNUSED, 402 file_ptr offset ATTRIBUTE_UNUSED, 403 void **map_addr ATTRIBUTE_UNUSED, 404 bfd_size_type *map_len ATTRIBUTE_UNUSED) 405 { 406 void *ret = (void *) -1; 407 408 if ((abfd->flags & BFD_IN_MEMORY) != 0) 409 abort (); 410 #ifdef HAVE_MMAP 411 else 412 { 413 static uintptr_t pagesize_m1; 414 FILE *f; 415 file_ptr pg_offset; 416 bfd_size_type pg_len; 417 418 f = bfd_cache_lookup (abfd, CACHE_NO_SEEK_ERROR); 419 if (f == NULL) 420 return ret; 421 422 if (pagesize_m1 == 0) 423 pagesize_m1 = getpagesize () - 1; 424 425 /* Handle archive members. */ 426 if (abfd->my_archive != NULL) 427 offset += abfd->origin; 428 429 /* Align. */ 430 pg_offset = offset & ~pagesize_m1; 431 pg_len = (len + (offset - pg_offset) + pagesize_m1) & ~pagesize_m1; 432 433 ret = mmap (addr, pg_len, prot, flags, fileno (f), pg_offset); 434 if (ret == (void *) -1) 435 bfd_set_error (bfd_error_system_call); 436 else 437 { 438 *map_addr = ret; 439 *map_len = pg_len; 440 ret = (char *) ret + (offset & pagesize_m1); 441 } 442 } 443 #endif 444 445 return ret; 446 } 447 448 static const struct bfd_iovec cache_iovec = 449 { 450 &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek, 451 &cache_bclose, &cache_bflush, &cache_bstat, &cache_bmmap 452 }; 453 454 /* 455 INTERNAL_FUNCTION 456 bfd_cache_init 457 458 SYNOPSIS 459 bfd_boolean bfd_cache_init (bfd *abfd); 460 461 DESCRIPTION 462 Add a newly opened BFD to the cache. 463 */ 464 465 bfd_boolean 466 bfd_cache_init (bfd *abfd) 467 { 468 BFD_ASSERT (abfd->iostream != NULL); 469 if (open_files >= BFD_CACHE_MAX_OPEN) 470 { 471 if (! close_one ()) 472 return FALSE; 473 } 474 abfd->iovec = &cache_iovec; 475 insert (abfd); 476 ++open_files; 477 return TRUE; 478 } 479 480 /* 481 INTERNAL_FUNCTION 482 bfd_cache_close 483 484 SYNOPSIS 485 bfd_boolean bfd_cache_close (bfd *abfd); 486 487 DESCRIPTION 488 Remove the BFD @var{abfd} from the cache. If the attached file is open, 489 then close it too. 490 491 RETURNS 492 <<FALSE>> is returned if closing the file fails, <<TRUE>> is 493 returned if all is well. 494 */ 495 496 bfd_boolean 497 bfd_cache_close (bfd *abfd) 498 { 499 if (abfd->iovec != &cache_iovec) 500 return TRUE; 501 502 if (abfd->iostream == NULL) 503 /* Previously closed. */ 504 return TRUE; 505 506 return bfd_cache_delete (abfd); 507 } 508 509 /* 510 FUNCTION 511 bfd_cache_close_all 512 513 SYNOPSIS 514 bfd_boolean bfd_cache_close_all (void); 515 516 DESCRIPTION 517 Remove all BFDs from the cache. If the attached file is open, 518 then close it too. 519 520 RETURNS 521 <<FALSE>> is returned if closing one of the file fails, <<TRUE>> is 522 returned if all is well. 523 */ 524 525 bfd_boolean 526 bfd_cache_close_all () 527 { 528 bfd_boolean ret = TRUE; 529 530 while (bfd_last_cache != NULL) 531 ret &= bfd_cache_close (bfd_last_cache); 532 533 return ret; 534 } 535 536 /* 537 INTERNAL_FUNCTION 538 bfd_open_file 539 540 SYNOPSIS 541 FILE* bfd_open_file (bfd *abfd); 542 543 DESCRIPTION 544 Call the OS to open a file for @var{abfd}. Return the <<FILE *>> 545 (possibly <<NULL>>) that results from this operation. Set up the 546 BFD so that future accesses know the file is open. If the <<FILE *>> 547 returned is <<NULL>>, then it won't have been put in the 548 cache, so it won't have to be removed from it. 549 */ 550 551 FILE * 552 bfd_open_file (bfd *abfd) 553 { 554 abfd->cacheable = TRUE; /* Allow it to be closed later. */ 555 556 if (open_files >= BFD_CACHE_MAX_OPEN) 557 { 558 if (! close_one ()) 559 return NULL; 560 } 561 562 switch (abfd->direction) 563 { 564 case read_direction: 565 case no_direction: 566 abfd->iostream = real_fopen (abfd->filename, FOPEN_RB); 567 break; 568 case both_direction: 569 case write_direction: 570 if (abfd->opened_once) 571 { 572 abfd->iostream = real_fopen (abfd->filename, FOPEN_RUB); 573 if (abfd->iostream == NULL) 574 abfd->iostream = real_fopen (abfd->filename, FOPEN_WUB); 575 } 576 else 577 { 578 /* Create the file. 579 580 Some operating systems won't let us overwrite a running 581 binary. For them, we want to unlink the file first. 582 583 However, gcc 2.95 will create temporary files using 584 O_EXCL and tight permissions to prevent other users from 585 substituting other .o files during the compilation. gcc 586 will then tell the assembler to use the newly created 587 file as an output file. If we unlink the file here, we 588 open a brief window when another user could still 589 substitute a file. 590 591 So we unlink the output file if and only if it has 592 non-zero size. */ 593 #ifndef __MSDOS__ 594 /* Don't do this for MSDOS: it doesn't care about overwriting 595 a running binary, but if this file is already open by 596 another BFD, we will be in deep trouble if we delete an 597 open file. In fact, objdump does just that if invoked with 598 the --info option. */ 599 struct stat s; 600 601 if (stat (abfd->filename, &s) == 0 && s.st_size != 0) 602 unlink_if_ordinary (abfd->filename); 603 #endif 604 abfd->iostream = real_fopen (abfd->filename, FOPEN_WUB); 605 abfd->opened_once = TRUE; 606 } 607 break; 608 } 609 610 if (abfd->iostream == NULL) 611 bfd_set_error (bfd_error_system_call); 612 else 613 { 614 if (! bfd_cache_init (abfd)) 615 return NULL; 616 } 617 618 return (FILE *) abfd->iostream; 619 } 620