From: Adhemerval Zanella <adhemerval.zanella@linaro.org>
To: libc-alpha@sourceware.org, Florian Weimer <fweimer@redhat.com>
Subject: Re: [PATCH 24/28] elf: Implement a string table for ldconfig, with tail merging
Date: Tue, 20 Oct 2020 11:25:59 -0300 [thread overview]
Message-ID: <2fa948f4-4cc9-750d-3282-7df1d4dd4498@linaro.org> (raw)
In-Reply-To: <a512949efa4f8cfc68362c86d021720a2f56145e.1601569371.git.fweimer@redhat.com>
On 01/10/2020 13:34, Florian Weimer via Libc-alpha wrote:
> This will be used in ldconfig to reduce the ld.so.cache size slightly.
Could you extend the commit message to explain why the 32-bit FNV-1a hash
is used and how the hash table is organized (how collisions are handled,
expected memory usage, strategy used to increase/decrease the bucket size)?
It could help also to explain the usercase a bit more, the 'tail merging'
is not straightforward to understand without dig deep in the code. Also
why kind of cache size decrease do you expect by using strategy?
> ---
> elf/Makefile | 2 +-
> elf/stringtable.c | 201 +++++++++++++++++++++++++++++++++++++++++
> elf/stringtable.h | 61 +++++++++++++
> elf/stringtable_free.c | 32 +++++++
> elf/tst-stringtable.c | 140 ++++++++++++++++++++++++++++
> 5 files changed, 435 insertions(+), 1 deletion(-)
> create mode 100644 elf/stringtable.c
> create mode 100644 elf/stringtable.h
> create mode 100644 elf/stringtable_free.c
> create mode 100644 elf/tst-stringtable.c
>
> diff --git a/elf/Makefile b/elf/Makefile
> index 2c36b08c73..ad50a3e16e 100644
> --- a/elf/Makefile
> +++ b/elf/Makefile
> @@ -172,7 +172,7 @@ tests-container := \
>
> tests := tst-tls9 tst-leaks1 \
> tst-array1 tst-array2 tst-array3 tst-array4 tst-array5 \
> - tst-auxv
> + tst-auxv tst-stringtable
> tests-internal := tst-tls1 tst-tls2 $(tests-static-internal)
> tests-static := $(tests-static-normal) $(tests-static-internal)
>
> diff --git a/elf/stringtable.c b/elf/stringtable.c
> new file mode 100644
> index 0000000000..f9ade50249
> --- /dev/null
> +++ b/elf/stringtable.c
> @@ -0,0 +1,201 @@
> +/* String tables for ld.so.cache construction. Implementation.
This file misses the Copyright year.
> + This file is part of the GNU C 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; 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, see <https://www.gnu.org/licenses/>. */
> +
> +#include <assert.h>
> +#include <error.h>
> +#include <ldconfig.h>
> +#include <libintl.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <stringtable.h>
> +
> +static void
> +stringtable_init (struct stringtable *table)
> +{
> + table->count = 0;
> + table->allocated = 16;
> + table->entries = xcalloc (table->allocated, sizeof (table->entries[0]));
> +}
> +
Why 16 elements as initial size?
> +/* 32-bit FNV-1a hash function. */
> +static uint32_t
> +fnv1a (const char *string, size_t length)
> +{
> + const unsigned char *p = (const unsigned char *) string;
> + uint32_t hash = 2166136261U;
> + for (size_t i = 0; i < length; ++i)
> + {
> + hash ^= p[i];
> + hash *= 16777619U;
> + }
> + return hash;
> +}
Why fnv1a was chosen?
> +
> +/* Double the capacity of the hash table. */
> +static void
> +stringtable_rehash (struct stringtable *table)
> +{
> + /* Cannot overflow because the old allocation size (in bytes) is
> + larger. */
> + uint32_t new_allocated = table->allocated * 2;
> + struct stringtable_entry **new_entries
> + = xcalloc (new_allocated, sizeof (table->entries[0]));
> +
> + uint32_t mask = new_allocated - 1;
> + for (uint32_t i = 0; i < table->allocated; ++i)
> + for (struct stringtable_entry *e = table->entries[i]; e != NULL; )
> + {
> + struct stringtable_entry *next = e->next;
> + uint32_t hash = fnv1a (e->string, e->length);
> + uint32_t new_index = hash & mask;
> + e->next = new_entries[new_index];
> + new_entries[new_index] = e;
> + e = next;
> + }
> +
> + free (table->entries);
> + table->entries = new_entries;
> + table->allocated = new_allocated;
> +}
> +
> +struct stringtable_entry *
> +stringtable_intern (struct stringtable *table, const char *string)
> +{
> + if (table->allocated == 0)
> + stringtable_init (table);
How this could happen? Is it expect the caller to set 'allocated' explicitly?
> +
> + size_t length = strlen (string);
> + if (length > (1U << 30))
> + error (EXIT_FAILURE, 0, _("String table string is too long"));
> + uint32_t hash = fnv1a (string, length);
> +
> + /* Return a previously-existing entry. */
> + for (struct stringtable_entry *e
> + = table->entries[hash & (table->allocated - 1)];
> + e != NULL; e = e->next)
> + if (e->length == length && memcmp (e->string, string, length) == 0)
> + return e;
> +
> + /* Increase the size of the table if necessary. Keep utilization
> + below two thirds. */
> + if (table->count >= (1U << 30))
> + error (EXIT_FAILURE, 0, _("String table has too many entries"));
> + if (table->count * 3 > table->allocated * 2)
> + stringtable_rehash (table);
> +
> + /* Add the new table entry. */
> + ++table->count;
> + struct stringtable_entry *e
> + = xmalloc (offsetof (struct stringtable_entry, string) + length + 1);
> + uint32_t index = hash & (table->allocated - 1);
> + e->next = table->entries[index];
> + table->entries[index] = e;
> + e->length = length;
> + e->offset = 0;
> + memcpy (e->string, string, length + 1);
> + return e;
> +}
> +
> +/* Sort reversed strings in lexicographic order. This is used for tail
> + merging. */
> +static int
> +finalize_compare (const void *l, const void *r)
> +{
> + struct stringtable_entry *left = *(struct stringtable_entry **) l;
> + struct stringtable_entry *right = *(struct stringtable_entry **) r;
> + size_t to_compare;
> + if (left->length < right->length)
> + to_compare = left->length;
> + else
> + to_compare = right->length;
> + for (ssize_t i = to_compare - 1; i >= 0; --i)
> + {
> + unsigned char lch = left->string[i];
> + unsigned char rch = right->string[i];
> + if (lch != rch)
> + return lch - rch;
> + }
> + if (left->length == right->length)
> + return 0;
> + else if (left->length < right->length)
> + /* Longer strings should come first. */
> + return 1;
> + else
> + return -1;
> +}
Ok.
> +
> +void
> +stringtable_finalize (struct stringtable *table,
> + struct stringtable_finalized *result)
> +{
> + if (table->count == 0)
> + {
> + result->strings = xstrdup ("");
> + result->size = 0;
> + return;
> + }
> +
> + /* Optimize the order of the strings. */
> + struct stringtable_entry **array = xcalloc (table->count, sizeof (*array));
> + {
> + size_t j = 0;
> + for (uint32_t i = 0; i < table->allocated; ++i)
> + for (struct stringtable_entry *e = table->entries[i]; e != NULL;
> + e = e->next)
> + {
> + array[j] = e;
> + ++j;
> + }
> + assert (j == table->count);
> + }
> + qsort (array, table->count, sizeof (*array), finalize_compare);
> +
> + /* Assign offsets, using table sharing if possible. */
> + array[0]->offset = 0;
> + for (uint32_t j = 1; j < table->count; ++j)
> + {
> + struct stringtable_entry *previous = array[j - 1];
> + struct stringtable_entry *current = array[j];
> + if (previous->length >= current->length
> + && memcmp (&previous->string[previous->length - current->length],
> + current->string, current->length) == 0)
> + current->offset = (previous->offset + previous->length
> + - current->length);
> + else if (__builtin_add_overflow (previous->offset,
> + previous->length + 1,
> + ¤t->offset))
> + error (EXIT_FAILURE, 0, _("String table is too large"));
> + }
> +
> + /* Allocate the result string. */
> + {
> + struct stringtable_entry *last = array[table->count - 1];
> + if (__builtin_add_overflow (last->offset, last->length + 1,
> + &result->size))
> + error (EXIT_FAILURE, 0, _("String table is too large"));
> + }
> + /* The strings are copied from the hash table, so the array is no
> + longer needed. */
> + free (array);
> + result->strings = xcalloc (result->size, 1);
> +
> + /* Copy the strings. */
> + for (uint32_t i = 0; i < table->allocated; ++i)
> + for (struct stringtable_entry *e = table->entries[i]; e != NULL;
> + e = e->next)
> + if (result->strings[e->offset] == '\0')
> + memcpy (&result->strings[e->offset], e->string, e->length + 1);
> +}
Ok, I guess allocating a new stringtable_finalized should be simpler than
operating the table itself.
> diff --git a/elf/stringtable.h b/elf/stringtable.h
> new file mode 100644
> index 0000000000..e35b6c67fd
> --- /dev/null
> +++ b/elf/stringtable.h
> @@ -0,0 +1,61 @@
> +/* String tables for ld.so.cache construction.
> + This file is part of the GNU C 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; 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, see <https://www.gnu.org/licenses/>. */
> +
> +#ifndef _STRINGTABLE_H
> +#define _STRINGTABLE_H
> +
> +#include <stddef.h>
> +#include <stdint.h>
> +
> +/* An entry in the string table. Only the length and string fields are
> + expected to be used outside the string table code. */
> +struct stringtable_entry
> +{
> + struct stringtable_entry *next; /* For collision resolution. */
> + uint32_t length; /* Length of then string. */
> + uint32_t offset; /* From start of finalized table. */
> + char string[]; /* Null-terminated string. */
> +};
> +
> +/* A string table. Zero-initialization produces a valid atable. */
> +struct stringtable
> +{
> + struct stringtable_entry **entries;
> + uint32_t count; /* Number of elements in the table. */
> + uint32_t allocated; /* Length of the entries array. */
> +};
> +
> +/* Adds STRING to TABLE. May return the address of an existing entry. */
> +struct stringtable_entry *stringtable_intern (struct stringtable *table,
> + const char *string);
I think this name is confusing, why not just 'stringtable_add' or
'stringtable_add_element'?
> +
> +/* Result of stringtable_finalize. SIZE bytes at STRINGS should be
> + written to the file. */
> +struct stringtable_finalized
> +{
> + char *strings;
> + size_t size;
> +};
> +
> +/* Assigns offsets to string table entries and computes the serialized
> + form of the string table. */
> +void stringtable_finalize (struct stringtable *table,
> + struct stringtable_finalized *result);
> +
> +/* Deallocate the string table (but not the TABLE pointer itself). */
> +void stringtable_free (struct stringtable *table);
> +
> +#endif /* _STRINGTABLE_H */
> diff --git a/elf/stringtable_free.c b/elf/stringtable_free.c
> new file mode 100644
> index 0000000000..0e5296e429
> --- /dev/null
> +++ b/elf/stringtable_free.c
> @@ -0,0 +1,32 @@
> +/* String tables for ld.so.cache construction. Deallocation (for tests only).
> + This file is part of the GNU C 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; 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, see <https://www.gnu.org/licenses/>. */
> +
> +#include <stdlib.h>
> +#include <stringtable.h>
> +
> +void
> +stringtable_free (struct stringtable *table)
> +{
> + for (uint32_t i = 0; i < table->allocated; ++i)
> + for (struct stringtable_entry *e = table->entries[i]; e != NULL; )
> + {
> + struct stringtable_entry *next = e->next;
> + free (e);
> + e = next;
> + }
> + free (table->entries);
> + *table = (struct stringtable) { 0, };
> +}
Ok.
> diff --git a/elf/tst-stringtable.c b/elf/tst-stringtable.c
> new file mode 100644
> index 0000000000..78ca5434df
> --- /dev/null
> +++ b/elf/tst-stringtable.c
> @@ -0,0 +1,140 @@
> +/* Unit test for ldconfig string tables.
> + This file is part of the GNU C 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; 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, see <https://www.gnu.org/licenses/>. */
> +
> +#include <stdlib.h>
> +#include <string.h>
> +#include <stringtable.h>
> +#include <support/check.h>
> +#include <support/support.h>
> +
> +static int
> +do_test (void)
> +{
> + /* Empty string table. */
> + {
> + struct stringtable s = { 0, };
> + struct stringtable_finalized f;
> + stringtable_finalize (&s, &f);
> + TEST_COMPARE_STRING (f.strings, "");
> + TEST_COMPARE (f.size, 0);
> + free (f.strings);
> + stringtable_free (&s);
> + }
> +
> + /* String table with one empty string. */
> + {
> + struct stringtable s = { 0, };
> + struct stringtable_entry *e = stringtable_intern (&s, "");
> + TEST_COMPARE_STRING (e->string, "");
> + TEST_COMPARE (e->length, 0);
> + TEST_COMPARE (s.count, 1);
> +
> + struct stringtable_finalized f;
> + stringtable_finalize (&s, &f);
> + TEST_COMPARE (e->offset, 0);
> + TEST_COMPARE_STRING (f.strings, "");
> + TEST_COMPARE (f.size, 1);
> + free (f.strings);
> + stringtable_free (&s);
> + }
> +
> + /* String table with one non-empty string. */
> + {
> + struct stringtable s = { 0, };
> + struct stringtable_entry *e = stringtable_intern (&s, "name");
> + TEST_COMPARE_STRING (e->string, "name");
> + TEST_COMPARE (e->length, 4);
> + TEST_COMPARE (s.count, 1);
> +
> + struct stringtable_finalized f;
> + stringtable_finalize (&s, &f);
> + TEST_COMPARE (e->offset, 0);
> + TEST_COMPARE_STRING (f.strings, "name");
> + TEST_COMPARE (f.size, 5);
> + free (f.strings);
> + stringtable_free (&s);
> + }
> +
> + /* Two strings, one is a prefix of the other. Tail-merging can only
> + happen in one way in this case. */
> + {
> + struct stringtable s = { 0, };
> + struct stringtable_entry *suffix = stringtable_intern (&s, "suffix");
> + TEST_COMPARE_STRING (suffix->string, "suffix");
> + TEST_COMPARE (suffix->length, 6);
> + TEST_COMPARE (s.count, 1);
> +
> + struct stringtable_entry *prefix
> + = stringtable_intern (&s, "prefix-suffix");
> + TEST_COMPARE_STRING (prefix->string, "prefix-suffix");
> + TEST_COMPARE (prefix->length, strlen ("prefix-suffix"));
> + TEST_COMPARE (s.count, 2);
> +
> + struct stringtable_finalized f;
> + stringtable_finalize (&s, &f);
> + TEST_COMPARE (prefix->offset, 0);
> + TEST_COMPARE (suffix->offset, strlen ("prefix-"));
> + TEST_COMPARE_STRING (f.strings, "prefix-suffix");
> + TEST_COMPARE (f.size, sizeof ("prefix-suffix"));
> + free (f.strings);
> + stringtable_free (&s);
> + }
> +
> + /* String table with various shared prefixes. Triggers hash
> + resizing. */
> + {
> + enum { count = 1500 };
> + char *strings[2 * count];
> + struct stringtable_entry *entries[2 * count];
> + struct stringtable s = { 0, };
> + for (int i = 0; i < count; ++i)
> + {
> + strings[i] = xasprintf ("%d", i);
> + entries[i] = stringtable_intern (&s, strings[i]);
> + TEST_COMPARE (entries[i]->length, strlen (strings[i]));
> + TEST_COMPARE_STRING (entries[i]->string, strings[i]);
> + strings[i + count] = xasprintf ("prefix/%d", i);
> + entries[i + count] = stringtable_intern (&s, strings[i + count]);
> + TEST_COMPARE (entries[i + count]->length, strlen (strings[i + count]));
> + TEST_COMPARE_STRING (entries[i + count]->string, strings[i + count]);
> + }
> +
> + struct stringtable_finalized f;
> + stringtable_finalize (&s, &f);
> +
> + for (int i = 0; i < 2 * count; ++i)
> + {
> + TEST_COMPARE (entries[i]->length, strlen (strings[i]));
> + TEST_COMPARE_STRING (entries[i]->string, strings[i]);
> + TEST_COMPARE_STRING (f.strings + entries[i]->offset, strings[i]);
> + free (strings[i]);
> + }
> +
> + free (f.strings);
> + stringtable_free (&s);
> + }
> +
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
> +
> +/* Re-compile the string table implementation here. It is not
> + possible to link against the actual build because it was built for
> + use in ldconfig. */
> +#define _(arg) arg
> +#include "stringtable.c"
> +#include "stringtable_free.c"
>
Ok.
next prev parent reply other threads:[~2020-10-20 14:26 UTC|newest]
Thread overview: 103+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-10-01 16:31 [PATCH 00/28] glibc-hwcaps support Florian Weimer
2020-10-01 16:31 ` [PATCH 01/28] elf: Do not search HWCAP subdirectories in statically linked binaries Florian Weimer
2020-10-01 18:22 ` Adhemerval Zanella
2020-10-01 18:24 ` Carlos O'Donell
2020-10-01 18:29 ` Adhemerval Zanella
2020-10-01 20:24 ` Carlos O'Donell
2020-10-01 16:31 ` [PATCH 02/28] elf: Implement __rtld_malloc_is_full Florian Weimer
2020-10-01 18:23 ` Adhemerval Zanella
2020-10-08 9:44 ` Florian Weimer
2020-10-01 16:31 ` [PATCH 03/28] elf: Implement _dl_write Florian Weimer
2020-10-05 19:46 ` Adhemerval Zanella
2020-10-01 16:31 ` [PATCH 04/28] elf: Extract command-line/environment variables state from rtld.c Florian Weimer
2020-10-06 20:45 ` Adhemerval Zanella
2020-10-08 11:32 ` Florian Weimer
2020-10-01 16:32 ` [PATCH 05/28] elf: Move ld.so error/help output to _dl_usage Florian Weimer
2020-10-06 21:06 ` Adhemerval Zanella
2020-10-08 12:19 ` Florian Weimer
2020-10-01 16:32 ` [PATCH 06/28] elf: Record whether paths come from LD_LIBRARY_PATH or --library-path Florian Weimer
2020-10-07 16:39 ` Adhemerval Zanella
2020-10-07 16:49 ` Florian Weimer
2020-10-01 16:32 ` [PATCH 07/28] elf: Implement ld.so --help Florian Weimer
2020-10-07 17:16 ` Adhemerval Zanella
2020-10-08 13:13 ` Florian Weimer
2020-10-01 16:32 ` [PATCH 08/28] elf: Implement ld.so --version Florian Weimer
2020-10-07 18:36 ` Adhemerval Zanella
2020-10-07 18:38 ` Adhemerval Zanella
2020-10-08 13:37 ` Florian Weimer
2020-10-01 16:32 ` [PATCH 09/28] scripts/update-copyrights: Update csu/version.c, elf/dl-usage.c Florian Weimer
2020-10-07 18:41 ` Adhemerval Zanella
2020-10-01 16:32 ` [PATCH 10/28] elf: Use the term "program interpreter" in the ld.so help message Florian Weimer
2020-10-07 21:08 ` Adhemerval Zanella
2020-10-08 14:08 ` Florian Weimer
2020-10-01 16:32 ` [PATCH 11/28] elf: Print the full name of the dynamic loader " Florian Weimer
2020-10-08 12:38 ` Adhemerval Zanella
2020-10-01 16:32 ` [PATCH 12/28] elf: Make __rtld_env_path_list and __rtld_search_dirs global variables Florian Weimer
2020-10-08 13:27 ` Adhemerval Zanella
2020-10-01 16:32 ` [PATCH 13/28] elf: Add library search path information to ld.so --help Florian Weimer
2020-10-08 16:22 ` Adhemerval Zanella
2020-10-01 16:33 ` [PATCH 14/28] elf: Enhance ld.so --help to print HWCAP subdirectories Florian Weimer
2020-10-08 16:27 ` Adhemerval Zanella
2020-10-09 8:18 ` Florian Weimer
2020-10-09 13:49 ` Matheus Castanho
2020-10-09 17:08 ` Florian Weimer
2020-10-09 17:12 ` Florian Weimer
2020-10-09 18:54 ` Matheus Castanho
2020-10-12 9:47 ` Florian Weimer
2020-10-01 16:33 ` [PATCH 15/28] elf: Do not pass GLRO(dl_platform), GLRO(dl_platformlen) to _dl_important_hwcaps Florian Weimer
2020-10-08 18:04 ` Adhemerval Zanella
2020-10-01 16:33 ` [PATCH 16/28] elf: Add glibc-hwcaps support for LD_LIBRARY_PATH Florian Weimer
2020-10-08 10:13 ` Szabolcs Nagy
2020-10-09 9:08 ` Florian Weimer
2020-10-09 10:50 ` Szabolcs Nagy
2020-10-09 10:55 ` Florian Weimer
2020-10-09 11:03 ` Szabolcs Nagy
2020-10-08 23:16 ` Paul A. Clarke
2020-10-09 8:56 ` Florian Weimer
2020-10-09 13:19 ` Adhemerval Zanella
2020-10-12 11:54 ` Florian Weimer
2020-10-01 16:33 ` [PATCH 17/28] x86_64: Add glibc-hwcaps support Florian Weimer
2020-10-01 16:33 ` [PATCH 18/28] powerpc64le: " Florian Weimer
2020-10-01 18:56 ` Paul A. Clarke
2020-10-05 9:47 ` Florian Weimer
2020-10-05 19:15 ` Paul A. Clarke
2020-10-06 12:20 ` Florian Weimer
2020-10-06 17:45 ` Paul A. Clarke
2020-10-09 9:06 ` Florian Weimer
2020-10-01 16:33 ` [PATCH 19/28] s390x: Add " Florian Weimer
2020-10-01 16:33 ` [PATCH 20/28] aarch64: " Florian Weimer
2020-10-14 13:46 ` Adhemerval Zanella
2020-10-14 14:08 ` Florian Weimer
2020-10-14 14:15 ` Adhemerval Zanella
2020-10-14 14:37 ` Szabolcs Nagy
2020-10-14 14:43 ` Adhemerval Zanella
2020-10-14 15:13 ` Florian Weimer
2020-10-14 14:44 ` Florian Weimer
2020-10-14 15:09 ` Szabolcs Nagy
2020-10-01 16:33 ` [PATCH 21/28] elf: Add endianness markup to ld.so.cache Florian Weimer
2020-10-14 14:07 ` Adhemerval Zanella
2020-10-01 16:33 ` [PATCH 22/28] elf: Add extension mechanism " Florian Weimer
2020-10-15 17:52 ` Adhemerval Zanella
2020-10-30 12:22 ` Florian Weimer
2020-11-03 12:45 ` Adhemerval Zanella
2020-11-03 15:30 ` Florian Weimer
2020-10-01 16:34 ` [PATCH 23/28] elf: Unify old and new format cache handling code in ld.so Florian Weimer
2020-10-16 14:37 ` Adhemerval Zanella
2020-10-30 13:22 ` Florian Weimer
2020-11-03 13:02 ` Adhemerval Zanella
2020-10-01 16:34 ` [PATCH 24/28] elf: Implement a string table for ldconfig, with tail merging Florian Weimer
2020-10-20 14:25 ` Adhemerval Zanella [this message]
2020-10-30 17:08 ` Florian Weimer
2020-11-03 13:05 ` Adhemerval Zanella
2020-11-03 15:29 ` Florian Weimer
2020-10-01 16:34 ` [PATCH 25/28] elf: Implement tail merging of strings in ldconfig Florian Weimer
2020-10-22 21:08 ` Adhemerval Zanella
2020-10-30 17:36 ` Florian Weimer
2020-10-01 16:34 ` [PATCH 26/28] elf: In ldconfig, extract the new_sub_entry function from search_dir Florian Weimer
2020-10-27 13:15 ` Adhemerval Zanella
2020-10-01 16:34 ` [PATCH 27/28] elf: Process glibc-hwcaps subdirectories in ldconfig Florian Weimer
2020-10-27 17:28 ` Adhemerval Zanella
2020-11-04 11:57 ` Florian Weimer
2020-10-01 16:34 ` [PATCH 28/28] elf: Add glibc-hwcaps subdirectory support to ld.so cache processing Florian Weimer
2020-10-01 16:50 ` [PATCH 00/28] glibc-hwcaps support H.J. Lu
2020-10-01 16:54 ` Florian Weimer
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=2fa948f4-4cc9-750d-3282-7df1d4dd4498@linaro.org \
--to=adhemerval.zanella@linaro.org \
--cc=fweimer@redhat.com \
--cc=libc-alpha@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).