From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 85338 invoked by alias); 24 Oct 2016 14:43:12 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Received: (qmail 85241 invoked by uid 89); 24 Oct 2016 14:43:12 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.3 required=5.0 tests=BAYES_05,RCVD_IN_DNSWL_NONE,SPF_NEUTRAL autolearn=no version=3.3.2 spammy=1598, colon, mmanh, UD:mman.h X-HELO: homiemail-a45.g.dreamhost.com From: Siddhesh Poyarekar To: libc-alpha@sourceware.org Subject: [PATCH 4/6] Initialize tunable list with the GLIBC_TUNABLES environment variable Date: Mon, 24 Oct 2016 14:43:00 -0000 Message-Id: <1477320168-23397-5-git-send-email-siddhesh@sourceware.org> In-Reply-To: <1477320168-23397-1-git-send-email-siddhesh@sourceware.org> References: <1477320168-23397-1-git-send-email-siddhesh@sourceware.org> X-SW-Source: 2016-10/txt/msg00385.txt.bz2 Read tunables values from the users using the GLIBC_TUNABLES environment variable. The value of this variable is a colon-separated list of name=value pairs. So a typical string would look like this: GLIBC_TUNABLES=glibc.malloc.mmap_threshold=2048:glibc.malloc.trim_threshold=1024 * elf/dl-tunables.c: Include mman.h and libc-internals.h. (GLIBC_TUNABLES): New macro. (tunables_strdup): New function. (parse_tunables): New function. (__tunables_init): Use the new functions and macro. (disable_tunable): Disable tunable from GLIBC_TUNABLES. * malloc/tst-malloc-usable-tunables.c: New test case. * malloc/tst-malloc-usable-static-tunables.c: New test case. * malloc/Makefile (tests, tests-static): Add tests. --- elf/dl-tunables.c | 115 +++++++++++++++++++++++++++++ malloc/Makefile | 6 +- malloc/tst-malloc-usable-static-tunables.c | 1 + malloc/tst-malloc-usable-tunables.c | 1 + 4 files changed, 122 insertions(+), 1 deletion(-) create mode 100644 malloc/tst-malloc-usable-static-tunables.c create mode 100644 malloc/tst-malloc-usable-tunables.c diff --git a/elf/dl-tunables.c b/elf/dl-tunables.c index 91340b6..6612885 100644 --- a/elf/dl-tunables.c +++ b/elf/dl-tunables.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -29,6 +30,8 @@ #define TUNABLES_INTERNAL 1 #include "dl-tunables.h" +#define GLIBC_TUNABLES "GLIBC_TUNABLES" + /* Compare environment names, bounded by the name hardcoded in glibc. */ static bool is_name (const char *orig, const char *envname) @@ -44,6 +47,27 @@ is_name (const char *orig, const char *envname) return false; } +static char *tunables_strdup (const char *in) +{ + size_t i = 0; + + while (in[i++]); + + char *out = __mmap (NULL, ALIGN_UP (i, __getpagesize ()), + PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, + 0); + + if (out == MAP_FAILED) + return NULL; + + i--; + + while (i-- > 0) + out[i] = in[i]; + + return out; +} + static char ** get_next_env (char **envp, char **name, size_t *namelen, char **val) { @@ -208,6 +232,72 @@ tunable_initialize (tunable_t *cur, const char *strval) } } +static void +parse_tunables (char *tunestr) +{ + if (tunestr == NULL || *tunestr == '\0') + return; + + char *p = tunestr; + + while (true) + { + char *name = p; + size_t len = 0; + + /* First, find where the name ends. */ + while (p[len] != '=' && p[len] != ':' && p[len] != '\0') + len++; + + /* If we reach the end of the string before getting a valid name-value + pair, bail out. */ + if (p[len] == '\0') + return; + + /* We did not find a valid name-value pair before encountering the + colon. */ + if (p[len]== ':') + { + p += len + 1; + continue; + } + + p += len + 1; + + char *value = p; + len = 0; + + while (p[len] != ':' && p[len] != '\0') + len++; + + char end = p[len]; + p[len] = '\0'; + + /* Add the tunable if it exists. */ + for (size_t i = 0; i < sizeof (tunable_list) / sizeof (tunable_t); i++) + { + tunable_t *cur = &tunable_list[i]; + + /* If we are in a secure context (AT_SECURE) then ignore the tunable + unless it is explicitly marked as secure. Tunable values take + precendence over their envvar aliases. */ + if (__libc_enable_secure && !cur->is_secure) + continue; + + if (is_name (cur->name, name)) + { + tunable_initialize (cur, value); + break; + } + } + + if (end == ':') + p += len + 1; + else + return; + } +} + /* Disable a tunable if it is set. */ static void disable_tunable (tunable_id_t id, char **envp) @@ -216,6 +306,23 @@ disable_tunable (tunable_id_t id, char **envp) if (env_alias) tunables_unsetenv (envp, tunable_list[id].env_alias); + + char *tunable = getenv (GLIBC_TUNABLES); + const char *cmp = tunable_list[id].name; + const size_t len = strlen (cmp); + + while (tunable && *tunable != '\0' && *tunable != ':') + { + if (strncmp (tunable, cmp, len) == 0) + { + tunable += len; + /* Overwrite the = and the value with colons. */ + while (*tunable != '\0' && *tunable != ':') + *tunable++ = ':'; + break; + } + tunable++; + } } /* Disable the glibc.malloc.check tunable in SETUID/SETGID programs unless @@ -246,6 +353,14 @@ __tunables_init (char **envp) while ((envp = get_next_env (envp, &envname, &len, &envval)) != NULL) { + if (is_name (GLIBC_TUNABLES, envname)) + { + char *val = tunables_strdup (envval); + if (val != NULL) + parse_tunables (val); + continue; + } + for (int i = 0; i < sizeof (tunable_list) / sizeof (tunable_t); i++) { tunable_t *cur = &tunable_list[i]; diff --git a/malloc/Makefile b/malloc/Makefile index e7c2cb7..4e4898c 100644 --- a/malloc/Makefile +++ b/malloc/Makefile @@ -33,11 +33,13 @@ tests := mallocbug tst-malloc tst-valloc tst-calloc tst-obstack \ tst-mallocfork2 \ tst-interpose-nothread \ tst-interpose-thread \ + tst-malloc-usable-tunables tests-static := \ tst-interpose-static-nothread \ tst-interpose-static-thread \ - tst-malloc-usable-static + tst-malloc-usable-static \ + tst-malloc-usable-static-tunables tests += $(tests-static) test-srcs = tst-mtrace @@ -157,6 +159,8 @@ endif tst-mcheck-ENV = MALLOC_CHECK_=3 tst-malloc-usable-ENV = MALLOC_CHECK_=3 tst-malloc-usable-static-ENV = $(tst-malloc-usable-ENV) +tst-malloc-usable-tunables-ENV = GLIBC_TUNABLES=glibc.malloc.check=3 +tst-malloc-usable-static-tunables-ENV = $(tst-malloc-usable-tunables-ENV) # Uncomment this for test releases. For public releases it is too expensive. #CPPFLAGS-malloc.o += -DMALLOC_DEBUG=1 diff --git a/malloc/tst-malloc-usable-static-tunables.c b/malloc/tst-malloc-usable-static-tunables.c new file mode 100644 index 0000000..8907db0 --- /dev/null +++ b/malloc/tst-malloc-usable-static-tunables.c @@ -0,0 +1 @@ +#include diff --git a/malloc/tst-malloc-usable-tunables.c b/malloc/tst-malloc-usable-tunables.c new file mode 100644 index 0000000..8907db0 --- /dev/null +++ b/malloc/tst-malloc-usable-tunables.c @@ -0,0 +1 @@ +#include -- 2.7.4