From patchwork Mon Jul 20 17:22:40 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Siddhesh Poyarekar X-Patchwork-Id: 7763 Received: (qmail 89670 invoked by alias); 20 Jul 2015 17:23:31 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 89660 invoked by uid 89); 20 Jul 2015 17:23:30 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.7 required=5.0 tests=AWL, BAYES_00, KAM_LAZY_DOMAIN_SECURITY, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com From: "Siddhesh Poyarekar" To: libc-alpha@sourceware.org Cc: roland@hack.frob.com, carlos@redhat.com Subject: [PATCH v7] Remove Linuxism from tst-tls-atexit Date: Mon, 20 Jul 2015 22:52:40 +0530 Message-Id: <1437412960-12587-1-git-send-email-siddhesh@redhat.com> In-Reply-To: <55ACF201.6010505@redhat.com> References: <55ACF201.6010505@redhat.com> The tst-tls-atexit test case searches for its module in /proc/PID/maps to verify that it is unloaded, which is a Linux-specific test. This patch makes the test generic by looking for the library in the link map list in the _r_debug structure. Verified that the test continues to succeed on x86_64. There is a bug in the test case where it calls dlclose once again, which is actually incorrect but still manages to unload the DSO thanks to an existing bug in __tls_call_dtors. This will be fixed in a later patch which also fixes up the __cxa_thread_atexit_impl implementation. I have added a FIXME comment to that call momentarily, which I will remove when I fix the problem. * stdlib/tst-tls-atexit-lib.c (do_foo): Rename to reg_dtor. * stdlib/tst-tls-atexit.c: (is_loaded): New function. (spawn_thread): New function. (load): Rename to reg_dtor_and_close. Move dlopen to... (do_test): ... here. Use IS_LOADED to test for its availability. --- stdlib/tst-tls-atexit-lib.c | 2 +- stdlib/tst-tls-atexit.c | 96 +++++++++++++++++++++++++-------------------- 2 files changed, 55 insertions(+), 43 deletions(-) diff --git a/stdlib/tst-tls-atexit-lib.c b/stdlib/tst-tls-atexit-lib.c index 2945379..2478d80 100644 --- a/stdlib/tst-tls-atexit-lib.c +++ b/stdlib/tst-tls-atexit-lib.c @@ -31,7 +31,7 @@ void A_dtor (void *obj) ((A *)obj)->val = obj; } -void do_foo (void) +void reg_dtor (void) { static __thread A b; __cxa_thread_atexit_impl (A_dtor, &b, __dso_handle); diff --git a/stdlib/tst-tls-atexit.c b/stdlib/tst-tls-atexit.c index 0c6c499..cea655d 100644 --- a/stdlib/tst-tls-atexit.c +++ b/stdlib/tst-tls-atexit.c @@ -16,10 +16,12 @@ License along with the GNU C Library; if not, see . */ -/* There are two tests in this test case. The first is implicit where it is - assumed that the destructor call on exit of the LOAD function does not - segfault. The other is a verification that after the thread has exited, a - dlclose will unload the DSO. */ +/* This test dynamically loads a DSO and spawns a thread that subsequently + calls into the DSO to register a destructor for an object in the DSO and + then calls dlclose on the handle for the DSO. When the thread exits, the + DSO should not be unloaded or else the destructor called during thread exit + will crash. Further in the main thread, the DSO is opened and closed again, + at which point the DSO should be unloaded. */ #include #include @@ -27,44 +29,53 @@ #include #include #include +#include -void *handle; +#define DSO_NAME "$ORIGIN/tst-tls-atexit-lib.so" -void * -load (void *u) +/* Walk through the map in the _r_debug structure to see if our lib is still + loaded. */ +static bool +is_loaded (void) { - handle = dlopen ("$ORIGIN/tst-tls-atexit-lib.so", RTLD_LAZY); - if (handle == NULL) - { - printf ("Unable to load DSO: %s\n", dlerror ()); - return (void *) (uintptr_t) 1; - } + struct link_map *lm = (struct link_map *) _r_debug.r_map; - void (*foo) (void) = (void (*) (void)) dlsym (handle, "do_foo"); + for (; lm; lm = lm->l_next) + if (lm->l_type == lt_loaded && lm->l_name + && strcmp (basename (DSO_NAME), basename (lm->l_name)) == 0) + return true; + return false; +} + +/* Accept a valid handle returned by DLOPEN, load the reg_dtor symbol to + register a destructor and then call dlclose on the handle. The dlclose + should not unload the DSO since the destructor has not been called yet. */ +static void * +reg_dtor_and_close (void *h) +{ + void (*reg_dtor) (void) = (void (*) (void)) dlsym (h, "reg_dtor"); - if (foo == NULL) + if (reg_dtor == NULL) { printf ("Unable to find symbol: %s\n", dlerror ()); - exit (1); + return (void *) (uintptr_t) 1; } - foo (); + reg_dtor (); - /* This should not unload the DSO. If it does, then the thread exit will - result in a segfault. */ - dlclose (handle); + dlclose (h); return NULL; } static int -do_test (void) +spawn_thread (void *h) { pthread_t t; int ret; void *thr_ret; - if ((ret = pthread_create (&t, NULL, load, NULL)) != 0) + if ((ret = pthread_create (&t, NULL, reg_dtor_and_close, h)) != 0) { printf ("pthread_create failed: %s\n", strerror (ret)); return 1; @@ -79,30 +90,31 @@ do_test (void) if (thr_ret != NULL) return 1; - /* Now this should unload the DSO. */ - dlclose (handle); - - /* Run through our maps and ensure that the DSO is unloaded. */ - FILE *f = fopen ("/proc/self/maps", "r"); + return 0; +} - if (f == NULL) +static int +do_test (void) +{ + /* Load the DSO. */ + void *h1 = dlopen (DSO_NAME, RTLD_LAZY); + if (h1 == NULL) { - perror ("Failed to open /proc/self/maps"); - fprintf (stderr, "Skipping verification of DSO unload\n"); - return 0; + printf ("h1: Unable to load DSO: %s\n", dlerror ()); + return 1; } - char *line = NULL; - size_t s = 0; - while (getline (&line, &s, f) > 0) - { - if (strstr (line, "tst-tls-atexit-lib.so")) - { - printf ("DSO not unloaded yet:\n%s", line); - return 1; - } - } - free (line); + if (spawn_thread (h1) != 0) + return 1; + + /* Now this should unload the DSO. FIXME: This is a bug, calling dlclose + like this is actually wrong, but it works because cxa_thread_atexit_impl + has a bug which results in dlclose allowing this to work. */ + dlclose (h1); + + /* Check link maps to ensure that the DSO has unloaded. */ + if (is_loaded ()) + return 1; return 0; }