Attachment #351858 for bug #471020

Lines 84-89 struct locarhandle Link Here

(-)a/locale/locarchive.h (+7 lines)
84	void *addr;	84	void *addr;
85	size_t mmaped;	85	size_t mmaped;
86	size_t reserved;	86	size_t reserved;
		87	/* If this mmap required adjustment (such as re-aligning), then this is the
		88	real address that was returned from mmap and thus should be passed to the
		89	munmap call. The addr field above is the first usable address. */
		90	void *mmap_base;
		91	/* Same as above for mmap_base vs addr, but this is the real length of the
		92	map rather than the usable (which is what reserved represents). */
		93	size_t mmap_len;
87	};	94	};
88		95
89		96




#include <stdint.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <sys/shm.h>
#include <sys/stat.h>

#include <libc-mmap.h>
#include "../../crypt/md5.h"
#include "../localeinfo.h"
#include "../locarchive.h"

   mapping affects the address selection.  So do this mapping from the
   actual file, even though it's only a dummy to reserve address space.  */
static void *
prepare_address_space (int fd, size_t total, size_t *reserved, int *xflags,
		       void **mmap_base, size_t *mmap_len)
{
  if (total < RESERVE_MMAP_SIZE)
    {
      void *p = mmap64 (NULL, RESERVE_MMAP_SIZE, PROT_NONE, MAP_SHARED, fd, 0);
      if (p != MAP_FAILED)
	{
	  void *aligned_p = PTR_ALIGN_UP (p, MAP_FIXED_ALIGNMENT);
	  size_t align_adjust = aligned_p - p;
	  *mmap_base = p;
	  *mmap_len = RESERVE_MMAP_SIZE;
	  assert (align_adjust < RESERVE_MMAP_SIZE);
	  *reserved = RESERVE_MMAP_SIZE - align_adjust;
	  *xflags = MAP_FIXED;
	  return aligned_p;
	}
    }

  *reserved = total;
  *xflags = 0;
  *mmap_base = NULL;
  *mmap_len = 0;
  return NULL;
}


      error (EXIT_FAILURE, errval, _("cannot resize archive file"));
    }

  size_t reserved, mmap_len;
  int xflags;
  void *mmap_base;
  void *p = prepare_address_space (fd, total, &reserved, &xflags, &mmap_base,
				   &mmap_len);

  /* Map the header and all the administration data structures.  */
  p = mmap64 (p, total, PROT_READ | PROT_WRITE, MAP_SHARED | xflags, fd, 0);

    }

  ah->fd = fd;
  ah->mmap_base = mmap_base;
  ah->mmap_len = mmap_len;
  ah->addr = p;
  ah->mmaped = total;
  ah->reserved = reserved;

  if (st.st_size > ah->reserved)
    return false;

  size_t start = ALIGN_DOWN (ah->mmaped, MAP_FIXED_ALIGNMENT);
  size_t start = ah->mmaped & ~(pagesz - 1);
  void *p = mmap64 (ah->addr + start, st.st_size - start,
		    PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED,
		    ah->fd, start);

		       MAP_SHARED | MAP_FIXED, ah->fd, 0);
  else
    {
      if (ah->mmap_base)
	munmap (ah->mmap_base, ah->mmap_len);
      else
	munmap (ah->addr, ah->reserved);
      ah->addr = mmap64 (NULL, st.st_size, PROT_READ | PROT_WRITE,
			 MAP_SHARED, ah->fd, 0);
      ah->reserved = st.st_size;
      ah->mmap_base = NULL;
      ah->mmap_len = 0;
      head = ah->addr;
    }
  if (ah->addr == MAP_FAILED)

      error (EXIT_FAILURE, errval, _("cannot resize archive file"));
    }

  size_t reserved, mmap_len;
  int xflags;
  void *mmap_base;
  void *p = prepare_address_space (fd, total, &reserved, &xflags, &mmap_base,
				   &mmap_len);

  /* Map the header and all the administration data structures.  */
  p = mmap64 (p, total, PROT_READ | PROT_WRITE, MAP_SHARED | xflags, fd, 0);

    }

  new_ah.mmaped = total;
  new_ah.mmap_base = mmap_base;
  new_ah.mmap_len = mmap_len;
  new_ah.addr = p;
  new_ah.fd = fd;
  new_ah.reserved = reserved;

  ah->fd = fd;
  ah->mmaped = st.st_size;

  size_t reserved, mmap_len;
  int xflags;
  void *mmap_base;
  void *p = prepare_address_space (fd, st.st_size, &reserved, &xflags,
				   &mmap_base, &mmap_len);

  /* Map the entire file.  We might need to compare the category data
     in the file with the newly added data.  */

      error (EXIT_FAILURE, errno, _("cannot map archive header"));
    }
  ah->reserved = reserved;
  ah->mmap_base = mmap_base;
  ah->mmap_len = mmap_len;
}



