+2009-04-24 Ulrich Drepper <drepper@redhat.com>
+
+ [BZ #10093]
+ * iconv/gconv_simple.c (BODY for UTF-8 to INTERNAL): Don't accept
+ UTF-16 surrogates.
+
+ * locale/programs/locarchive.c (enlarge_archive): Conserve address
+ space when temporarily mapping the whole content of the old file.
+
+ [BZ #10100]
+ * misc/hsearch_r.c (hsearch_r): Add back ensurance that hval is
+ not zero.
+
+2009-04-24 Jakub Jelinek <jakub@redhat.com>
+
+ * iconvdata/sjis.c (BODY): Don't advance inptr before
+ STANDARD_FROM_LOOP_ERR_HANDLER (2) for 2 byte invalid input.
+ Use STANDARD_FROM_LOOP_ERR_HANDLER with 2 instead of 1 for
+ two byte chars.
+
+2009-04-24 Ulrich Drepper <drepper@redhat.com>
+
+ * locale/locarchive.h (struct locarhandle): Rename len field to
+ mmaped and add new reserved field.
+ * locale/programs/locarchive.c (RESERVE_MMAP_SIZE): Define.
+ (create_archive): Reserve address space and then map file into it.
+ (open_archive): Likewise.
+ (file_data_available_p): New function.
+ (compare_from_file): New function.
+ (close_archive): Adjust to member name changes.
+ (add_locale): Before comparing locale data, check it is mapped.
+ Otherwise fall back to reading from the file.
+
+2009-04-23 H.J. Lu <hongjiu.lu@intel.com>
+
+ * stdio-common/psiginfo.c: Include <errno.h>.
+
2009-04-23 Ulrich Drepper <drepper@redhat.com>
[BZ #9920]
/* Mapping tables for SJIS handling.
- Copyright (C) 1997-2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1997-2001, 2002, 2009 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
\
ch2 = inptr[1]; \
idx = ch * 256 + ch2; \
- if (__builtin_expect (ch2 < 0x40, 0) \
- || (__builtin_expect (idx > 0x84be, 0) && idx < 0x889f) \
- || (__builtin_expect (idx > 0x88fc, 0) && idx < 0x8940) \
- || (__builtin_expect (idx > 0x9ffc, 0) && idx < 0xe040) \
- || __builtin_expect (idx > 0xeaa4, 0)) \
+ if (__builtin_expect (ch2 < 0x40, 0)) \
{ \
/* This is illegal. */ \
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
} \
+ else if ((__builtin_expect (idx > 0x84be && idx < 0x889f, 0)) \
+ || (__builtin_expect (idx > 0x88fc && idx < 0x8940, 0)) \
+ || (__builtin_expect (idx > 0x9ffc && idx < 0xe040, 0)) \
+ || __builtin_expect (idx > 0xeaa4, 0)) \
+ { \
+ /* This is illegal. */ \
+ STANDARD_FROM_LOOP_ERR_HANDLER (2); \
+ } \
else \
{ \
/* We could pack the data a bit more dense. The second \
else \
ch = cjk_block4[(ch - 0xe0) * 192 + ch2 - 0x40]; \
\
- inptr += 2; \
- } \
+ if (__builtin_expect (ch == 0, 0)) \
+ { \
+ /* This is an illegal character. */ \
+ STANDARD_FROM_LOOP_ERR_HANDLER (2); \
+ } \
\
- if (__builtin_expect (ch == 0, 0)) \
- { \
- /* This is an illegal character. */ \
- STANDARD_FROM_LOOP_ERR_HANDLER (2); \
+ inptr += 2; \
} \
} \
\
#define INITIAL_NUM_SUMS 2000
+/* Size of the reserved address space area. */
+#define RESERVE_MMAP_SIZE 512 * 1024 * 1024
+
+
static void
create_archive (const char *archivefname, struct locarhandle *ah)
{
error (EXIT_FAILURE, errval, _("cannot resize archive file"));
}
+ /* To prepare for enlargements of the mmaped area reserve some
+ address space. */
+ size_t reserved = RESERVE_MMAP_SIZE;
+ int xflags = 0;
+ if (total < reserved
+ && ((p = mmap64 (NULL, reserved, PROT_NONE, MAP_ANON, -1, 0))
+ != MAP_FAILED))
+ xflags = MAP_FIXED;
+ else
+ {
+ p = NULL;
+ reserved = total;
+ }
+
/* Map the header and all the administration data structures. */
- p = mmap64 (NULL, total, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ p = mmap64 (p, total, PROT_READ | PROT_WRITE, MAP_SHARED | xflags, fd, 0);
if (p == MAP_FAILED)
{
int errval = errno;
ah->fd = fd;
ah->addr = p;
- ah->len = total;
+ ah->mmaped = total;
+ ah->reserved = reserved;
}
bool replace, const char *oldname,
uint32_t *locrec_offset_p);
+
+static bool
+file_data_available_p (struct locarhandle *ah, uint32_t offset, uint32_t size)
+{
+ if (offset < ah->mmaped && offset + size <= ah->mmaped)
+ return true;
+
+ struct stat64 st;
+ if (fstat64 (ah->fd, &st) != 0)
+ return false;
+
+ if (st.st_size > ah->reserved)
+ return false;
+
+ void *p = mremap (ah->addr, ah->mmaped, st.st_size,
+ MREMAP_FIXED | MREMAP_MAYMOVE, ah->addr);
+ if (p == MAP_FAILED)
+ return false;
+
+ ah->mmaped = st.st_size;
+ return true;
+}
+
+
+static int
+compare_from_file (struct locarhandle *ah, void *p1, uint32_t offset2,
+ uint32_t size)
+{
+ void *p2 = xmalloc (size);
+ if (pread (ah->fd, p2, size, offset2) != size)
+ WITH_CUR_LOCALE (error (4, errno,
+ _("cannot read data from locale archive")));
+
+ int res = memcmp (p1, p2, size);
+ free (p2);
+ return res;
+}
+
+
static void
enlarge_archive (struct locarhandle *ah, const struct locarhead *head)
{
/* Not all of the old file has to be mapped. Change this now this
we will have to access the whole content. */
- if (fstat64 (ah->fd, &st) != 0
- || (ah->addr = mmap64 (NULL, st.st_size, PROT_READ | PROT_WRITE,
- MAP_SHARED, ah->fd, 0)) == MAP_FAILED)
+ if (fstat64 (ah->fd, &st) != 0)
+ enomap:
error (EXIT_FAILURE, errno, _("cannot map locale archive file"));
- ah->len = st.st_size;
+
+ if (st.st_size < ah->reserved)
+ ah->addr = mremap (ah->addr, ah->mmaped, st.st_size,
+ MREMAP_MAYMOVE | MREMAP_FIXED, ah->addr);
+ 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;
+ }
+ if (ah->addr == MAP_FAILED)
+ goto enomap;
+ ah->mmaped = st.st_size;
/* Create a temporary file in the correct directory. */
fd = mkstemp (fname);
error (EXIT_FAILURE, errval, _("cannot lock new archive"));
}
- new_ah.len = total;
+ new_ah.mmaped = total;
new_ah.addr = p;
new_ah.fd = fd;
+ new_ah.reserved = total;
/* Walk through the hash name hash table to find out what data is
still referenced and transfer it into the new file. */
}
ah->fd = fd;
- ah->len = (head.sumhash_offset
- + head.sumhash_size * sizeof (struct sumhashent));
+ ah->mmaped = st.st_size;
+
+ /* To prepare for enlargements of the mmaped area reserve some
+ address space. */
+ size_t reserved = RESERVE_MMAP_SIZE;
+ int xflags = 0;
+ void *p;
+ if (st.st_size < reserved
+ && ((p = mmap64 (NULL, RESERVE_MMAP_SIZE, PROT_NONE, MAP_ANON, -1, 0))
+ != MAP_FAILED))
+ xflags = MAP_FIXED;
+ else
+ {
+ p = NULL;
+ reserved = st.st_size;
+ }
/* Map the entire file. We might need to compare the category data
in the file with the newly added data. */
- ah->addr = mmap64 (NULL, st.st_size, PROT_READ | (readonly ? 0 : PROT_WRITE),
- MAP_SHARED, fd, 0);
+ ah->addr = mmap64 (p, st.st_size, PROT_READ | (readonly ? 0 : PROT_WRITE),
+ MAP_SHARED | xflags, fd, 0);
if (ah->addr == MAP_FAILED)
{
(void) lockf64 (fd, F_ULOCK, sizeof (struct locarhead));
error (EXIT_FAILURE, errno, _("cannot map archive header"));
}
+ ah->reserved = reserved;
}
{
if (ah->fd != -1)
{
- munmap (ah->addr, ah->len);
+ munmap (ah->addr, ah->reserved);
close (ah->fd);
}
}
if (iloc != head->locrectab_used
&& data[cnt].size == locrecent[iloc].record[cnt].len
- && memcmp (data[cnt].addr,
- (char *) ah->addr + sumhashtab[idx].file_offset,
- data[cnt].size) == 0)
+ /* We have to compare the content. Either we can
+ have the data mmaped or we have to read from
+ the file. */
+ && (file_data_available_p (ah, sumhashtab[idx].file_offset,
+ data[cnt].size)
+ ? memcmp (data[cnt].addr,
+ (char *) ah->addr
+ + sumhashtab[idx].file_offset,
+ data[cnt].size) == 0
+ : compare_from_file (ah, data[cnt].addr,
+ sumhashtab[idx].file_offset,
+ data[cnt].size) == 0))
{
/* Found it. */
file_offsets[cnt] = sumhashtab[idx].file_offset;
projects / thirdparty / glibc.git / commitdiff
