[deliverable/binutils-gdb.git] / bfd / bfdwin.c

/* Support for memory-mapped windows into a BFD.
   Copyright 1995, 1996, 2001, 2002, 2003, 2005
   Free Software Foundation, Inc.
   Written by Cygnus Support.

This file is part of BFD, the Binary File Descriptor library.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

#include "sysdep.h"

#include "bfd.h"
#include "libbfd.h"

/* Currently, if USE_MMAP is undefined, none if the window stuff is
   used.  Okay, so it's mis-named.  At least the command-line option
   "--without-mmap" is more obvious than "--without-windows" or some
   such.  */

#ifdef USE_MMAP

#undef HAVE_MPROTECT /* code's not tested yet */

#if HAVE_MMAP || HAVE_MPROTECT || HAVE_MADVISE
#include <sys/mman.h>
#endif

#ifndef MAP_FILE
#define MAP_FILE 0
#endif

static int debug_windows;

/* The idea behind the next and refcount fields is that one mapped
   region can suffice for multiple read-only windows or multiple
   non-overlapping read-write windows.  It's not implemented yet
   though.  */

/*
INTERNAL_DEFINITION

.struct _bfd_window_internal {
.  struct _bfd_window_internal *next;
.  void *data;
.  bfd_size_type size;
.  int refcount : 31;		{* should be enough...  *}
.  unsigned mapped : 1;		{* 1 = mmap, 0 = malloc *}
.};
*/

void
bfd_init_window (bfd_window *windowp)
{
  windowp->data = 0;
  windowp->i = 0;
  windowp->size = 0;
}

void
bfd_free_window (bfd_window *windowp)
{
  bfd_window_internal *i = windowp->i;
  windowp->i = 0;
  windowp->data = 0;
  if (i == 0)
    return;
  i->refcount--;
  if (debug_windows)
    fprintf (stderr, "freeing window @%p<%p,%lx,%p>\n",
	     windowp, windowp->data, windowp->size, windowp->i);
  if (i->refcount != 0)
    return;

  if (i->mapped)
    {
#ifdef HAVE_MMAP
      munmap (i->data, i->size);
      goto no_free;
#else
      abort ();
#endif
    }
#ifdef HAVE_MPROTECT
  mprotect (i->data, i->size, PROT_READ | PROT_WRITE);
#endif
  free (i->data);
#ifdef HAVE_MMAP
 no_free:
#endif
  i->data = 0;
  /* There should be no more references to i at this point.  */
  free (i);
}

static int ok_to_map = 1;

