| /* Test the interaction of fork and robust mutexes. |
| Copyright (C) 2017-2018 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 |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <errno.h> |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <support/check.h> |
| #include <support/test-driver.h> |
| #include <support/xthread.h> |
| #include <support/xunistd.h> |
| #include <sys/mman.h> |
| |
| /* Data shared between processes. */ |
| struct shared |
| { |
| pthread_mutex_t parent_mutex; |
| pthread_mutex_t child_mutex; |
| }; |
| |
| /* These flags control which mutex settings are enabled in the parent |
| and child (separately). */ |
| enum mutex_bits |
| { |
| mutex_pshared = 1, |
| mutex_robust = 2, |
| mutex_pi = 4, |
| mutex_check = 8, |
| |
| /* All bits combined. */ |
| mutex_all_bits = 15, |
| }; |
| |
| static void |
| mutex_init (pthread_mutex_t *mutex, int bits) |
| { |
| pthread_mutexattr_t attr; |
| xpthread_mutexattr_init (&attr); |
| if (bits & mutex_pshared) |
| xpthread_mutexattr_setpshared (&attr, PTHREAD_PROCESS_SHARED); |
| if (bits & mutex_robust) |
| xpthread_mutexattr_setrobust (&attr, PTHREAD_MUTEX_ROBUST); |
| if (bits & mutex_pi) |
| xpthread_mutexattr_setprotocol (&attr, PTHREAD_PRIO_INHERIT); |
| if (bits & mutex_check) |
| xpthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK); |
| xpthread_mutex_init (mutex, &attr); |
| xpthread_mutexattr_destroy (&attr); |
| } |
| |
| static void |
| one_test (int parent_bits, int child_bits, int nonshared_bits, |
| bool lock_nonshared, bool lock_child) |
| { |
| |
| struct shared *shared = xmmap (NULL, sizeof (*shared), |
| PROT_READ | PROT_WRITE, |
| MAP_ANONYMOUS | MAP_SHARED, -1); |
| mutex_init (&shared->parent_mutex, parent_bits); |
| mutex_init (&shared->child_mutex, child_bits); |
| |
| /* Acquire the parent mutex in the parent. */ |
| xpthread_mutex_lock (&shared->parent_mutex); |
| |
| pthread_mutex_t nonshared_mutex; |
| mutex_init (&nonshared_mutex, nonshared_bits); |
| if (lock_nonshared) |
| xpthread_mutex_lock (&nonshared_mutex); |
| |
| pid_t pid = xfork (); |
| if (pid == 0) |
| { |
| /* Child process. */ |
| if (lock_child) |
| xpthread_mutex_lock (&shared->child_mutex); |
| else |
| xmunmap (shared, sizeof (*shared)); |
| if (lock_nonshared) |
| /* Reinitialize the non-shared mutex if it was locked in the |
| parent. */ |
| mutex_init (&nonshared_mutex, nonshared_bits); |
| xpthread_mutex_lock (&nonshared_mutex); |
| /* For robust mutexes, the _exit call will perform the unlock |
| instead. */ |
| if (lock_child && !(child_bits & mutex_robust)) |
| xpthread_mutex_unlock (&shared->child_mutex); |
| _exit (0); |
| } |
| /* Parent process. */ |
| { |
| int status; |
| xwaitpid (pid, &status, 0); |
| TEST_VERIFY (status == 0); |
| } |
| |
| if (parent_bits & mutex_check) |
| /* Test for expected self-deadlock. This is only possible to |
| detect if the mutex is error-checking. */ |
| TEST_VERIFY_EXIT (pthread_mutex_lock (&shared->parent_mutex) == EDEADLK); |
| |
| pid = xfork (); |
| if (pid == 0) |
| { |
| /* Child process. We can perform some checks only if we are |
| dealing with process-shared mutexes. */ |
| if (parent_bits & mutex_pshared) |
| /* It must not be possible to acquire the parent mutex. |
| |
| NB: This check touches a mutex which has been acquired in |
| the parent at fork time, so it might be deemed undefined |
| behavior, pending the resolution of Austin Groups issue |
| 1112. */ |
| TEST_VERIFY_EXIT (pthread_mutex_trylock (&shared->parent_mutex) |
| == EBUSY); |
| if (lock_child && (child_bits & mutex_robust)) |
| { |
| if (!(child_bits & mutex_pshared)) |
| /* No further tests possible. */ |
| _exit (0); |
| TEST_VERIFY_EXIT (pthread_mutex_lock (&shared->child_mutex) |
| == EOWNERDEAD); |
| xpthread_mutex_consistent (&shared->child_mutex); |
| } |
| else |
| /* We did not acquire the lock in the first child process, or |
| we unlocked the mutex again because the mutex is not a |
| robust mutex. */ |
| xpthread_mutex_lock (&shared->child_mutex); |
| xpthread_mutex_unlock (&shared->child_mutex); |
| _exit (0); |
| } |
| /* Parent process. */ |
| { |
| int status; |
| xwaitpid (pid, &status, 0); |
| TEST_VERIFY (status == 0); |
| } |
| |
| if (lock_nonshared) |
| xpthread_mutex_unlock (&nonshared_mutex); |
| xpthread_mutex_unlock (&shared->parent_mutex); |
| xpthread_mutex_destroy (&shared->parent_mutex); |
| xpthread_mutex_destroy (&shared->child_mutex); |
| xpthread_mutex_destroy (&nonshared_mutex); |
| xmunmap (shared, sizeof (*shared)); |
| } |
| |
| static int |
| do_test (void) |
| { |
| for (int parent_bits = 0; parent_bits <= mutex_all_bits; ++parent_bits) |
| for (int child_bits = 0; child_bits <= mutex_all_bits; ++child_bits) |
| for (int nonshared_bits = 0; nonshared_bits <= mutex_all_bits; |
| ++nonshared_bits) |
| for (int lock_nonshared = 0; lock_nonshared < 2; ++lock_nonshared) |
| for (int lock_child = 0; lock_child < 2; ++lock_child) |
| { |
| if (test_verbose) |
| printf ("info: parent_bits=0x%x child_bits=0x%x" |
| " nonshared_bits=0x%x%s%s\n", |
| parent_bits, child_bits, nonshared_bits, |
| lock_nonshared ? " lock_nonshared" : "", |
| lock_child ? " lock_child" : ""); |
| one_test (parent_bits, child_bits, nonshared_bits, |
| lock_nonshared, lock_child); |
| } |
| return 0; |
| } |
| |
| #define TIMEOUT 100 |
| #include <support/test-driver.c> |