{
  if (ah->fd != -1)
    {
      if (ah->mmap_base)
	munmap (ah->mmap_base, ah->mmap_len);
      else
	munmap (ah->addr, ah->reserved);
      close (ah->fd);
    }
}




/* Internal logic for dealing with mmap quirks.
   Copyright (C) 2013 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

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

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#ifndef _LIBC_MMAP_H
#define _LIBC_MMAP_H 1

/* Using MAP_FIXED with mmap sometimes requires larger alignment.  */
#include <sys/shm.h>
#define MAP_FIXED_ALIGNMENT SHMLBA

#endif

Return to bug 471020

Lines 37-44 Link Here

(-)a/locale/programs/locarchive.c (-16 / +45 lines)
37	#include <stdint.h>	37	#include <stdint.h>
38	#include <sys/mman.h>	38	#include <sys/mman.h>
39	#include <sys/param.h>	39	#include <sys/param.h>
		40	#include <sys/shm.h>
40	#include <sys/stat.h>	41	#include <sys/stat.h>
41		42
		43	#include <libc-mmap.h>
42	#include "../../crypt/md5.h"	44	#include "../../crypt/md5.h"
43	#include "../localeinfo.h"	45	#include "../localeinfo.h"
44	#include "../locarchive.h"	46	#include "../locarchive.h"
Lines 79-99 static const char *locnames[] = Link Here
79	mapping affects the address selection. So do this mapping from the	81	mapping affects the address selection. So do this mapping from the
80	actual file, even though it's only a dummy to reserve address space. */	82	actual file, even though it's only a dummy to reserve address space. */
81	static void *	83	static void *
82	prepare_address_space (int fd, size_t total, size_t reserved, int xflags)	84	prepare_address_space (int fd, size_t total, size_t reserved, int xflags,
		85	void *mmap_base, size_t mmap_len)
83	{	86	{
84	if (total < RESERVE_MMAP_SIZE)	87	if (total < RESERVE_MMAP_SIZE)
85	{	88	{
86	void *p = mmap64 (NULL, RESERVE_MMAP_SIZE, PROT_NONE, MAP_SHARED, fd, 0);	89	void *p = mmap64 (NULL, RESERVE_MMAP_SIZE, PROT_NONE, MAP_SHARED, fd, 0);
87	if (p != MAP_FAILED)	90	if (p != MAP_FAILED)
88	{	91	{
89	*reserved = RESERVE_MMAP_SIZE;	92	void *aligned_p = PTR_ALIGN_UP (p, MAP_FIXED_ALIGNMENT);
90	*xflags = MAP_FIXED;	93	size_t align_adjust = aligned_p - p;
91	return p;	94	*mmap_base = p;
92	}	95	*mmap_len = RESERVE_MMAP_SIZE;
		96	assert (align_adjust < RESERVE_MMAP_SIZE);
		97	*reserved = RESERVE_MMAP_SIZE - align_adjust;
		98	*xflags = MAP_FIXED;
		99	return aligned_p;
		100	}
93	}	101	}
94		102
95	*reserved = total;	103	*reserved = total;
96	*xflags = 0;	104	*xflags = 0;
		105	*mmap_base = NULL;
		106	*mmap_len = 0;
97	return NULL;	107	return NULL;
98	}	108	}
99		109
Lines 151-159 create_archive (const char archivefname, struct locarhandle ah) Link Here
151	error (EXIT_FAILURE, errval, _("cannot resize archive file"));	161	error (EXIT_FAILURE, errval, _("cannot resize archive file"));
152	}	162	}
153		163
154	size_t reserved;	164	size_t reserved, mmap_len;
155	int xflags;	165	int xflags;
156	void *p = prepare_address_space (fd, total, &reserved, &xflags);	166	void *mmap_base;
		167	void *p = prepare_address_space (fd, total, &reserved, &xflags, &mmap_base,
		168	&mmap_len);
