From patchwork Wed Nov 1 12:56:07 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 740062 Delivered-To: patch@linaro.org Received: by 2002:a5d:538f:0:b0:32d:baff:b0ca with SMTP id d15csp267477wrv; Wed, 1 Nov 2023 05:56:55 -0700 (PDT) X-Google-Smtp-Source: AGHT+IERtRyORLtp1vOX40O4iuhqEATGXetCzt8kATSVGuzYAsDtYP83oOkWDncBy+0pdnwn9p7a X-Received: by 2002:a9d:77d1:0:b0:6bc:fb5f:7b06 with SMTP id w17-20020a9d77d1000000b006bcfb5f7b06mr16474278otl.17.1698843414963; Wed, 01 Nov 2023 05:56:54 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1698843414; cv=pass; d=google.com; s=arc-20160816; b=Dr5b7vFt0+Osl/v32yJgu7EaWAiImFmJX79APfOLB6Gbn8x9ePlY2iqBiPc7q1N0K3 gtyLYRQQovWSEOqLTaF1YqfxF7w5swUnhltdHQrMk61X1HxQyFAON0cq9HZS0KHC21Or bGcGOJmaFez3iIj4hsxs4MUH1yu8JOu94TibFvpCQqmXi+ZMllf5p6SZie56L1nrzLeO EfYBPtnwLwlqSNTqki/9nElrTKB0PMJv2cBhJr5ffXhB3uQ9o45c/OvpSb+p+vFIeFnr IyoXPLJKVls8JHl/Y2I6gJT0n7e4884weMBVhKHP+Kt2NcbulgwP3f2EWNnWwyd8Z9ru 6hGw== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:to:from :dkim-signature:arc-filter:dmarc-filter:delivered-to; bh=bKGTvDrs3EZm8QuGc3+yl+qhCuH5QjsUhkgltvYjiTs=; fh=wOialSeEyZrL0Zmx/XQW8gMhKHOwjxYz8NEgiPSksGI=; b=ZBvAiPswRZlMR1n/XmsRDjKAsABTAkPKmm1d+e8iVIacSQ9r0oiQp5p+/KrBwtBZWs E+FNXF57lnEUCxeoFoX47DaINeIJwaipl+v/sbtEvKvzgIzs51gAr75el03lyaJ9rrYN MTRgnWxEfYVXU8K7ghM97261o0ZG9ugLxA44XaCR6suSjrYMlXj7wkC4OCXYAWG7Bxr4 N3IHgCHPU2zprfd/pTJ8bDU3TkTMXfi38rlYWFXtN6rqLeYjRuDoHAcX9WGiW/r/i0Tl PYJ455vhmuf8XPBZjO69dLV2yaRnc4i7UDUWTBU5opxOpasV4DknCRPexEQ6anZ6rOf7 60aQ== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=GXBPkv6d; arc=pass (i=1); spf=pass (google.com: domain of libc-alpha-bounces+patch=linaro.org@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="libc-alpha-bounces+patch=linaro.org@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id bp42-20020a05622a1baa00b00417dc02ee2fsi2650693qtb.462.2023.11.01.05.56.54 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Nov 2023 05:56:54 -0700 (PDT) Received-SPF: pass (google.com: domain of libc-alpha-bounces+patch=linaro.org@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=GXBPkv6d; arc=pass (i=1); spf=pass (google.com: domain of libc-alpha-bounces+patch=linaro.org@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="libc-alpha-bounces+patch=linaro.org@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id B096D3857806 for ; Wed, 1 Nov 2023 12:56:53 +0000 (GMT) X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-yb1-xb29.google.com (mail-yb1-xb29.google.com [IPv6:2607:f8b0:4864:20::b29]) by sourceware.org (Postfix) with ESMTPS id 83D083858412 for ; Wed, 1 Nov 2023 12:56:25 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 83D083858412 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=linaro.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 83D083858412 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2607:f8b0:4864:20::b29 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698843395; cv=none; b=E/FjlSwco8HLf607nkZjTSBi7XhBtWs4TjhCAFLF/rnhD5nRlfrzQX0NKtVyFqC9NEnd6ffhB8+Hx5UhIcUHlBFiNaFahpFcQ/jlyGbM2klFaRKVqDd3RR8tAn8BKHB9NVXUbFcFI44uBTaLbvp+SYxWXuebT17Poq+eZSgDHdk= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698843395; c=relaxed/simple; bh=FO3ADlkLBQb15irFLg8Ohq9np5D2yI2q0MMZkaDWk7Y=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=eQVFfkgzptE2Czc1j7YdfulgBJ2/bi2/LFZgQ7rrpkmROJGYv/r3aMfl03jNYug4OLhmOBOccqrwLfEAW5bhLH8IVCWSWVRH2D+UZMONQkBCpFCu9KnVt5dFbY1xgJztydUJ7FkM2pq2qb4s5NXhfUxjTGyZaI60hs20b8PEyYU= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-yb1-xb29.google.com with SMTP id 3f1490d57ef6-d9ad90e1038so6310173276.3 for ; Wed, 01 Nov 2023 05:56:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1698843384; x=1699448184; darn=sourceware.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date:message-id :reply-to; bh=bKGTvDrs3EZm8QuGc3+yl+qhCuH5QjsUhkgltvYjiTs=; b=GXBPkv6dVVZtiQFIlUnTVBQyaUfPGRVdbjVLeD2vlyKc7Pbt39nXOGrVomfEGQR6q5 vbuZwq4XgLYIR+NfN26AaGrY3WJTNiYXAkbXDJckHvOSxbHJimtfXEFJ+fVVsO9DDjYW WmnO0WkrxjzG3QpChlwJ45GV3J7MmOEBg30b2FeDQspLq5XVJkA1E30sQ59qlkOUvfgp rS/mjSEAW4QOJsQV2FqwN6D0MwBufS/Drkb1/a2MKDFHVf3CJF/63eYrfd7tnNk/497b n9eYE8xBGYTSuX18wq/7TbRAqile1xdK47/mALRvxwwhdJGFrdtfjmTt9yK70vhUR/M5 fViw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698843384; x=1699448184; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=bKGTvDrs3EZm8QuGc3+yl+qhCuH5QjsUhkgltvYjiTs=; b=hfyQEL0GQJ/jumnvGXfu+YtKVfMFe8301jYIMSdCpadYPkzmIyXRXtSGxBMX1DVbSV G+G8i9n9beYCTTrjz0RLncAJrAMhvQPFIbbu1Y3ZLTZbeEwHBzekvRb1CNIId1xMaSj2 wTJHpNbP3K9zDT3/wD8tqw3JUyx18+kqzVWWV8Y4Ji/fqpknqoX3axWAfMRCLVz9yC8M jQyhvi462zCsQdl8PdsjNxAxAcAN09+Z2FRu2eX8e3AIXQyQ+SuQkTAtvdGtPNXywrlG Xl1oruqeP147SI8LH1aOowmq1/0DN7hRawuHFRXia1lLvME19aRTfPvWljsK+twDThQZ epYg== X-Gm-Message-State: AOJu0Yxk4IPx1+dnd3euu0Ztd8lrzTh+d8rziiKVS9x5ciYm2/TsddOS Ak9r6CcWKvI1V8WQgLUIOkVfFLywm7SxgZw7utwaTg== X-Received: by 2002:a25:9805:0:b0:da0:29e2:d29 with SMTP id a5-20020a259805000000b00da029e20d29mr13213069ybo.42.1698843384204; Wed, 01 Nov 2023 05:56:24 -0700 (PDT) Received: from mandiga.. ([2804:1b3:a7c0:a715:15ac:c4b6:7a0e:f5c5]) by smtp.gmail.com with ESMTPSA id w11-20020a5b08cb000000b00da034601e2esm1888100ybq.52.2023.11.01.05.56.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Nov 2023 05:56:23 -0700 (PDT) From: Adhemerval Zanella To: libc-alpha@sourceware.org, DJ Delorie , Ian Rogers , Francesco Nigro , Carlos O'Donell Subject: [PATCH v3 3/7] nptl: Decorate thread stack on pthread_create Date: Wed, 1 Nov 2023 09:56:07 -0300 Message-Id: <20231101125611.208544-4-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231101125611.208544-1-adhemerval.zanella@linaro.org> References: <20231101125611.208544-1-adhemerval.zanella@linaro.org> MIME-Version: 1.0 X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libc-alpha-bounces+patch=linaro.org@sourceware.org Linux 4.5 removed thread stack annotations due to the complexity of computing them [1], and Linux added PR_SET_VMA_ANON_NAME on 5.17 as a way to name anonymous virtual memory areas. This patch adds decoration on the stack created and used by pthread_create, for glibc crated thread stack the /proc/self/maps will now show: [anon: glibc: pthread stack: ] And for user-provided stacks: [anon: glibc: pthread user stack: ] The guard page is not decorated, and the mapping name is cleared when the thread finishes its execution (so the cached stack does not have any name associated). Checked on x86_64-linux-gnu aarch64 aarch64-linux-gnu. [1] https://github.com/torvalds/linux/commit/65376df582174ffcec9e6471bf5b0dd79ba05e4a Co-authored-by: Ian Rogers Reviewed-by: DJ Delorie --- elf/Makefile | 3 + elf/tst-decorate-maps.c | 160 ++++++++++++++++++++++++++++++++++++++++ nptl/allocatestack.c | 40 ++++++++++ nptl/pthread_create.c | 6 ++ 4 files changed, 209 insertions(+) create mode 100644 elf/tst-decorate-maps.c diff --git a/elf/Makefile b/elf/Makefile index b46dee1c16..33f88bae96 100644 --- a/elf/Makefile +++ b/elf/Makefile @@ -303,6 +303,7 @@ tests := \ tst-array4 \ tst-array5 \ tst-auxv \ + tst-decorate-maps \ tst-dl-hash \ tst-leaks1 \ tst-stringtable \ @@ -2980,3 +2981,5 @@ LDFLAGS-tst-dlclose-lazy-mod1.so = -Wl,-z,lazy,--no-as-needed $(objpfx)tst-dlclose-lazy-mod1.so: $(objpfx)tst-dlclose-lazy-mod2.so $(objpfx)tst-dlclose-lazy.out: \ $(objpfx)tst-dlclose-lazy-mod1.so $(objpfx)tst-dlclose-lazy-mod2.so + +$(objpfx)tst-decorate-maps: $(shared-thread-library) diff --git a/elf/tst-decorate-maps.c b/elf/tst-decorate-maps.c new file mode 100644 index 0000000000..b40a0e9b49 --- /dev/null +++ b/elf/tst-decorate-maps.c @@ -0,0 +1,160 @@ +/* Check the VMA name decoration. + Copyright (C) 2023 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 + . */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef MAP_STACK +# define MAP_STACK 0 +#endif + +static pthread_barrier_t b; + +static void * +tf (void *closure) +{ + /* Wait the thread startup, so thread stack is allocated. */ + xpthread_barrier_wait (&b); + + /* Wait the test to read the process mapping. */ + xpthread_barrier_wait (&b); + + return NULL; +} + +struct proc_maps_t +{ + int n_def_threads; + int n_user_threads; +}; + +static struct proc_maps_t +read_proc_maps (void) +{ + if (test_verbose) + printf ("=== print process %jd memory mapping ===\n", + (intmax_t) getpid ()); + struct proc_maps_t r = { 0 }; + + FILE *f = xfopen ("/proc/self/maps", "r"); + char *line = NULL; + size_t line_len = 0; + while (xgetline (&line, &line_len, f)) + { + if (test_verbose) + printf ("%s", line); + if (strstr (line, "[anon: glibc: pthread stack:") != NULL) + r.n_def_threads++; + else if (strstr (line, "[anon: glibc: pthread user stack:") != NULL) + r.n_user_threads++; + } + free (line); + xfclose (f); + + if (test_verbose) + printf ("===\n"); + return r; +} + +static void +do_test_threads (bool set_guard) +{ + enum + { + num_def_threads = 8, + num_user_threads = 2, + num_threads = num_def_threads + num_user_threads, + }; + + xpthread_barrier_init (&b, NULL, num_threads + 1); + + pthread_t thr[num_threads]; + { + int i = 0; + for (; i < num_threads - num_user_threads; i++) + { + pthread_attr_t attr; + xpthread_attr_init (&attr); + /* The guard page is not annotated. */ + if (!set_guard) + xpthread_attr_setguardsize (&attr, 0); + thr[i] = xpthread_create (&attr, tf, NULL); + xpthread_attr_destroy (&attr); + } + for (; i < num_threads; i++) + { + pthread_attr_t attr; + xpthread_attr_init (&attr); + size_t stacksize = support_small_thread_stack_size (); + void *stack = xmmap (0, + stacksize, + PROT_READ | PROT_WRITE, + MAP_PRIVATE|MAP_ANONYMOUS|MAP_STACK, + -1); + xpthread_attr_setstack (&attr, stack, stacksize); + if (!set_guard) + xpthread_attr_setguardsize (&attr, 0); + thr[i] = xpthread_create (&attr, tf, NULL); + xpthread_attr_destroy (&attr); + } + } + + /* Wait all threads to finshed statup and stack allocation. */ + xpthread_barrier_wait (&b); + + { + struct proc_maps_t r = read_proc_maps (); + TEST_COMPARE (r.n_def_threads, num_def_threads); + TEST_COMPARE (r.n_user_threads, num_user_threads); + } + + /* Let the threads finish. */ + xpthread_barrier_wait (&b); + + for (int i = 0; i < num_threads; i++) + xpthread_join (thr[i]); + + { + struct proc_maps_t r = read_proc_maps (); + TEST_COMPARE (r.n_def_threads, 0); + TEST_COMPARE (r.n_user_threads, 0); + } +} + +static int +do_test (void) +{ + support_need_proc ("Reads /proc/self/maps to get stack names."); + + if (!support_set_vma_name_supported ()) + FAIL_UNSUPPORTED ("kernel does not support PR_SET_VMA_ANON_NAME"); + + do_test_threads (false); + do_test_threads (true); + + return 0; +} + +#include diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index f9d8cdfd08..97d0efec10 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -33,6 +33,8 @@ #include #include #include +#include +#include /* Default alignment of stack. */ #ifndef STACK_ALIGN @@ -577,3 +579,41 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, return 0; } + +/* Maximum supported name from initial kernel support, not exported + by user API. */ +#define ANON_VMA_NAME_MAX_LEN 80 + +#define SET_STACK_NAME(__prefix, __stack, __stacksize, __tid) \ + ({ \ + char __stack_name[sizeof (__prefix) + \ + INT_BUFSIZE_BOUND (unsigned int)]; \ + _Static_assert (sizeof __stack_name <= ANON_VMA_NAME_MAX_LEN, \ + "VMA name size larger than maximum supported"); \ + __snprintf (__stack_name, sizeof (__stack_name), __prefix "%u", \ + (unsigned int) __tid); \ + __set_vma_name (__stack, __stacksize, __stack_name); \ + }) + +/* Add or remove an associated name to the PD VMA stack. */ +static void +name_stack_maps (struct pthread *pd, bool set) +{ +#if _STACK_GROWS_DOWN && !defined(NEED_SEPARATE_REGISTER_STACK) + void *stack = pd->stackblock + pd->guardsize; +#else + void *stack = pd->stackblock; +#endif + size_t stacksize = pd->stackblock_size - pd->guardsize; + + if (!set) + __set_vma_name (stack, stacksize, NULL); + else + { + unsigned int tid = pd->tid; + if (pd->user_stack) + SET_STACK_NAME (" glibc: pthread user stack: ", stack, stacksize, tid); + else + SET_STACK_NAME (" glibc: pthread stack: ", stack, stacksize, tid); + } +} diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c index 6a41d50109..63cb684f04 100644 --- a/nptl/pthread_create.c +++ b/nptl/pthread_create.c @@ -369,6 +369,9 @@ start_thread (void *arg) /* Initialize pointers to locale data. */ __ctype_init (); + /* Name the thread stack if kernel supports it. */ + name_stack_maps (pd, true); + /* Register rseq TLS to the kernel. */ { bool do_rseq = THREAD_GETMEM (pd, flags) & ATTR_FLAG_DO_RSEQ; @@ -571,6 +574,9 @@ start_thread (void *arg) /* Free the TCB. */ __nptl_free_tcb (pd); + /* Remove the associated name from the thread stack. */ + name_stack_maps (pd, false); + out: /* We cannot call '_exit' here. '_exit' will terminate the process.