bfd_boolean
bfd_get_file_window (bfd *abfd,
		     file_ptr offset,
		     bfd_size_type size,
		     bfd_window *windowp,
		     bfd_boolean writable)
{
  static size_t pagesize;
  bfd_window_internal *i = windowp->i;
  bfd_size_type size_to_alloc = size;

  if (debug_windows)
    fprintf (stderr, "bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)",
	     abfd, (long) offset, (long) size,
	     windowp, windowp->data, (unsigned long) windowp->size,
	     windowp->i, writable);

  /* Make sure we know the page size, so we can be friendly to mmap.  */
  if (pagesize == 0)
    pagesize = getpagesize ();
  if (pagesize == 0)
    abort ();

  if (i == 0)
    {
      i = bfd_zmalloc (sizeof (bfd_window_internal));
      windowp->i = i;
      if (i == 0)
	return FALSE;
      i->data = 0;
    }
#ifdef HAVE_MMAP
  if (ok_to_map
      && (i->data == 0 || i->mapped == 1)
      && (abfd->flags & BFD_IN_MEMORY) == 0)
    {
      file_ptr file_offset, offset2;
      size_t real_size;
      int fd;

      /* Find the real file and the real offset into it.  */
      while (abfd->my_archive != NULL)
	{
	  offset += abfd->origin;
	  abfd = abfd->my_archive;
	}

      /* Seek into the file, to ensure it is open if cacheable.  */
      if (abfd->iostream == NULL
	  && (abfd->iovec == NULL
	      || abfd->iovec->bseek (abfd, offset, SEEK_SET) != 0))
	return FALSE;
      fd = fileno ((FILE *) abfd->iostream);

      /* Compute offsets and size for mmap and for the user's data.  */
      offset2 = offset % pagesize;
      if (offset2 < 0)
	abort ();
      file_offset = offset - offset2;
      real_size = offset + size - file_offset;
      real_size = real_size + pagesize - 1;
      real_size -= real_size % pagesize;

      /* If we're re-using a memory region, make sure it's big enough.  */
      if (i->data && i->size < size)
	{
	  munmap (i->data, i->size);
	  i->data = 0;
	}
      i->data = mmap (i->data, real_size,
		      writable ? PROT_WRITE | PROT_READ : PROT_READ,
		      (writable
		       ? MAP_FILE | MAP_PRIVATE
		       : MAP_FILE | MAP_SHARED),
		      fd, file_offset);
      if (i->data == (void *) -1)
	{
	  /* An error happened.  Report it, or try using malloc, or
	     something.  */
	  bfd_set_error (bfd_error_system_call);
	  i->data = 0;
	  windowp->data = 0;
	  if (debug_windows)
	    fprintf (stderr, "\t\tmmap failed!\n");
	  return FALSE;
	}
      if (debug_windows)
	fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n",
		 (long) real_size, i->data, (long) offset2);
      i->size = real_size;
      windowp->data = (bfd_byte *) i->data + offset2;
      windowp->size = size;
      i->mapped = 1;
      return TRUE;
    }
  else if (debug_windows)
    {
      if (ok_to_map)
	fprintf (stderr, _("not mapping: data=%lx mapped=%d\n"),
		 (unsigned long) i->data, (int) i->mapped);
      else
	fprintf (stderr, _("not mapping: env var not set\n"));
    }
#else
  ok_to_map = 0;
#endif

#ifdef HAVE_MPROTECT
  if (!writable)
    {
      size_to_alloc += pagesize - 1;
      size_to_alloc -= size_to_alloc % pagesize;
    }
#endif
  if (debug_windows)
    fprintf (stderr, "\n\t%s(%6ld)",
	     i->data ? "realloc" : " malloc", (long) size_to_alloc);
  i->data = bfd_realloc (i->data, size_to_alloc);
  if (debug_windows)
    fprintf (stderr, "\t-> %p\n", i->data);
  i->refcount = 1;
  if (i->data == NULL)
    {
      if (size_to_alloc == 0)
	return TRUE;
      return FALSE;
    }
  if (bfd_seek (abfd, offset, SEEK_SET) != 0)
    return FALSE;
  i->size = bfd_bread (i->data, size, abfd);
  if (i->size != size)
    return FALSE;
  i->mapped = 0;
#ifdef HAVE_MPROTECT
  if (!writable)
    {
      if (debug_windows)
	fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data,
		 (long) i->size);
      mprotect (i->data, i->size, PROT_READ);
    }
#endif
  windowp->data = i->data;
  windowp->size = i->size;
  return TRUE;
}

#endif /* USE_MMAP */
Commit	Line	Data
93509525	1	/* Support for memory-mapped windows into a BFD.
182a0099 AM	2	Copyright 1995, 1996, 2001, 2002, 2003, 2005
182a0099 AM	3	Free Software Foundation, Inc.
93509525 KD	4	Written by Cygnus Support.
	5
	6	This file is part of BFD, the Binary File Descriptor library.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
3e110533	20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
93509525 KD	21
	22	#include "sysdep.h"
	23
	24	#include "bfd.h"
	25	#include "libbfd.h"
	26
	27	/* Currently, if USE_MMAP is undefined, none if the window stuff is
	28	used. Okay, so it's mis-named. At least the command-line option
	29	"--without-mmap" is more obvious than "--without-windows" or some
	30	such. */
	31
	32	#ifdef USE_MMAP
	33
	34	#undef HAVE_MPROTECT /* code's not tested yet */
	35
	36	#if HAVE_MMAP \|\| HAVE_MPROTECT \|\| HAVE_MADVISE
	37	#include <sys/mman.h>
	38	#endif
	39
	40	#ifndef MAP_FILE
	41	#define MAP_FILE 0
	42	#endif
	43
	44	static int debug_windows;
	45
	46	/* The idea behind the next and refcount fields is that one mapped
	47	region can suffice for multiple read-only windows or multiple
	48	non-overlapping read-write windows. It's not implemented yet
	49	though. */
	50
	51	/*
	52	INTERNAL_DEFINITION
	53
	54	.struct _bfd_window_internal {
	55	. struct _bfd_window_internal *next;
c58b9523	56	. void *data;
93509525 KD	57	. bfd_size_type size;
	58	. int refcount : 31; {* should be enough... *}
	59	. unsigned mapped : 1; {* 1 = mmap, 0 = malloc *}
	60	.};
	61	*/
	62
	63	void
