From patchwork Tue May 11 01:43:55 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "H.J. Lu" X-Patchwork-Id: 43365 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C09A43850423; Tue, 11 May 2021 01:44:04 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C09A43850423 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1620697444; bh=xPKMdboBkG1F4Y6lyObc3GV4F1Pbhoq2DIeBeh/un8w=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=EpArmQ9HDBZivrDT9V412xM61+exjIsGSNs40ZP1cSRkvfQoOlRbDKsYfe4e0T7sr p1kltC4sCQAT0HHr60IJb47Nf2WVLOc4JvTY4BCDPoo/Hq0yGDe7p5Fop1toMOsq42 FpKvv7LkXFl4qYG3ZWjiHpSp75QXHLAemacp+7Nw= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-pf1-x42a.google.com (mail-pf1-x42a.google.com [IPv6:2607:f8b0:4864:20::42a]) by sourceware.org (Postfix) with ESMTPS id 6C249386102A for ; Tue, 11 May 2021 01:44:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 6C249386102A Received: by mail-pf1-x42a.google.com with SMTP id i13so15034371pfu.2 for ; Mon, 10 May 2021 18:44:00 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xPKMdboBkG1F4Y6lyObc3GV4F1Pbhoq2DIeBeh/un8w=; b=nWDtweUo9sK4U/Zz6dZFZ2NLEO2HrdPWwSA4KtPIbLR+h/lh5ho0PBhUzNeAiCL1ju d8EBGkFSj+dxs19KooUnv7uea2/5oom0oPU10aE6/Z0CS/DuDSCEaTQ8Db9gpreOI9iD zqIp3ocjLn6AjJ/pjqpjVueZGVi5DO/JzkMYUrgdExJ+QLvlNhpaTuyWVsqv2oQxOr8T T/sefmlz5f/iMScpQUcEc68VwUXBxkbzQZ5YP7H4qFxXcM0QmudNVC7nfc2YV5Mwv1y4 EuXMaGzfWiQ23vQ9jGS6KkkhbubRv1Pqs5mRIkSdiCo8ILyISW4sGfSENRI1huL74ccv lCEA== X-Gm-Message-State: AOAM533NBaQH0H6fgjx384fFoOHbh146iDdbG9vSlHmevf+mARBOa4Cv jlBVIkIAQu+VF93q4kCakAz4JKQVWxpHhg== X-Google-Smtp-Source: ABdhPJyEUeAQo5pe8dipIqmOHh+UMEmrTeAEjHvqGrl+Pkti3pQ0t4SGbzf8UdpO5JgHMHFKZ6y7Zw== X-Received: by 2002:a63:d80f:: with SMTP id b15mr14217996pgh.388.1620697439272; Mon, 10 May 2021 18:43:59 -0700 (PDT) Received: from gnu-cfl-2.localdomain ([172.56.38.197]) by smtp.gmail.com with ESMTPSA id g8sm11853708pfo.85.2021.05.10.18.43.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 May 2021 18:43:58 -0700 (PDT) Received: from gnu-cfl-2.. (localhost [IPv6:::1]) by gnu-cfl-2.localdomain (Postfix) with ESMTP id 9CA12C04D3; Mon, 10 May 2021 18:43:56 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH v4 1/2] Add an internal wrapper for clone, clone2 and clone3 Date: Mon, 10 May 2021 18:43:55 -0700 Message-Id: <20210511014356.235353-2-hjl.tools@gmail.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210511014356.235353-1-hjl.tools@gmail.com> References: <20210511014356.235353-1-hjl.tools@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3034.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_NUMSUBJECT, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: "H.J. Lu via Libc-alpha" From: "H.J. Lu" Reply-To: "H.J. Lu" Cc: Florian Weimer Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" The clone3 system call provides a superset of the functionality of clone and clone2. It also provides a number of API improve ments, including the ability to specify the size of the child's stack area which can be used by kernel to compute the shadow stack size when allocating the shadow stack. Add: extern int __clone_internal (struct clone_args *cl_args, int (*__fn) (void *__arg), void *__arg); to provide an abstract interface for clone, clone2 and clone3. 1. Add cast_to_pointer to cast an integer to void * pointer. 2. Simplify stack management for thread creation by passing both stack base and size to create_thread. 3. Consolidate clone vs clone2 differences into a single file. 4. Use only __clone_internal to clone a thread. If clone3 returns -1 with ENOSYS, __clone_internal will fall back to clone or clone2. 5. Add the x86-64 clone3 wrapper. 6. Enable the public clone3 wrapper in the future after it has been added to all targets. Tested with build-many-glibcs.py. The x86-64 clone3 wrapper and the i686 clone fallback are tested under 5.12.2 kernel. --- include/clone3.h | 14 ++++ include/libc-pointer-arith.h | 3 + sysdeps/unix/sysv/linux/Makefile | 4 +- sysdeps/unix/sysv/linux/Versions | 1 + sysdeps/unix/sysv/linux/clone-internal.c | 80 ++++++++++++++++++++ sysdeps/unix/sysv/linux/clone-offsets.sym | 5 ++ sysdeps/unix/sysv/linux/clone3.c | 34 +++++++++ sysdeps/unix/sysv/linux/clone3.h | 58 ++++++++++++++ sysdeps/unix/sysv/linux/createthread.c | 25 +++--- sysdeps/unix/sysv/linux/spawni.c | 26 +++---- sysdeps/unix/sysv/linux/tst-align-clone.c | 55 +++++++++++--- sysdeps/unix/sysv/linux/tst-clone.c | 23 +++++- sysdeps/unix/sysv/linux/tst-clone2.c | 61 +++++++++++---- sysdeps/unix/sysv/linux/tst-clone3.c | 60 +++++++++++---- sysdeps/unix/sysv/linux/tst-getpid1.c | 54 ++++++++++--- sysdeps/unix/sysv/linux/x86_64/clone3.S | 92 +++++++++++++++++++++++ 16 files changed, 517 insertions(+), 78 deletions(-) create mode 100644 include/clone3.h create mode 100644 sysdeps/unix/sysv/linux/clone-internal.c create mode 100644 sysdeps/unix/sysv/linux/clone-offsets.sym create mode 100644 sysdeps/unix/sysv/linux/clone3.c create mode 100644 sysdeps/unix/sysv/linux/clone3.h create mode 100644 sysdeps/unix/sysv/linux/x86_64/clone3.S diff --git a/include/clone3.h b/include/clone3.h new file mode 100644 index 0000000000..124f7ba169 --- /dev/null +++ b/include/clone3.h @@ -0,0 +1,14 @@ +#ifndef _CLONE3_H +#include_next + +extern __typeof (clone3) __clone3; + +/* The internal wrapper of clone and clone3. */ +extern __typeof (clone3) __clone_internal; + +#ifndef _ISOMAC +libc_hidden_proto (__clone3) +libc_hidden_proto (__clone_internal) +#endif + +#endif diff --git a/include/libc-pointer-arith.h b/include/libc-pointer-arith.h index 72e722c5aa..04ba537617 100644 --- a/include/libc-pointer-arith.h +++ b/include/libc-pointer-arith.h @@ -37,6 +37,9 @@ /* Cast an integer or a pointer VAL to integer with proper type. */ # define cast_to_integer(val) ((__integer_if_pointer_type (val)) (val)) +/* Cast an integer VAL to void * pointer. */ +# define cast_to_pointer(val) ((void *) (uintptr_t) (val)) + /* Align a value by rounding down to closest size. e.g. Using size of 4096, we get this behavior: {4095, 4096, 4097} = {0, 4096, 4096}. */ diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile index fb155cf856..7c1f32b84d 100644 --- a/sysdeps/unix/sysv/linux/Makefile +++ b/sysdeps/unix/sysv/linux/Makefile @@ -54,6 +54,8 @@ CFLAGS-malloc.c += -DMORECORE_CLEARS=2 endif ifeq ($(subdir),misc) +gen-as-const-headers += clone-offsets.sym + sysdep_routines += adjtimex clone umount umount2 readahead sysctl \ setfsuid setfsgid epoll_pwait signalfd \ eventfd eventfd_read eventfd_write prlimit \ @@ -64,7 +66,7 @@ sysdep_routines += adjtimex clone umount umount2 readahead sysctl \ time64-support pselect32 \ xstat fxstat lxstat xstat64 fxstat64 lxstat64 \ fxstatat fxstatat64 \ - xmknod xmknodat + xmknod xmknodat clone3 clone-internal CFLAGS-gethostid.c = -fexceptions CFLAGS-tee.c = -fexceptions -fasynchronous-unwind-tables diff --git a/sysdeps/unix/sysv/linux/Versions b/sysdeps/unix/sysv/linux/Versions index 220bb2dffe..299d4fef9c 100644 --- a/sysdeps/unix/sysv/linux/Versions +++ b/sysdeps/unix/sysv/linux/Versions @@ -179,6 +179,7 @@ libc { __sigtimedwait; # functions used by nscd __netlink_assert_response; + __clone_internal; } } diff --git a/sysdeps/unix/sysv/linux/clone-internal.c b/sysdeps/unix/sysv/linux/clone-internal.c new file mode 100644 index 0000000000..acafb78d81 --- /dev/null +++ b/sysdeps/unix/sysv/linux/clone-internal.c @@ -0,0 +1,80 @@ +/* The internal wrapper of clone and clone3. + Copyright (C) 2021 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 /* For cast_to_pointer. */ +#include /* For _STACK_GROWS_{UP,DOWN}. */ + +int +__clone_internal (struct clone_args *cl_args, + int (*fn) (void *arg), void *arg) +{ + int ret; +#ifdef CLONE_ARGS_SIZE_VER0 + /* Try clone3 first. */ + int saved_errno = errno; + ret = __clone3 (cl_args, fn, arg); + if (ret != -1 || errno != ENOSYS) + return ret; + + /* NB: Restore errno since errno may be checked against non-zero + return value. */ + __set_errno (saved_errno); +#else + /* Check invalid arguments. */ + if (cl_args == NULL || fn == NULL) + __set_errno (EINVAL); +#endif + + /* Check invalid clone3 specific bits. */ + if ((cl_args->flags & CSIGNAL) != 0 + || (cl_args->flags & __UINT64_C (0xffffffff00000000))) + { + __set_errno (EINVAL); + return -1; + } + + /* Map clone3 arguments to clone arguments. */ + int flags = cl_args->flags | cl_args->exit_signal; + void *stack = cast_to_pointer (cl_args->stack); + +#ifdef __ia64__ + ret = __clone2 (fn, stack, (size_t) cl_args->stack_size, + flags, arg, + cast_to_pointer (cl_args->parent_tid), + cast_to_pointer (cl_args->tls), + cast_to_pointer (cl_args->child_tid)); +#else +# if !_STACK_GROWS_DOWN && !_STACK_GROWS_UP +# error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" +# endif + +# if _STACK_GROWS_DOWN + stack += cl_args->stack_size; +# endif + ret = __clone (fn, stack, flags, arg, + cast_to_pointer (cl_args->parent_tid), + cast_to_pointer (cl_args->tls), + cast_to_pointer (cl_args->child_tid)); +#endif + return ret; +} + +libc_hidden_def (__clone_internal) diff --git a/sysdeps/unix/sysv/linux/clone-offsets.sym b/sysdeps/unix/sysv/linux/clone-offsets.sym new file mode 100644 index 0000000000..d767e49fc8 --- /dev/null +++ b/sysdeps/unix/sysv/linux/clone-offsets.sym @@ -0,0 +1,5 @@ +#include + +-- + +CLONE_ARGS_SIZE sizeof (struct clone_args) diff --git a/sysdeps/unix/sysv/linux/clone3.c b/sysdeps/unix/sysv/linux/clone3.c new file mode 100644 index 0000000000..b7a41f82e8 --- /dev/null +++ b/sysdeps/unix/sysv/linux/clone3.c @@ -0,0 +1,34 @@ +/* The clone3 syscall wrapper. + Copyright (C) 2021 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 + +int +__clone3 (struct clone_args *cl_args, int (*fn) (void *arg), void *arg) +{ + if (cl_args == NULL || fn == NULL) + __set_errno (EINVAL); + else + __set_errno (ENOSYS); + return -1; +} + +libc_hidden_def (__clone3) +weak_alias (__clone3, clone3) diff --git a/sysdeps/unix/sysv/linux/clone3.h b/sysdeps/unix/sysv/linux/clone3.h new file mode 100644 index 0000000000..be8a11a17c --- /dev/null +++ b/sysdeps/unix/sysv/linux/clone3.h @@ -0,0 +1,58 @@ +/* The wrapper of clone3. + Copyright (C) 2021 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 + . */ + +#ifndef _CLONE3_H +#define _CLONE3_H 1 + +#include +#include +#define clone_args __redirect_clone_args +#include +#undef clone_args + +__BEGIN_DECLS + +struct clone_args +{ + uint64_t flags; /* Flags bit mask. */ + uint64_t pidfd; /* Where to store PID file descriptor + (pid_t *). */ + uint64_t child_tid; /* Where to store child TID, in child's memory + (pid_t *). */ + uint64_t parent_tid; /* Where to store child TID, in parent's memory + (int *). */ + uint64_t exit_signal; /* Signal to deliver to parent on child + termination */ + uint64_t stack; /* The lowest address of stack. */ + uint64_t stack_size; /* Size of stack. */ + uint64_t tls; /* Location of new TLS. */ + uint64_t set_tid; /* Pointer to a pid_t array + (since Linux 5.5). */ + uint64_t set_tid_size; /* Number of elements in set_tid + (since Linux 5.5). */ + uint64_t cgroup; /* File descriptor for target cgroup + of child (since Linux 5.7). */ +}; + +/* The wrapper of clone3. */ +extern int clone3 (struct clone_args *cl_args, + int (*__fn) (void *__arg), void *__arg); + +__END_DECLS + +#endif /* clone3.h */ diff --git a/sysdeps/unix/sysv/linux/createthread.c b/sysdeps/unix/sysv/linux/createthread.c index bc3409b326..2b5e6cb131 100644 --- a/sysdeps/unix/sysv/linux/createthread.c +++ b/sysdeps/unix/sysv/linux/createthread.c @@ -18,6 +18,7 @@ . */ #include +#include #include #include #include @@ -28,12 +29,6 @@ #include -#ifdef __NR_clone2 -# define ARCH_CLONE __clone2 -#else -# define ARCH_CLONE __clone -#endif - /* See the comments in pthread_create.c for the requirements for these two macros and the create_thread function. */ @@ -47,7 +42,8 @@ static int start_thread (void *arg) __attribute__ ((noreturn)); static int create_thread (struct pthread *pd, const struct pthread_attr *attr, - bool *stopped_start, STACK_VARIABLES_PARMS, bool *thread_ran) + bool *stopped_start, void *stackaddr, size_t stacksize, + bool *thread_ran) { /* Determine whether the newly created threads has to be started stopped since we have to set the scheduling parameters or set the @@ -100,9 +96,18 @@ create_thread (struct pthread *pd, const struct pthread_attr *attr, TLS_DEFINE_INIT_TP (tp, pd); - if (__glibc_unlikely (ARCH_CLONE (&start_thread, STACK_VARIABLES_ARGS, - clone_flags, pd, &pd->tid, tp, &pd->tid) - == -1)) + struct clone_args args = + { + .flags = clone_flags, + .pidfd = (uintptr_t) &pd->tid, + .parent_tid = (uintptr_t) &pd->tid, + .child_tid = (uintptr_t) &pd->tid, + .stack = (uintptr_t) stackaddr, + .stack_size = stacksize, + .tls = (uintptr_t) tp, + }; + int ret = __clone_internal (&args, &start_thread, pd); + if (__glibc_unlikely (ret == -1)) return errno; /* It's started now, so if we fail below, we'll have to cancel it diff --git a/sysdeps/unix/sysv/linux/spawni.c b/sysdeps/unix/sysv/linux/spawni.c index 501f8fbccd..92b61e55d3 100644 --- a/sysdeps/unix/sysv/linux/spawni.c +++ b/sysdeps/unix/sysv/linux/spawni.c @@ -31,6 +31,7 @@ #include #include #include +#include #include "spawn_int.h" /* The Linux implementation of posix_spawn{p} uses the clone syscall directly @@ -59,21 +60,6 @@ normal program exit with the exit code 127. */ #define SPAWN_ERROR 127 -#ifdef __ia64__ -# define CLONE(__fn, __stackbase, __stacksize, __flags, __args) \ - __clone2 (__fn, __stackbase, __stacksize, __flags, __args, 0, 0, 0) -#else -# define CLONE(__fn, __stack, __stacksize, __flags, __args) \ - __clone (__fn, __stack, __flags, __args) -#endif - -/* Since ia64 wants the stackbase w/clone2, re-use the grows-up macro. */ -#if _STACK_GROWS_UP || defined (__ia64__) -# define STACK(__stack, __stack_size) (__stack) -#elif _STACK_GROWS_DOWN -# define STACK(__stack, __stack_size) (__stack + __stack_size) -#endif - struct posix_spawn_args { @@ -378,8 +364,14 @@ __spawnix (pid_t * pid, const char *file, need for CLONE_SETTLS. Although parent and child share the same TLS namespace, there will be no concurrent access for TLS variables (errno for instance). */ - new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size, - CLONE_VM | CLONE_VFORK | SIGCHLD, &args); + struct clone_args clone_args = + { + .flags = CLONE_VM | CLONE_VFORK, + .exit_signal = SIGCHLD, + .stack = (uintptr_t) stack, + .stack_size = stack_size, + }; + new_pid = __clone_internal (&clone_args, __spawni_child, &args); /* It needs to collect the case where the auxiliary process was created but failed to execute the file (due either any preparation step or diff --git a/sysdeps/unix/sysv/linux/tst-align-clone.c b/sysdeps/unix/sysv/linux/tst-align-clone.c index 6ace61bac3..5a463e7af3 100644 --- a/sysdeps/unix/sysv/linux/tst-align-clone.c +++ b/sysdeps/unix/sysv/linux/tst-align-clone.c @@ -16,6 +16,7 @@ . */ #include +#include #include #include #include @@ -39,7 +40,7 @@ f (void *arg) } static int -do_test (void) +do_test_clone (bool use_clone_internal) { bool ok = true; @@ -49,21 +50,41 @@ do_test (void) ok = false; #ifdef __ia64__ - extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base, - size_t __child_stack_size, int __flags, - void *__arg, ...); - char st[256 * 1024]; - pid_t p = __clone2 (f, st, sizeof (st), 0, 0); +# define STACK_SIZE 256 * 1024 +#else +# define STACK_SIZE 128 * 1024 +#endif + char st[STACK_SIZE] __attribute__ ((aligned)); + + pid_t p; + + if (use_clone_internal) + { + struct clone_args clone_args = + { + .stack = (uintptr_t) st, + .stack_size = sizeof (st), + }; + p = __clone_internal (&clone_args, f, 0); + } + else + { +#ifdef __ia64__ + extern int __clone2 (int (*__fn) (void *__arg), + void *__child_stack_base, + size_t __child_stack_size, int __flags, + void *__arg, ...); + p = __clone2 (f, st, sizeof (st), 0, 0); #else - char st[128 * 1024] __attribute__ ((aligned)); # if _STACK_GROWS_DOWN - pid_t p = clone (f, st + sizeof (st), 0, 0); + p = clone (f, st + sizeof (st), 0, 0); # elif _STACK_GROWS_UP - pid_t p = clone (f, st, 0, 0); + p = clone (f, st, 0, 0); # else # error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" # endif #endif + } if (p == -1) { printf("clone failed: %m\n"); @@ -91,5 +112,21 @@ do_test (void) return ok ? 0 : 1; } +static int +do_test (void) +{ + bool ok = true; + + puts ("in main"); + + if (do_test_clone (false) != 0) + ok = false; + + if (do_test_clone (true) != 0) + ok = false; + + return ok ? 0 : 1; +} + #define TEST_FUNCTION do_test () #include "../test-skeleton.c" diff --git a/sysdeps/unix/sysv/linux/tst-clone.c b/sysdeps/unix/sysv/linux/tst-clone.c index e6ae0106ef..855f48121e 100644 --- a/sysdeps/unix/sysv/linux/tst-clone.c +++ b/sysdeps/unix/sysv/linux/tst-clone.c @@ -22,6 +22,8 @@ #include #include #include +#include +#include #ifdef __ia64__ extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base, @@ -35,14 +37,17 @@ int child_fn(void *arg) } static int -do_test (void) +do_test_clone (bool use_clone_internal) { int result; + if (use_clone_internal) + result = __clone_internal (NULL, child_fn, NULL); + else #ifdef __ia64__ - result = __clone2 (child_fn, NULL, 0, 0, NULL, NULL, NULL); + result = __clone2 (child_fn, NULL, 0, 0, NULL, NULL, NULL); #else - result = clone (child_fn, NULL, 0, NULL); + result = clone (child_fn, NULL, 0, NULL); #endif if (errno != EINVAL || result != -1) @@ -52,6 +57,18 @@ do_test (void) return 1; } + return 0; +} + +static int +do_test (void) +{ + if (do_test_clone (false) != 0) + return 1; + + if (do_test_clone (true) != 0) + return 1; + puts ("All OK"); return 0; } diff --git a/sysdeps/unix/sysv/linux/tst-clone2.c b/sysdeps/unix/sysv/linux/tst-clone2.c index ce36c70c0d..1df336f8c6 100644 --- a/sysdeps/unix/sysv/linux/tst-clone2.c +++ b/sysdeps/unix/sysv/linux/tst-clone2.c @@ -17,6 +17,7 @@ . */ #include +#include #include #include #include @@ -58,7 +59,7 @@ f (void *a) static int -do_test (void) +do_test_clone (bool use_clone_internal) { sig = SIGRTMIN; sigset_t ss; @@ -70,23 +71,43 @@ do_test (void) if (pipe2 (pipefd, O_CLOEXEC)) FAIL_EXIT1 ("pipe failed: %m"); - int clone_flags = 0; #ifdef __ia64__ - extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base, - size_t __child_stack_size, int __flags, - void *__arg, ...); - char st[256 * 1024] __attribute__ ((aligned)); - pid_t p = __clone2 (f, st, sizeof (st), clone_flags, 0); -#else - char st[128 * 1024] __attribute__ ((aligned)); -#if _STACK_GROWS_DOWN - pid_t p = clone (f, st + sizeof (st), clone_flags, 0); -#elif _STACK_GROWS_UP - pid_t p = clone (f, st, clone_flags, 0); +# define STACK_SIZE 256 * 1024 #else -#error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" +# define STACK_SIZE 128 * 1024 #endif + char st[STACK_SIZE] __attribute__ ((aligned)); + + pid_t p; + + if (use_clone_internal) + { + struct clone_args clone_args = + { + .stack = (uintptr_t) st, + .stack_size = sizeof (st), + }; + p = __clone_internal (&clone_args, f, 0); + } + else + { + int clone_flags = 0; +#ifdef __ia64__ + extern int __clone2 (int (*__fn) (void *__arg), + void *__child_stack_base, + size_t __child_stack_size, int __flags, + void *__arg, ...); + p = __clone2 (f, st, sizeof (st), clone_flags, 0); +#else +# if _STACK_GROWS_DOWN + p = clone (f, st + sizeof (st), clone_flags, 0); +# elif _STACK_GROWS_UP + p = clone (f, st, clone_flags, 0); +# else +# error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" +# endif #endif + } close (pipefd[1]); @@ -143,4 +164,16 @@ do_test (void) return ret; } +static int +do_test (void) +{ + if (do_test_clone (false) != 0) + return 1; + + if (do_test_clone (true) != 0) + return 1; + + return 0; +} + #include diff --git a/sysdeps/unix/sysv/linux/tst-clone3.c b/sysdeps/unix/sysv/linux/tst-clone3.c index 1a1bfd4586..f4eabfc5a7 100644 --- a/sysdeps/unix/sysv/linux/tst-clone3.c +++ b/sysdeps/unix/sysv/linux/tst-clone3.c @@ -18,6 +18,8 @@ #include #include +#include +#include #include #include #include @@ -64,7 +66,7 @@ futex_wait (int *futexp, int val) } static int -do_test (void) +do_test_clone (bool use_clone_internal) { char st[1024] __attribute__ ((aligned)); int clone_flags = CLONE_THREAD; @@ -78,23 +80,39 @@ do_test (void) pid_t ctid = CTID_INIT_VAL; pid_t tid; + if (use_clone_internal) + { + struct clone_args clone_args = + { + .flags = clone_flags & ~CSIGNAL, + .exit_signal = clone_flags & CSIGNAL, + .stack = (uintptr_t) st, + .stack_size = sizeof (st), + .child_tid = (uintptr_t) &ctid, + }; + tid = __clone_internal (&clone_args, f, NULL); + } + else + { #ifdef __ia64__ - extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base, - size_t __child_stack_size, int __flags, - void *__arg, ...); - tid = __clone2 (f, st, sizeof (st), clone_flags, NULL, /* ptid */ NULL, - /* tls */ NULL, &ctid); -#else -#if _STACK_GROWS_DOWN - tid = clone (f, st + sizeof (st), clone_flags, NULL, /* ptid */ NULL, - /* tls */ NULL, &ctid); -#elif _STACK_GROWS_UP - tid = clone (f, st, clone_flags, NULL, /* ptid */ NULL, /* tls */ NULL, - &ctid); + extern int __clone2 (int (*__fn) (void *__arg), + void *__child_stack_base, + size_t __child_stack_size, int __flags, + void *__arg, ...); + tid = __clone2 (f, st, sizeof (st), clone_flags, NULL, /* ptid */ NULL, + /* tls */ NULL, &ctid); #else -#error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" -#endif +# if _STACK_GROWS_DOWN + tid = clone (f, st + sizeof (st), clone_flags, NULL, /* ptid */ NULL, + /* tls */ NULL, &ctid); +# elif _STACK_GROWS_UP + tid = clone (f, st, clone_flags, NULL, /* ptid */ NULL, /* tls */ NULL, + &ctid); +# else +# error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" +# endif #endif + } if (tid == -1) FAIL_EXIT1 ("clone failed: %m"); @@ -103,5 +121,17 @@ do_test (void) return 2; } +static int +do_test (void) +{ + if (do_test_clone (false) != 2) + return 1; + + if (do_test_clone (true) != 2) + return 1; + + return 2; +} + #define EXPECTED_STATUS 2 #include diff --git a/sysdeps/unix/sysv/linux/tst-getpid1.c b/sysdeps/unix/sysv/linux/tst-getpid1.c index 253ebf2e15..1528743319 100644 --- a/sysdeps/unix/sysv/linux/tst-getpid1.c +++ b/sysdeps/unix/sysv/linux/tst-getpid1.c @@ -1,4 +1,6 @@ #include +#include +#include #include #include #include @@ -27,7 +29,7 @@ f (void *a) static int -do_test (void) +do_test_clone (bool use_clone_internal) { int mypid = getpid (); @@ -42,21 +44,43 @@ do_test (void) } #ifdef __ia64__ - extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base, - size_t __child_stack_size, int __flags, - void *__arg, ...); - char st[256 * 1024] __attribute__ ((aligned)); - pid_t p = __clone2 (f, st, sizeof (st), TEST_CLONE_FLAGS, 0); +# define STACK_SIZE 256 * 1024 +#else +# define STACK_SIZE 128 * 1024 +#endif + char st[STACK_SIZE] __attribute__ ((aligned)); + + pid_t p; + + if (use_clone_internal) + { + struct clone_args clone_args = + { + .flags = TEST_CLONE_FLAGS & ~CSIGNAL, + .exit_signal = TEST_CLONE_FLAGS & CSIGNAL, + .stack = (uintptr_t) st, + .stack_size = sizeof (st), + }; + p = __clone_internal (&clone_args, f, 0); + } + else + { +#ifdef __ia64__ + extern int __clone2 (int (*__fn) (void *__arg), + void *__child_stack_base, + size_t __child_stack_size, int __flags, + void *__arg, ...); + p = __clone2 (f, st, sizeof (st), TEST_CLONE_FLAGS, 0); #else - char st[128 * 1024] __attribute__ ((aligned)); # if _STACK_GROWS_DOWN - pid_t p = clone (f, st + sizeof (st), TEST_CLONE_FLAGS, 0); + p = clone (f, st + sizeof (st), TEST_CLONE_FLAGS, 0); # elif _STACK_GROWS_UP - pid_t p = clone (f, st, TEST_CLONE_FLAGS, 0); + p = clone (f, st, TEST_CLONE_FLAGS, 0); # else # error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" # endif #endif + } if (p == -1) { printf("clone failed: %m\n"); @@ -118,5 +142,17 @@ do_test (void) return 0; } +static int +do_test (void) +{ + if (do_test_clone (false) != 0) + return 1; + + if (do_test_clone (true) != 0) + return 1; + + return 0; +} + #define TEST_FUNCTION do_test () #include "../test-skeleton.c" diff --git a/sysdeps/unix/sysv/linux/x86_64/clone3.S b/sysdeps/unix/sysv/linux/x86_64/clone3.S new file mode 100644 index 0000000000..8a7a9a7478 --- /dev/null +++ b/sysdeps/unix/sysv/linux/x86_64/clone3.S @@ -0,0 +1,92 @@ +/* The clone3 syscall wrapper. Linux/x86-64 version. + Copyright (C) 2021 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 + . */ + +/* clone3() is even more special than fork() as it mucks with stacks + and invokes a function in the right context after its all over. */ + +#include +#include + +/* The userland implementation is: + int clone3 (struct clone_args *cl_args, int (*fn)(void *arg), + void *arg); + the kernel entry is: + int clone3 (struct clone_args *cl_args, size_t size); + + The parameters are passed in registers from userland: + rdi: cl_args + rsi: fn + rdx: arg + + The kernel expects: + rax: system call number + rdi: cl_args + rsi: size */ + + .text +ENTRY (__clone3) + /* Sanity check arguments. */ + movq $-EINVAL, %rax + testq %rdi, %rdi /* No NULL cl_args pointer. */ + jz SYSCALL_ERROR_LABEL + testq %rsi, %rsi /* No NULL function pointer. */ + jz SYSCALL_ERROR_LABEL + + /* Save the function pointer in R8 which is preserved by the + syscall. */ + movq %rsi, %r8 + + /* Put sizeof (struct clone_args) in ESI. */ + movl $CLONE_ARGS_SIZE , %esi + + /* Do the system call. */ + movl $SYS_ify(clone3), %eax + + /* End FDE now, because in the child the unwind info will be + wrong. */ + cfi_endproc + syscall + + test %RAX_LP, %RAX_LP + jl SYSCALL_ERROR_LABEL + jz L(thread_start) + + ret + +L(thread_start): + cfi_startproc + /* Clearing frame pointer is insufficient, use CFI. */ + cfi_undefined (rip) + /* Clear the frame pointer. The ABI suggests this be done, to mark + the outermost frame obviously. */ + xorl %ebp, %ebp + + /* Set up arguments for the function call. */ + movq %rdx, %rdi /* Argument. */ + call *%r8 /* Call function. */ + /* Call exit with return value from function call. */ + movq %rax, %rdi + movl $SYS_ify(exit), %eax + syscall + cfi_endproc + + cfi_startproc +PSEUDO_END (__clone3) + +libc_hidden_def (__clone3) +weak_alias (__clone3, clone3) From patchwork Tue May 11 01:43:56 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "H.J. Lu" X-Patchwork-Id: 43364 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 3B2DC386102A; Tue, 11 May 2021 01:44:04 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 3B2DC386102A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1620697444; bh=QP4XYZ5bqnaUEhQthbVA3BTuVnd4Nv7LktCNn8BHgqU=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=b7lkA4ZWTkEN80EmfuowALBwa6numaEQHNetWc6O+Vuu1ABEKYqIREW7GmDytX1VT TC0oE9VQiomqO9gjQ64OWVP0cnNBcWYZOUbQmBziZO92kpwI1RLs0/J8GYx/dDM5Ua I5uzF7kWH+VffdYjrfCsc9OgOJM2BqSbEWR+wUUE= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-pg1-x532.google.com (mail-pg1-x532.google.com [IPv6:2607:f8b0:4864:20::532]) by sourceware.org (Postfix) with ESMTPS id D876A386100B for ; Tue, 11 May 2021 01:43:59 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org D876A386100B Received: by mail-pg1-x532.google.com with SMTP id j12so8561293pgh.7 for ; Mon, 10 May 2021 18:43:59 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=QP4XYZ5bqnaUEhQthbVA3BTuVnd4Nv7LktCNn8BHgqU=; b=JsYnD63e+ikrtuQMlXd1067Pgy1P41Kp8zqZ6s2FaXH9QHnwIgJiujChL6iTpzM3/k YwsiOyk2vFIrTwd9XL8o/SpSi9cG3MSUTeF0NmkDsr6GawiuDURhwaJmMErjYxshRE9h dpIZblq+38a+Y5u2aoqDyfmiM9YqJBmj0Ax9xegZAd0DxPPhFpmcd9yiQWpBpdW9YqTE 7lzOboRT9Sk9hTWowfze34M+vjkenIBEvvmxiERDB84KUR8w9t9PtLxiHG8j1n1y2EgW LJxROX9RZY8UicvcNec3vnJiET1Pa1XDW9R9Zq72hmcWfkqJkUuwHoXySdO0o1OsoNIo MvgA== X-Gm-Message-State: AOAM531YvIiFBVCbjN8uXyzPZkP7Vfzf06lIrL/Ke9h9/iYwdV1blOFn fyT716rlM26Nwi8cH9H4MQQ= X-Google-Smtp-Source: ABdhPJzAaaeP7JudCEgTxUpwjxSzW+aKo18VLLWsG9Lm+uEswFnl61tPtpu/ZPuWbQ0w/SGKdt4hqA== X-Received: by 2002:a62:18d7:0:b029:28c:fdfa:f95b with SMTP id 206-20020a6218d70000b029028cfdfaf95bmr27924582pfy.57.1620697438926; Mon, 10 May 2021 18:43:58 -0700 (PDT) Received: from gnu-cfl-2.localdomain ([172.56.38.197]) by smtp.gmail.com with ESMTPSA id w23sm7294754pfn.63.2021.05.10.18.43.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 May 2021 18:43:58 -0700 (PDT) Received: from gnu-cfl-2.. (localhost [IPv6:::1]) by gnu-cfl-2.localdomain (Postfix) with ESMTP id A3B10C053D; Mon, 10 May 2021 18:43:56 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH v4 2/2] nptl: Always pass stack size to create_thread Date: Mon, 10 May 2021 18:43:56 -0700 Message-Id: <20210511014356.235353-3-hjl.tools@gmail.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210511014356.235353-1-hjl.tools@gmail.com> References: <20210511014356.235353-1-hjl.tools@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3035.0 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: "H.J. Lu via Libc-alpha" From: "H.J. Lu" Reply-To: "H.J. Lu" Cc: Florian Weimer Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" Since the stack size argument for create_thread is now unconditional, always pass stack size to create_thread. --- nptl/allocatestack.c | 59 ++++--------------------------------------- nptl/createthread.c | 3 ++- nptl/pthread_create.c | 17 +++++++------ 3 files changed, 16 insertions(+), 63 deletions(-) diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index 8672e89e75..515d756aa6 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -33,47 +33,6 @@ #include -#ifndef NEED_SEPARATE_REGISTER_STACK - -/* Most architectures have exactly one stack pointer. Some have more. */ -# define STACK_VARIABLES void *stackaddr = NULL - -/* How to pass the values to the 'create_thread' function. */ -# define STACK_VARIABLES_ARGS stackaddr - -/* How to declare function which gets there parameters. */ -# define STACK_VARIABLES_PARMS void *stackaddr - -/* How to declare allocate_stack. */ -# define ALLOCATE_STACK_PARMS void **stack - -/* This is how the function is called. We do it this way to allow - other variants of the function to have more parameters. */ -# define ALLOCATE_STACK(attr, pd) allocate_stack (attr, pd, &stackaddr) - -#else - -/* We need two stacks. The kernel will place them but we have to tell - the kernel about the size of the reserved address space. */ -# define STACK_VARIABLES void *stackaddr = NULL; size_t stacksize = 0 - -/* How to pass the values to the 'create_thread' function. */ -# define STACK_VARIABLES_ARGS stackaddr, stacksize - -/* How to declare function which gets there parameters. */ -# define STACK_VARIABLES_PARMS void *stackaddr, size_t stacksize - -/* How to declare allocate_stack. */ -# define ALLOCATE_STACK_PARMS void **stack, size_t *stacksize - -/* This is how the function is called. We do it this way to allow - other variants of the function to have more parameters. */ -# define ALLOCATE_STACK(attr, pd) \ - allocate_stack (attr, pd, &stackaddr, &stacksize) - -#endif - - /* Default alignment of stack. */ #ifndef STACK_ALIGN # define STACK_ALIGN __alignof__ (long double) @@ -361,7 +320,7 @@ advise_stack_range (void *mem, size_t size, uintptr_t pd, size_t guardsize) PDP must be non-NULL. */ static int allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, - ALLOCATE_STACK_PARMS) + void **stack, size_t *stacksize) { struct pthread *pd; size_t size; @@ -709,25 +668,17 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, /* We place the thread descriptor at the end of the stack. */ *pdp = pd; -#if _STACK_GROWS_DOWN void *stacktop; -# if TLS_TCB_AT_TP +#if TLS_TCB_AT_TP /* The stack begins before the TCB and the static TLS block. */ stacktop = ((char *) (pd + 1) - __static_tls_size); -# elif TLS_DTV_AT_TP +#elif TLS_DTV_AT_TP stacktop = (char *) (pd - 1); -# endif +#endif -# ifdef NEED_SEPARATE_REGISTER_STACK + *stacksize = stacktop - pd->stackblock; *stack = pd->stackblock; - *stacksize = stacktop - *stack; -# else - *stack = stacktop; -# endif -#else - *stack = pd->stackblock; -#endif return 0; } diff --git a/nptl/createthread.c b/nptl/createthread.c index 46943b33fe..2ac83111ec 100644 --- a/nptl/createthread.c +++ b/nptl/createthread.c @@ -25,7 +25,8 @@ static int create_thread (struct pthread *pd, const struct pthread_attr *attr, - bool *stopped_start, STACK_VARIABLES_PARMS, bool *thread_ran) + bool *stopped_start, void *stackaddr, size_t stacksize, + bool *thread_ran) { /* If the implementation needs to do some tweaks to the thread after it has been created at the OS level, it can set STOPPED_START here. */ diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c index 775287d0e4..2b33c48fc1 100644 --- a/nptl/pthread_create.c +++ b/nptl/pthread_create.c @@ -205,8 +205,8 @@ static struct rtld_global *__nptl_rtld_global __attribute_used__ be set to true iff the thread actually started up and then got canceled before calling user code (*PD->start_routine). */ static int create_thread (struct pthread *pd, const struct pthread_attr *attr, - bool *stopped_start, STACK_VARIABLES_PARMS, - bool *thread_ran); + bool *stopped_start, void *stackaddr, + size_t stacksize, bool *thread_ran); #include @@ -531,7 +531,8 @@ int __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg) { - STACK_VARIABLES; + void *stackaddr = NULL; + size_t stacksize = 0; /* Avoid a data race in the multi-threaded case. */ if (__libc_single_threaded) @@ -551,7 +552,7 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, } struct pthread *pd = NULL; - int err = ALLOCATE_STACK (iattr, &pd); + int err = allocate_stack (iattr, &pd, &stackaddr, &stacksize); int retval = 0; if (__glibc_unlikely (err != 0)) @@ -696,8 +697,8 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, /* We always create the thread stopped at startup so we can notify the debugger. */ - retval = create_thread (pd, iattr, &stopped_start, - STACK_VARIABLES_ARGS, &thread_ran); + retval = create_thread (pd, iattr, &stopped_start, stackaddr, + stacksize, &thread_ran); if (retval == 0) { /* We retain ownership of PD until (a) (see CONCURRENCY NOTES @@ -728,8 +729,8 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, } } else - retval = create_thread (pd, iattr, &stopped_start, - STACK_VARIABLES_ARGS, &thread_ran); + retval = create_thread (pd, iattr, &stopped_start, stackaddr, + stacksize, &thread_ran); /* Return to the previous signal mask, after creating the new thread. */