157		169
158	/* Map the header and all the administration data structures. */	170	/* Map the header and all the administration data structures. */
159	p = mmap64 (p, total, PROT_READ \| PROT_WRITE, MAP_SHARED \| xflags, fd, 0);	171	p = mmap64 (p, total, PROT_READ \| PROT_WRITE, MAP_SHARED \| xflags, fd, 0);
Lines 199-204 create_archive (const char archivefname, struct locarhandle ah) Link Here
199	}	211	}
200		212
201	ah->fd = fd;	213	ah->fd = fd;
		214	ah->mmap_base = mmap_base;
		215	ah->mmap_len = mmap_len;
202	ah->addr = p;	216	ah->addr = p;
203	ah->mmaped = total;	217	ah->mmaped = total;
204	ah->reserved = reserved;	218	ah->reserved = reserved;
Lines 271-278 file_data_available_p (struct locarhandle *ah, uint32_t offset, uint32_t size) Link Here
271	if (st.st_size > ah->reserved)	285	if (st.st_size > ah->reserved)
272	return false;	286	return false;
273		287
274	const size_t pagesz = getpagesize ();	288	size_t start = ALIGN_DOWN (ah->mmaped, MAP_FIXED_ALIGNMENT);
275	size_t start = ah->mmaped & ~(pagesz - 1);
276	void *p = mmap64 (ah->addr + start, st.st_size - start,	289	void *p = mmap64 (ah->addr + start, st.st_size - start,
277	PROT_READ \| PROT_WRITE, MAP_SHARED \| MAP_FIXED,	290	PROT_READ \| PROT_WRITE, MAP_SHARED \| MAP_FIXED,
278	ah->fd, start);	291	ah->fd, start);
Lines 332-341 enlarge_archive (struct locarhandle ah, const struct locarhead head) Link Here
332	MAP_SHARED \| MAP_FIXED, ah->fd, 0);	345	MAP_SHARED \| MAP_FIXED, ah->fd, 0);
333	else	346	else
334	{	347	{
335	munmap (ah->addr, ah->reserved);	348	if (ah->mmap_base)
		349	munmap (ah->mmap_base, ah->mmap_len);
		350	else
		351	munmap (ah->addr, ah->reserved);
336	ah->addr = mmap64 (NULL, st.st_size, PROT_READ \| PROT_WRITE,	352	ah->addr = mmap64 (NULL, st.st_size, PROT_READ \| PROT_WRITE,
337	MAP_SHARED, ah->fd, 0);	353	MAP_SHARED, ah->fd, 0);
338	ah->reserved = st.st_size;	354	ah->reserved = st.st_size;
		355	ah->mmap_base = NULL;
		356	ah->mmap_len = 0;
339	head = ah->addr;	357	head = ah->addr;
340	}	358	}
341	if (ah->addr == MAP_FAILED)	359	if (ah->addr == MAP_FAILED)
Lines 401-409 enlarge_archive (struct locarhandle ah, const struct locarhead head) Link Here
401	error (EXIT_FAILURE, errval, _("cannot resize archive file"));	419	error (EXIT_FAILURE, errval, _("cannot resize archive file"));
402	}	420	}
403		421
404	size_t reserved;	422	size_t reserved, mmap_len;
405	int xflags;	423	int xflags;
406	void *p = prepare_address_space (fd, total, &reserved, &xflags);	424	void *mmap_base;
		425	void *p = prepare_address_space (fd, total, &reserved, &xflags, &mmap_base,
		426	&mmap_len);