c58b9523	64	bfd_init_window (bfd_window *windowp)
93509525 KD	65	{
	66	windowp->data = 0;
	67	windowp->i = 0;
	68	windowp->size = 0;
	69	}
	70
	71	void
c58b9523	72	bfd_free_window (bfd_window *windowp)
93509525 KD	73	{
	74	bfd_window_internal *i = windowp->i;
	75	windowp->i = 0;
	76	windowp->data = 0;
	77	if (i == 0)
	78	return;
	79	i->refcount--;
	80	if (debug_windows)
	81	fprintf (stderr, "freeing window @%p<%p,%lx,%p>\n",
	82	windowp, windowp->data, windowp->size, windowp->i);
	83	if (i->refcount != 0)
	84	return;
	85
	86	if (i->mapped)
	87	{
	88	#ifdef HAVE_MMAP
	89	munmap (i->data, i->size);
	90	goto no_free;
	91	#else
	92	abort ();
	93	#endif
	94	}
	95	#ifdef HAVE_MPROTECT
	96	mprotect (i->data, i->size, PROT_READ \| PROT_WRITE);
	97	#endif
	98	free (i->data);
	99	#ifdef HAVE_MMAP
	100	no_free:
	101	#endif
	102	i->data = 0;
	103	/* There should be no more references to i at this point. */
	104	free (i);
	105	}
	106
	107	static int ok_to_map = 1;
	108
b34976b6	109	bfd_boolean
c58b9523 AM	110	bfd_get_file_window (bfd *abfd,
	111	file_ptr offset,
	112	bfd_size_type size,
	113	bfd_window *windowp,
	114	bfd_boolean writable)
