OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [cache.c] - Blame information for rev 165

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* 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 161 khays
#include "bfd_stdint.h"
49 14 khays
 
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
  if (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);
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 161 khays
             file_ptr offset ATTRIBUTE_UNUSED,
403
             void **map_addr ATTRIBUTE_UNUSED,
404
             bfd_size_type *map_len ATTRIBUTE_UNUSED)
405 14 khays
{
406
  void *ret = (void *) -1;
407
 
408
  if ((abfd->flags & BFD_IN_MEMORY) != 0)
409
    abort ();
410
#ifdef HAVE_MMAP
411
  else
412
    {
413 161 khays
      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 14 khays
      if (f == NULL)
420
        return ret;
421
 
422 161 khays
      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 14 khays
      if (ret == (void *) -1)
435
        bfd_set_error (bfd_error_system_call);
436 161 khays
      else
437
        {
438
          *map_addr = ret;
439
          *map_len = pg_len;
440
          ret += offset & pagesize_m1;
441
        }
442 14 khays
    }
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 = (PTR) 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 = (PTR) real_fopen (abfd->filename, FOPEN_RUB);
573
          if (abfd->iostream == NULL)
574
            abfd->iostream = (PTR) 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 = (PTR) 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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.