407		427
408	/* Map the header and all the administration data structures. */	428	/* Map the header and all the administration data structures. */
409	p = mmap64 (p, total, PROT_READ \| PROT_WRITE, MAP_SHARED \| xflags, fd, 0);	429	p = mmap64 (p, total, PROT_READ \| PROT_WRITE, MAP_SHARED \| xflags, fd, 0);
Lines 423-428 enlarge_archive (struct locarhandle ah, const struct locarhead head) Link Here
423	}	443	}
424		444
425	new_ah.mmaped = total;	445	new_ah.mmaped = total;
		446	new_ah.mmap_base = mmap_base;
		447	new_ah.mmap_len = mmap_len;
426	new_ah.addr = p;	448	new_ah.addr = p;
427	new_ah.fd = fd;	449	new_ah.fd = fd;
428	new_ah.reserved = reserved;	450	new_ah.reserved = reserved;
Lines 606-614 open_archive (struct locarhandle *ah, bool readonly) Link Here
606	ah->fd = fd;	628	ah->fd = fd;
607	ah->mmaped = st.st_size;	629	ah->mmaped = st.st_size;
608		630
609	size_t reserved;	631	size_t reserved, mmap_len;
610	int xflags;	632	int xflags;
611	void *p = prepare_address_space (fd, st.st_size, &reserved, &xflags);	633	void *mmap_base;
		634	void *p = prepare_address_space (fd, st.st_size, &reserved, &xflags,
		635	&mmap_base, &mmap_len);
612		636
613	/* Map the entire file. We might need to compare the category data	637	/* Map the entire file. We might need to compare the category data
614	in the file with the newly added data. */	638	in the file with the newly added data. */
Lines 620-625 open_archive (struct locarhandle *ah, bool readonly) Link Here
620	error (EXIT_FAILURE, errno, _("cannot map archive header"));	644	error (EXIT_FAILURE, errno, _("cannot map archive header"));
621	}	645	}
622	ah->reserved = reserved;	646	ah->reserved = reserved;
		647	ah->mmap_base = mmap_base;
		648	ah->mmap_len = mmap_len;
623	}	649	}
624		650
625		651
Lines 628-634 close_archive (struct locarhandle *ah) Link Here
628	{	654	{
629	if (ah->fd != -1)	655	if (ah->fd != -1)
630	{	656	{
631	munmap (ah->addr, ah->reserved);	657	if (ah->mmap_base)
		658	munmap (ah->mmap_base, ah->mmap_len);
		659	else
		660	munmap (ah->addr, ah->reserved);
632	close (ah->fd);	661	close (ah->fd);
633	}	662	}
634	}	663	}

Line 0 Link Here

(-)a/sysdeps/generic/libc-mmap.h (-1 / +26 lines)
0	-	1	/* Internal logic for dealing with mmap quirks.
		2	Copyright (C) 2013 Free Software Foundation, Inc.
		3	This file is part of the GNU C Library.
		4
		5	The GNU C Library is free software; you can redistribute it and/or
		6	modify it under the terms of the GNU Lesser General Public
		7	License as published by the Free Software Foundation; either
		8	version 2.1 of the License, or (at your option) any later version.
		9
		10	The GNU C Library is distributed in the hope that it will be useful,
		11	but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		13	Lesser General Public License for more details.
		14
		15	You should have received a copy of the GNU Lesser General Public
		16	License along with the GNU C Library; if not, see
		17	<http://www.gnu.org/licenses/>. */
		18
		19	#ifndef _LIBC_MMAP_H
		20	#define _LIBC_MMAP_H 1
		21
		22	/* Using MAP_FIXED with mmap sometimes requires larger alignment. */
		23	#include <sys/shm.h>
		24	#define MAP_FIXED_ALIGNMENT SHMLBA
		25
		26	#endif