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