From 714da1d4eac32400187255254dd40334b48b80f3 Mon Sep 17 00:00:00 2001 From: Florian Weimer Date: Fri, 15 May 2020 11:26:37 +0200 Subject: nptl: Replace some stubs with the Linux implementation The stubs for pthread_getaffinity_np, pthread_getname_np, pthread_setaffinity_np, pthread_setname_np are replaced, and corresponding tests are moved. After the removal of the NaCl port, nptl is Linux-specific, and the stubs are no longer needed. This effectively reverts commit c76d1ff5149bd03210f2bb8cd64446c51618d016 ("NPTL: Add stubs for Linux-only extension functions."). Reviewed-by: Carlos O'Donell --- nptl/Makefile | 9 +- nptl/pthread_getaffinity.c | 42 ++++- nptl/pthread_getname.c | 49 +++++- nptl/pthread_setaffinity.c | 37 ++++- nptl/pthread_setname.c | 43 +++++- nptl/tst-setgetname.c | 296 ++++++++++++++++++++++++++++++++++++ nptl/tst-thread-affinity-pthread.c | 49 ++++++ nptl/tst-thread-affinity-pthread2.c | 95 ++++++++++++ nptl/tst-thread-affinity-sched.c | 36 +++++ 9 files changed, 626 insertions(+), 30 deletions(-) create mode 100644 nptl/tst-setgetname.c create mode 100644 nptl/tst-thread-affinity-pthread.c create mode 100644 nptl/tst-thread-affinity-pthread2.c create mode 100644 nptl/tst-thread-affinity-sched.c (limited to 'nptl') diff --git a/nptl/Makefile b/nptl/Makefile index ef9a6eb561..5fc45b224b 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -321,14 +321,19 @@ tests = tst-attr2 tst-attr3 tst-default-attr \ tst-thread-exit-clobber tst-minstack-cancel tst-minstack-exit \ tst-minstack-throw \ tst-rwlock-pwn \ - tst-unwind-thread + tst-unwind-thread \ + tst-thread-affinity-pthread \ + tst-thread-affinity-pthread2 \ + tst-thread-affinity-sched \ + tests-container = tst-pthread-getattr tests-internal := tst-robustpi8 tst-rwlock19 tst-rwlock20 \ tst-sem11 tst-sem12 tst-sem13 \ tst-barrier5 tst-signal7 tst-mutex8 tst-mutex8-static \ - tst-mutexpi8 tst-mutexpi8-static tst-cancel25 + tst-mutexpi8 tst-mutexpi8-static tst-cancel25 \ + tst-setgetname \ xtests = tst-setuid1 tst-setuid1-static tst-setuid2 \ tst-mutexpp1 tst-mutexpp6 tst-mutexpp10 diff --git a/nptl/pthread_getaffinity.c b/nptl/pthread_getaffinity.c index 2ba05b5b92..cf6ecfe01f 100644 --- a/nptl/pthread_getaffinity.c +++ b/nptl/pthread_getaffinity.c @@ -1,6 +1,6 @@ -/* Get the processor affinity of a thread. Stub version. - Copyright (C) 2014-2020 Free Software Foundation, Inc. +/* Copyright (C) 2003-2020 Free Software Foundation, Inc. This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2003. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -16,17 +16,43 @@ License along with the GNU C Library; if not, see . */ +#include +#include #include +#include +#include +#include +#include +#include + int -__pthread_getaffinity_np (pthread_t th, size_t cpusetsize, cpu_set_t *cpuset) +__pthread_getaffinity_new (pthread_t th, size_t cpusetsize, cpu_set_t *cpuset) { const struct pthread *pd = (const struct pthread *) th; - if (INVALID_TD_P (pd)) - return ESRCH; + int res = INTERNAL_SYSCALL_CALL (sched_getaffinity, pd->tid, + MIN (INT_MAX, cpusetsize), cpuset); + if (INTERNAL_SYSCALL_ERROR_P (res)) + return INTERNAL_SYSCALL_ERRNO (res); + + /* Clean the rest of the memory the kernel didn't do. */ + memset ((char *) cpuset + res, '\0', cpusetsize - res); + + return 0; +} +strong_alias (__pthread_getaffinity_new, __pthread_getaffinity_np) +versioned_symbol (libpthread, __pthread_getaffinity_new, + pthread_getaffinity_np, GLIBC_2_3_4); - return ENOSYS; + +#if SHLIB_COMPAT (libpthread, GLIBC_2_3_3, GLIBC_2_3_4) +int +__pthread_getaffinity_old (pthread_t th, cpu_set_t *cpuset) +{ + /* The old interface by default assumed a 1024 processor bitmap. */ + return __pthread_getaffinity_new (th, 128, cpuset); } -weak_alias (__pthread_getaffinity_np, pthread_getaffinity_np) -stub_warning (pthread_getaffinity_np) +compat_symbol (libpthread, __pthread_getaffinity_old, pthread_getaffinity_np, + GLIBC_2_3_3); +#endif diff --git a/nptl/pthread_getname.c b/nptl/pthread_getname.c index b771f2ef76..c78cccffd4 100644 --- a/nptl/pthread_getname.c +++ b/nptl/pthread_getname.c @@ -1,5 +1,5 @@ -/* pthread_getname_np -- Get thread name. Stub version. - Copyright (C) 2014-2020 Free Software Foundation, Inc. +/* pthread_getname_np -- Get thread name. Linux version + Copyright (C) 2010-2020 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 @@ -17,16 +17,53 @@ not, see . */ #include +#include #include +#include +#include +#include +#include + +#include + int pthread_getname_np (pthread_t th, char *buf, size_t len) { const struct pthread *pd = (const struct pthread *) th; - if (INVALID_TD_P (pd)) - return ESRCH; + /* Unfortunately the kernel headers do not export the TASK_COMM_LEN + macro. So we have to define it here. */ +#define TASK_COMM_LEN 16 + if (len < TASK_COMM_LEN) + return ERANGE; + + if (pd == THREAD_SELF) + return prctl (PR_GET_NAME, buf) ? errno : 0; + +#define FMT "/proc/self/task/%u/comm" + char fname[sizeof (FMT) + 8]; + sprintf (fname, FMT, (unsigned int) pd->tid); + + int fd = __open64_nocancel (fname, O_RDONLY); + if (fd == -1) + return errno; + + int res = 0; + ssize_t n = TEMP_FAILURE_RETRY (__read_nocancel (fd, buf, len)); + if (n < 0) + res = errno; + else + { + if (buf[n - 1] == '\n') + buf[n - 1] = '\0'; + else if (n == len) + res = ERANGE; + else + buf[n] = '\0'; + } + + __close_nocancel_nostatus (fd); - return ENOSYS; + return res; } -stub_warning (pthread_getname_np) diff --git a/nptl/pthread_setaffinity.c b/nptl/pthread_setaffinity.c index 29bbfb4fb2..b0bd90c324 100644 --- a/nptl/pthread_setaffinity.c +++ b/nptl/pthread_setaffinity.c @@ -1,6 +1,6 @@ -/* Set the processor affinity of a thread. Stub version. - Copyright (C) 2014-2020 Free Software Foundation, Inc. +/* Copyright (C) 2003-2020 Free Software Foundation, Inc. This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2003. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -16,17 +16,38 @@ License along with the GNU C Library; if not, see . */ +#include #include +#include +#include +#include + int -pthread_setaffinity_np (pthread_t th, - size_t cpusetsize, const cpu_set_t *cpuset) +__pthread_setaffinity_new (pthread_t th, size_t cpusetsize, + const cpu_set_t *cpuset) { const struct pthread *pd = (const struct pthread *) th; + int res; + + res = INTERNAL_SYSCALL_CALL (sched_setaffinity, pd->tid, cpusetsize, + cpuset); + + return (INTERNAL_SYSCALL_ERROR_P (res) + ? INTERNAL_SYSCALL_ERRNO (res) + : 0); +} +versioned_symbol (libpthread, __pthread_setaffinity_new, + pthread_setaffinity_np, GLIBC_2_3_4); - if (INVALID_TD_P (pd)) - return ESRCH; - return ENOSYS; +#if SHLIB_COMPAT (libpthread, GLIBC_2_3_3, GLIBC_2_3_4) +int +__pthread_setaffinity_old (pthread_t th, cpu_set_t *cpuset) +{ + /* The old interface by default assumed a 1024 processor bitmap. */ + return __pthread_setaffinity_new (th, 128, cpuset); } -stub_warning (pthread_setaffinity_np) +compat_symbol (libpthread, __pthread_setaffinity_old, pthread_setaffinity_np, + GLIBC_2_3_3); +#endif diff --git a/nptl/pthread_setname.c b/nptl/pthread_setname.c index adfb3e828f..29df46b77c 100644 --- a/nptl/pthread_setname.c +++ b/nptl/pthread_setname.c @@ -1,5 +1,5 @@ -/* pthread_setname_np -- Set thread name. Stub version. - Copyright (C) 2014-2020 Free Software Foundation, Inc. +/* pthread_setname_np -- Set thread name. Linux version + Copyright (C) 2010-2020 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 @@ -17,16 +17,47 @@ not, see . */ #include +#include #include +#include +#include +#include +#include + +#include + int pthread_setname_np (pthread_t th, const char *name) { const struct pthread *pd = (const struct pthread *) th; - if (INVALID_TD_P (pd)) - return ESRCH; + /* Unfortunately the kernel headers do not export the TASK_COMM_LEN + macro. So we have to define it here. */ +#define TASK_COMM_LEN 16 + size_t name_len = strlen (name); + if (name_len >= TASK_COMM_LEN) + return ERANGE; + + if (pd == THREAD_SELF) + return prctl (PR_SET_NAME, name) ? errno : 0; + +#define FMT "/proc/self/task/%u/comm" + char fname[sizeof (FMT) + 8]; + sprintf (fname, FMT, (unsigned int) pd->tid); + + int fd = __open64_nocancel (fname, O_RDWR); + if (fd == -1) + return errno; + + int res = 0; + ssize_t n = TEMP_FAILURE_RETRY (__write_nocancel (fd, name, name_len)); + if (n < 0) + res = errno; + else if (n != name_len) + res = EIO; + + __close_nocancel_nostatus (fd); - return ENOSYS; + return res; } -stub_warning (pthread_setname_np) diff --git a/nptl/tst-setgetname.c b/nptl/tst-setgetname.c new file mode 100644 index 0000000000..c9a6fafb96 --- /dev/null +++ b/nptl/tst-setgetname.c @@ -0,0 +1,296 @@ +/* Test pthread_setname_np and pthread_getname_np. + Copyright (C) 2013-2020 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; see the file COPYING.LIB. If + not, see . */ +#include +#include +#include +#include +#include +#include +#include +#include + +/* New name of process. */ +#define NEW_NAME "setname" + +/* Name of process which is one byte too big + e.g. 17 bytes including null-terminator */ +#define BIG_NAME "....V....X....XV" + +/* Longest name of a process + e.g. 16 bytes including null-terminator. */ +#define LONGEST_NAME "....V....X....X" + +/* One less than longest name with unique + characters to detect modification. */ +#define CANARY_NAME "abcdefghijklmn" + +/* On Linux the maximum length of the name of a task *including* the null + terminator. */ +#define TASK_COMM_LEN 16 + +/* On Linux we can read this task's name from /proc. */ +int +get_self_comm (long tid, char *buf, size_t len) +{ + int res = 0; +#define FMT "/proc/self/task/%lu/comm" + char fname[sizeof (FMT) + 32]; + sprintf (fname, FMT, (unsigned long) tid); + + int fd = open (fname, O_RDONLY); + if (fd == -1) + return errno; + + ssize_t n = read (fd, (void *) buf, len); + if (n < 0) + res = errno; + else + { + if (buf[n - 1] == '\n') + buf[n - 1] = '\0'; + else if (n == len) + res = ERANGE; + else + buf[n] = '\0'; + } + + close (fd); + return res; +} + +int +do_test (int argc, char **argv) +{ + pthread_t self; + int res; + int ret = 0; + char name[TASK_COMM_LEN]; + char name_check[TASK_COMM_LEN]; + + memset (name, '\0', TASK_COMM_LEN); + memset (name_check, '\0', TASK_COMM_LEN); + + /* Test 1: Get the name of the task via pthread_getname_np and /proc + and verify that they both match. */ + self = pthread_self (); + res = pthread_getname_np (self, name, TASK_COMM_LEN); + + if (res == 0) + { + res = get_self_comm (gettid (), name_check, TASK_COMM_LEN); + + if (res == 0) + { + if (strncmp (name, name_check, strlen (BIG_NAME)) == 0) + printf ("PASS: Test 1 - pthread_getname_np and /proc agree.\n"); + else + { + printf ("FAIL: Test 1 - pthread_getname_np and /proc differ" + " i.e. %s != %s\n", name, name_check); + ret++; + } + } + else + { + printf ("FAIL: Test 1 - unable read task name via proc.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 1 - pthread_getname_np failed with error %d\n", res); + ret++; + } + + /* Test 2: Test setting the name and then independently verify it + was set. */ + res = pthread_setname_np (self, NEW_NAME); + + if (res == 0) + { + res = get_self_comm (gettid (), name_check, TASK_COMM_LEN); + if (res == 0) + { + if (strncmp (NEW_NAME, name_check, strlen (BIG_NAME)) == 0) + printf ("PASS: Test 2 - Value used in pthread_setname_np and" + " /proc agree.\n"); + else + { + printf ("FAIL: Test 2 - Value used in pthread_setname_np" + " and /proc differ i.e. %s != %s\n", + NEW_NAME, name_check); + ret++; + } + } + else + { + printf ("FAIL: Test 2 - unable to read task name via proc.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 2 - pthread_setname_np failed with error %d\n", res); + ret++; + } + + /* Test 3: Test setting a name that is one-byte too big. */ + res = pthread_getname_np (self, name, TASK_COMM_LEN); + + if (res == 0) + { + res = pthread_setname_np (self, BIG_NAME); + if (res != 0) + { + if (res == ERANGE) + { + printf ("PASS: Test 3 - pthread_setname_np returned ERANGE" + " for a process name that was too long.\n"); + + /* Verify the old name didn't change. */ + res = get_self_comm (gettid (), name_check, TASK_COMM_LEN); + if (res == 0) + { + if (strncmp (name, name_check, strlen (BIG_NAME)) == 0) + printf ("PASS: Test 3 - Original name unchanged after" + " pthread_setname_np returned ERANGE.\n"); + else + { + printf ("FAIL: Test 3 - Original name changed after" + " pthread_setname_np returned ERANGE" + " i.e. %s != %s\n", + name, name_check); + ret++; + } + } + else + { + printf ("FAIL: Test 3 - unable to read task name.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 3 - Wrong error returned" + " i.e. ERANGE != %d\n", res); + ret++; + } + } + else + { + printf ("FAIL: Test 3 - Too-long name accepted by" + " pthread_setname_np.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 3 - Unable to get original name.\n"); + ret++; + } + + /* Test 4: Verify that setting the longest name works. */ + res = pthread_setname_np (self, LONGEST_NAME); + + if (res == 0) + { + res = get_self_comm (gettid (), name_check, TASK_COMM_LEN); + if (res == 0) + { + if (strncmp (LONGEST_NAME, name_check, strlen (BIG_NAME)) == 0) + printf ("PASS: Test 4 - Longest name set via pthread_setname_np" + " agrees with /proc.\n"); + else + { + printf ("FAIL: Test 4 - Value used in pthread_setname_np and /proc" + " differ i.e. %s != %s\n", LONGEST_NAME, name_check); + ret++; + } + } + else + { + printf ("FAIL: Test 4 - unable to read task name via proc.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 4 - pthread_setname_np failed with error %d\n", res); + ret++; + } + + /* Test 5: Verify that getting a long name into a small buffer fails. */ + strncpy (name, CANARY_NAME, strlen (CANARY_NAME) + 1); + + /* Claim the buffer length is strlen (LONGEST_NAME). This is one character + too small to hold LONGEST_NAME *and* the null terminator. We should get + back ERANGE and name should be unmodified. */ + res = pthread_getname_np (self, name, strlen (LONGEST_NAME)); + + if (res != 0) + { + if (res == ERANGE) + { + if (strncmp (CANARY_NAME, name, strlen (BIG_NAME)) == 0) + { + printf ("PASS: Test 5 - ERANGE and buffer unmodified.\n"); + } + else + { + printf ("FAIL: Test 5 - Original buffer modified.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 5 - Did not return ERANGE for small buffer.\n"); + ret++; + } + } + else + { + printf ("FAIL: Test 5 - Returned name longer than buffer.\n"); + ret++; + } + + /* Test 6: Lastly make sure we can read back the longest name. */ + res = pthread_getname_np (self, name, strlen (LONGEST_NAME) + 1); + + if (res == 0) + { + if (strncmp (LONGEST_NAME, name, strlen (BIG_NAME)) == 0) + { + printf ("PASS: Test 6 - Read back longest name correctly.\n"); + } + else + { + printf ("FAIL: Test 6 - Read \"%s\" instead of longest name.\n", + name); + ret++; + } + } + else + { + printf ("FAIL: Test 6 - pthread_getname_np failed with error %d\n", res); + ret++; + } + + return ret; +} + +#include diff --git a/nptl/tst-thread-affinity-pthread.c b/nptl/tst-thread-affinity-pthread.c new file mode 100644 index 0000000000..388457763d --- /dev/null +++ b/nptl/tst-thread-affinity-pthread.c @@ -0,0 +1,49 @@ +/* Multi-threaded test for pthread_getaffinity_np, pthread_setaffinity_np. + Copyright (C) 2015-2020 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 + +/* Defined for the benefit of tst-skeleton-thread-affinity.c, included + below. */ + +static int +setaffinity (size_t size, const cpu_set_t *set) +{ + int ret = pthread_setaffinity_np (pthread_self (), size, set); + if (ret != 0) + { + errno = ret; + return -1; + } + return 0; +} + +static int +getaffinity (size_t size, cpu_set_t *set) +{ + int ret = pthread_getaffinity_np (pthread_self (), size, set); + if (ret != 0) + { + errno = ret; + return -1; + } + return 0; +} + +#include "tst-skeleton-thread-affinity.c" diff --git a/nptl/tst-thread-affinity-pthread2.c b/nptl/tst-thread-affinity-pthread2.c new file mode 100644 index 0000000000..3dd126fa60 --- /dev/null +++ b/nptl/tst-thread-affinity-pthread2.c @@ -0,0 +1,95 @@ +/* Separate thread test for pthread_getaffinity_np, pthread_setaffinity_np. + Copyright (C) 2015-2020 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 + +/* Defined for the benefit of tst-skeleton-thread-affinity.c, included + below. This variant runs the functions on a separate thread. */ + +struct affinity_access_task +{ + pthread_t thread; + cpu_set_t *set; + size_t size; + bool get; + int result; +}; + +static void * +affinity_access_thread (void *closure) +{ + struct affinity_access_task *task = closure; + if (task->get) + task->result = pthread_getaffinity_np + (task->thread, task->size, task->set); + else + task->result = pthread_setaffinity_np + (task->thread, task->size, task->set); + return NULL; +} + +static int +run_affinity_access_thread (cpu_set_t *set, size_t size, bool get) +{ + struct affinity_access_task task = + { + .thread = pthread_self (), + .set = set, + .size = size, + .get = get + }; + pthread_t thr; + int ret = pthread_create (&thr, NULL, affinity_access_thread, &task); + if (ret != 0) + { + errno = ret; + printf ("error: could not create affinity access thread: %m\n"); + abort (); + } + ret = pthread_join (thr, NULL); + if (ret != 0) + { + errno = ret; + printf ("error: could not join affinity access thread: %m\n"); + abort (); + } + if (task.result != 0) + { + errno = task.result; + return -1; + } + return 0; +} + +static int +setaffinity (size_t size, const cpu_set_t *set) +{ + return run_affinity_access_thread ((cpu_set_t *) set, size, false); +} + +static int +getaffinity (size_t size, cpu_set_t *set) +{ + return run_affinity_access_thread (set, size, true); +} + +#include "tst-skeleton-thread-affinity.c" diff --git a/nptl/tst-thread-affinity-sched.c b/nptl/tst-thread-affinity-sched.c new file mode 100644 index 0000000000..9fe4613a8f --- /dev/null +++ b/nptl/tst-thread-affinity-sched.c @@ -0,0 +1,36 @@ +/* Multi-threaded test for sched_getaffinity_np, sched_setaffinity_np. + Copyright (C) 2015-2020 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 + +/* Defined for the benefit of tst-skeleton-thread-affinity.c, included + below. */ + +static int +getaffinity (size_t size, cpu_set_t *set) +{ + return sched_getaffinity (0, size, set); +} + +static int +setaffinity (size_t size, const cpu_set_t *set) +{ + return sched_setaffinity (0, size, set); +} + +#include "tst-skeleton-thread-affinity.c" -- cgit 1.4.1