93509525 KD	115	{
	116	static size_t pagesize;
	117	bfd_window_internal *i = windowp->i;
	118	bfd_size_type size_to_alloc = size;
	119
	120	if (debug_windows)
	121	fprintf (stderr, "bfd_get_file_window (%p, %6ld, %6ld, %p<%p,%lx,%p>, %d)",
	122	abfd, (long) offset, (long) size,
	123	windowp, windowp->data, (unsigned long) windowp->size,
	124	windowp->i, writable);
	125
	126	/* Make sure we know the page size, so we can be friendly to mmap. */
	127	if (pagesize == 0)
	128	pagesize = getpagesize ();
	129	if (pagesize == 0)
	130	abort ();
	131
	132	if (i == 0)
	133	{
c58b9523	134	i = bfd_zmalloc (sizeof (bfd_window_internal));
93509525 KD	135	windowp->i = i;
93509525 KD	136	if (i == 0)
b34976b6	137	return FALSE;
93509525 KD	138	i->data = 0;
	139	}
	140	#ifdef HAVE_MMAP
	141	if (ok_to_map
	142	&& (i->data == 0 \|\| i->mapped == 1)
	143	&& (abfd->flags & BFD_IN_MEMORY) == 0)
	144	{
	145	file_ptr file_offset, offset2;
	146	size_t real_size;
	147	int fd;
93509525 KD	148
	149	/* Find the real file and the real offset into it. */
	150	while (abfd->my_archive != NULL)
	151	{
	152	offset += abfd->origin;
	153	abfd = abfd->my_archive;
	154	}
182a0099 AM	155
	156	/* Seek into the file, to ensure it is open if cacheable. */
	157	if (abfd->iostream == NULL
	158	&& (abfd->iovec == NULL
	159	\|\| abfd->iovec->bseek (abfd, offset, SEEK_SET) != 0))
3dff57e8	160	return FALSE;
182a0099	161	fd = fileno ((FILE *) abfd->iostream);
93509525 KD	162
	163	/* Compute offsets and size for mmap and for the user's data. */
	164	offset2 = offset % pagesize;
	165	if (offset2 < 0)
	166	abort ();
	167	file_offset = offset - offset2;
	168	real_size = offset + size - file_offset;
	169	real_size = real_size + pagesize - 1;
	170	real_size -= real_size % pagesize;
	171
	172	/* If we're re-using a memory region, make sure it's big enough. */
	173	if (i->data && i->size < size)
	174	{
	175	munmap (i->data, i->size);
	176	i->data = 0;
	177	}
	178	i->data = mmap (i->data, real_size,
	179	writable ? PROT_WRITE \| PROT_READ : PROT_READ,
	180	(writable
	181	? MAP_FILE \| MAP_PRIVATE
	182	: MAP_FILE \| MAP_SHARED),
	183	fd, file_offset);
c58b9523	184	if (i->data == (void *) -1)
93509525 KD	185	{
	186	/* An error happened. Report it, or try using malloc, or
	187	something. */
	188	bfd_set_error (bfd_error_system_call);
	189	i->data = 0;
	190	windowp->data = 0;
	191	if (debug_windows)
	192	fprintf (stderr, "\t\tmmap failed!\n");
b34976b6	193	return FALSE;
93509525 KD	194	}
	195	if (debug_windows)
	196	fprintf (stderr, "\n\tmapped %ld at %p, offset is %ld\n",
	197	(long) real_size, i->data, (long) offset2);
	198	i->size = real_size;
c58b9523	199	windowp->data = (bfd_byte *) i->data + offset2;
93509525 KD	200	windowp->size = size;
93509525 KD	201	i->mapped = 1;
b34976b6	202	return TRUE;
93509525 KD	203	}
	204	else if (debug_windows)
	205	{
	206	if (ok_to_map)
	207	fprintf (stderr, _("not mapping: data=%lx mapped=%d\n"),
	208	(unsigned long) i->data, (int) i->mapped);
	209	else
	210	fprintf (stderr, _("not mapping: env var not set\n"));
	211	}
	212	#else
	213	ok_to_map = 0;
	214	#endif
	215
	216	#ifdef HAVE_MPROTECT
	217	if (!writable)
	218	{
	219	size_to_alloc += pagesize - 1;
	220	size_to_alloc -= size_to_alloc % pagesize;
	221	}
	222	#endif
	223	if (debug_windows)
	224	fprintf (stderr, "\n\t%s(%6ld)",
	225	i->data ? "realloc" : " malloc", (long) size_to_alloc);
c58b9523	226	i->data = bfd_realloc (i->data, size_to_alloc);
93509525 KD	227	if (debug_windows)
	228	fprintf (stderr, "\t-> %p\n", i->data);
	229	i->refcount = 1;
	230	if (i->data == NULL)
	231	{
	232	if (size_to_alloc == 0)
b34976b6 AM	233	return TRUE;
b34976b6 AM	234	return FALSE;
93509525 KD	235	}
93509525 KD	236	if (bfd_seek (abfd, offset, SEEK_SET) != 0)
b34976b6	237	return FALSE;
93509525 KD	238	i->size = bfd_bread (i->data, size, abfd);
93509525 KD	239	if (i->size != size)
b34976b6	240	return FALSE;
93509525 KD	241	i->mapped = 0;
	242	#ifdef HAVE_MPROTECT
	243	if (!writable)
	244	{
	245	if (debug_windows)
	246	fprintf (stderr, "\tmprotect (%p, %ld, PROT_READ)\n", i->data,
	247	(long) i->size);
	248	mprotect (i->data, i->size, PROT_READ);
	249	}
	250	#endif
	251	windowp->data = i->data;
	252	windowp->size = i->size;
b34976b6	253	return TRUE;
93509525 KD	254	}
	255
	256	#endif /* USE_MMAP */