Index: uspace/app/dltest/Makefile =================================================================== --- uspace/app/dltest/Makefile (revision af2254ece47fffd627e909e8547dca085773c990) +++ uspace/app/dltest/Makefile (revision 3a9414e69cdbce3cfab8ca582a8a4ecc87c57ea0) @@ -28,5 +28,9 @@ USPACE_PREFIX = ../.. -EXTRA_CFLAGS = -I$(LIBDLTEST_PREFIX) +EXTRA_CFLAGS = -I$(LIBDLTEST_PREFIX) -DDLTEST_LINKED +LIBS = $(LIBDLTEST_PREFIX)/libdltest.so.0.0 +# Need a dynamic link, but possibly still use static libc +LINK_DYNAMIC = y + BINARY = dltest Index: uspace/app/dltest/dltest.c =================================================================== --- uspace/app/dltest/dltest.c (revision af2254ece47fffd627e909e8547dca085773c990) +++ uspace/app/dltest/dltest.c (revision 3a9414e69cdbce3cfab8ca582a8a4ecc87c57ea0) @@ -43,5 +43,8 @@ /** libdltest library handle */ -void *handle; +static void *handle; + +/** If true, do not run dlfcn tests */ +static bool no_dlfcn = false; /** Test dlsym() function */ @@ -93,4 +96,5 @@ { int (*p_dl_get_private_var)(void); + int *(*p_dl_get_private_var_addr)(void); int val; @@ -103,8 +107,16 @@ } + p_dl_get_private_var_addr = dlsym(handle, "dl_get_private_var_addr"); + if (p_dl_get_private_var_addr == NULL) { + printf("FAILED\n"); + return false; + } + val = p_dl_get_private_var(); printf("Got %d, expected %d... ", val, dl_private_var_val); if (val != dl_private_var_val) { + printf("dl_get_private_var_addr -> %p\n", + p_dl_get_private_var_addr()); printf("FAILED\n"); return false; @@ -121,4 +133,5 @@ { int (*p_dl_get_private_uvar)(void); + int *(*p_dl_get_private_uvar_addr)(void); int val; @@ -131,8 +144,16 @@ } + p_dl_get_private_uvar_addr = dlsym(handle, "dl_get_private_uvar_addr"); + if (p_dl_get_private_uvar_addr == NULL) { + printf("FAILED\n"); + return false; + } + val = p_dl_get_private_uvar(); printf("Got %d, expected %d... ", val, 0); if (val != 0) { + printf("dl_get_private_uvar_addr -> %p\n", + p_dl_get_private_uvar_addr()); printf("FAILED\n"); return false; @@ -149,4 +170,5 @@ { int (*p_dl_get_public_var)(void); + int *(*p_dl_get_public_var_addr)(void); int val; @@ -159,8 +181,16 @@ } + p_dl_get_public_var_addr = dlsym(handle, "dl_get_public_var_addr"); + if (p_dl_get_public_var_addr == NULL) { + printf("FAILED\n"); + return false; + } + val = p_dl_get_public_var(); printf("Got %d, expected %d... ", val, dl_public_var_val); if (val != dl_public_var_val) { + printf("dl_get_public_var_addr -> %p\n", + p_dl_get_public_var_addr()); printf("FAILED\n"); return false; @@ -177,4 +207,5 @@ { int (*p_dl_get_public_uvar)(void); + int *(*p_dl_get_public_uvar_addr)(void); int val; @@ -187,8 +218,16 @@ } + p_dl_get_public_uvar_addr = dlsym(handle, "dl_get_public_uvar_addr"); + if (p_dl_get_public_uvar_addr == NULL) { + printf("FAILED\n"); + return false; + } + val = p_dl_get_public_uvar(); printf("Got %d, expected %d... ", val, 0); if (val != 0) { + printf("dl_get_public_uvar_addr -> %p\n", + p_dl_get_public_uvar_addr()); printf("FAILED\n"); return false; @@ -205,4 +244,5 @@ { int *p_dl_public_var; + int *(*p_dl_get_public_var_addr)(void); int val; @@ -215,8 +255,17 @@ } + p_dl_get_public_var_addr = dlsym(handle, "dl_get_public_var_addr"); + if (p_dl_get_public_var_addr == NULL) { + printf("FAILED\n"); + return false; + } + val = *p_dl_public_var; printf("Got %d, expected %d... ", val, dl_public_var_val); if (val != dl_public_var_val) { + printf("&dl_public_var = %p, " + "dl_get_public_var_addr -> %p\n", + p_dl_public_var, p_dl_get_public_var_addr()); printf("FAILED\n"); return false; @@ -233,4 +282,5 @@ { int *p_dl_public_uvar; + int *(*p_dl_get_public_uvar_addr)(void); int val; @@ -243,21 +293,548 @@ } + p_dl_get_public_uvar_addr = dlsym(handle, "dl_get_public_uvar_addr"); + if (p_dl_get_public_uvar_addr == NULL) { + printf("FAILED\n"); + return false; + } + val = *p_dl_public_uvar; printf("Got %d, expected %d... ", val, 0); if (val != 0) { - printf("FAILED\n"); - return false; - } - - printf("Passed\n"); - return true; -} - -int main(int argc, char *argv[]) -{ - - printf("Dynamic linking test\n"); - + printf("&dl_public_uvar = %p, " + "dl_get_public_uvar_addr -> %p\n", + p_dl_public_uvar, p_dl_get_public_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +#ifndef STATIC_EXE + +/** Test calling a function that returns contents of a private initialized + * fibril-local variable. + */ +static bool test_dlfcn_dl_get_private_fib_var(void) +{ + int (*p_dl_get_private_fib_var)(void); + int *(*p_dl_get_private_fib_var_addr)(void); + int val; + + printf("Call dlsym/dl_get_private_fib_var...\n"); + + p_dl_get_private_fib_var = dlsym(handle, "dl_get_private_fib_var"); + if (p_dl_get_private_fib_var == NULL) { + printf("FAILED\n"); + return false; + } + + p_dl_get_private_fib_var_addr = dlsym(handle, "dl_get_private_fib_var_addr"); + if (p_dl_get_private_fib_var_addr == NULL) { + printf("FAILED\n"); + return false; + } + + val = p_dl_get_private_fib_var(); + + printf("Got %d, expected %d... ", val, dl_private_fib_var_val); + if (val != dl_private_fib_var_val) { + printf("dl_get_private_fib_var_addr -> %p\n", + p_dl_get_private_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test calling a function that returns contents of a private uninitialized + * fibril-local variable. + */ +static bool test_dlfcn_dl_get_private_fib_uvar(void) +{ + int (*p_dl_get_private_fib_uvar)(void); + int *(*p_dl_get_private_fib_uvar_addr)(void); + int val; + + printf("Call dlsym/dl_get_private_fib_uvar...\n"); + + p_dl_get_private_fib_uvar = dlsym(handle, "dl_get_private_fib_uvar"); + if (p_dl_get_private_fib_uvar == NULL) { + printf("FAILED\n"); + return false; + } + + p_dl_get_private_fib_uvar_addr = dlsym(handle, "dl_get_private_fib_uvar_addr"); + if (p_dl_get_private_fib_uvar_addr == NULL) { + printf("FAILED\n"); + return false; + } + + val = p_dl_get_private_fib_uvar(); + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("dl_get_private_fib_uvar_addr -> %p\n", + p_dl_get_private_fib_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test calling a function that returns the contents of a public initialized + * fibril-local variable. + */ +static bool test_dlfcn_dl_get_public_fib_var(void) +{ + int (*p_dl_get_public_fib_var)(void); + int *(*p_dl_get_public_fib_var_addr)(void); + int val; + + printf("Call dlsym/dl_get_public_fib_var...\n"); + + p_dl_get_public_fib_var = dlsym(handle, "dl_get_public_fib_var"); + if (p_dl_get_public_fib_var == NULL) { + printf("FAILED\n"); + return false; + } + + p_dl_get_public_fib_var_addr = dlsym(handle, "dl_get_public_fib_var_addr"); + if (p_dl_get_public_fib_var_addr == NULL) { + printf("FAILED\n"); + return false; + } + + val = p_dl_get_public_fib_var(); + + printf("Got %d, expected %d... ", val, dl_public_fib_var_val); + if (val != dl_public_fib_var_val) { + printf("dl_get_public_fib_var_addr -> %p\n", + p_dl_get_public_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test calling a function that returns the contents of a public uninitialized + * fibril-local variable. + */ +static bool test_dlfcn_dl_get_public_fib_uvar(void) +{ + int (*p_dl_get_public_fib_uvar)(void); + int *(*p_dl_get_public_fib_uvar_addr)(void); + int val; + + printf("Call dlsym/dl_get_public_fib_uvar...\n"); + + p_dl_get_public_fib_uvar = dlsym(handle, "dl_get_public_fib_uvar"); + if (p_dl_get_public_fib_uvar == NULL) { + printf("FAILED\n"); + return false; + } + + p_dl_get_public_fib_uvar_addr = dlsym(handle, "dl_get_public_fib_uvar_addr"); + if (p_dl_get_public_fib_uvar_addr == NULL) { + printf("FAILED\n"); + return false; + } + + val = p_dl_get_public_fib_uvar(); + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("dl_get_public_fib_uvar_addr -> %p\n", + p_dl_get_public_fib_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly reading a public initialized fibril-local variable + * whose address was obtained using dlsym. + */ +static bool test_dlfcn_read_public_fib_var(void) +{ + int *p_dl_public_fib_var; + int *(*p_dl_get_public_fib_var_addr)(void); + int val; + + printf("Read dlsym/dl_public_fib_var...\n"); + + p_dl_public_fib_var = dlsym(handle, "dl_public_fib_var"); + if (p_dl_public_fib_var == NULL) { + printf("FAILED\n"); + return false; + } + + p_dl_get_public_fib_var_addr = dlsym(handle, "dl_get_public_fib_var_addr"); + if (p_dl_get_public_fib_var_addr == NULL) { + printf("FAILED\n"); + return false; + } + + val = *p_dl_public_fib_var; + + printf("Got %d, expected %d... ", val, dl_public_fib_var_val); + if (val != dl_public_fib_var_val) { + printf("&dl_public_fib_var = %p, " + "dl_get_public_fib_var_addr -> %p\n", + p_dl_public_fib_var, p_dl_get_public_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly reading a public uninitialized fibril-local variable + * whose address was obtained using dlsym. + */ +static bool test_dlfcn_read_public_fib_uvar(void) +{ + int *p_dl_public_fib_uvar; + int *(*p_dl_get_public_fib_uvar_addr)(void); + int val; + + printf("Read dlsym/dl_public_fib_uvar...\n"); + + p_dl_public_fib_uvar = dlsym(handle, "dl_public_fib_uvar"); + if (p_dl_public_fib_uvar == NULL) { + printf("FAILED\n"); + return false; + } + + p_dl_get_public_fib_uvar_addr = dlsym(handle, "dl_get_public_fib_uvar_addr"); + if (p_dl_get_public_fib_uvar_addr == NULL) { + printf("FAILED\n"); + return false; + } + + val = *p_dl_public_fib_uvar; + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("&dl_public_fib_uvar = %p, " + "dl_get_public_fib_uvar_addr -> %p\n", + p_dl_public_fib_uvar, p_dl_get_public_fib_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +#endif /* STATIC_EXE */ + +#ifdef DLTEST_LINKED + +/** Test directly calling function that returns a constant */ +static bool test_lnk_dl_get_constant(void) +{ + int val; + + printf("Call linked dl_get_constant...\n"); + + val = dl_get_constant(); + + printf("Got %d, expected %d... ", val, dl_constant); + if (val != dl_constant) { + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test dircetly calling a function that returns contents of a private + * initialized variable. + */ +static bool test_lnk_dl_get_private_var(void) +{ + int val; + + printf("Call linked dl_get_private_var...\n"); + + val = dl_get_private_var(); + + printf("Got %d, expected %d... ", val, dl_private_var_val); + if (val != dl_private_var_val) { + printf("dl_get_private_var_addr -> %p\n", + dl_get_private_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test dircetly calling a function that returns contents of a private + * uninitialized variable. + */ +static bool test_lnk_dl_get_private_uvar(void) +{ + int val; + + printf("Call linked dl_get_private_uvar...\n"); + + val = dl_get_private_uvar(); + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("dl_get_private_uvar_addr -> %p\n", + dl_get_private_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly calling a function that returns the contents of a public + * initialized variable. + */ +static bool test_lnk_dl_get_public_var(void) +{ + int val; + + printf("Call linked dl_get_public_var...\n"); + + val = dl_get_public_var(); + + printf("Got %d, expected %d... ", val, dl_public_var_val); + if (val != dl_public_var_val) { + printf("dl_get_public_var_addr -> %p\n", + dl_get_public_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly calling a function that returns the contents of a public + * uninitialized variable. + */ +static bool test_lnk_dl_get_public_uvar(void) +{ + int val; + + printf("Call linked dl_get_public_uvar...\n"); + + val = dl_get_public_uvar(); + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("dl_get_public_uvar_addr -> %p\n", + dl_get_public_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly reading a public initialized variable. */ +static bool test_lnk_read_public_var(void) +{ + int val; + + printf("Read linked dl_public_var...\n"); + + val = dl_public_var; + + printf("Got %d, expected %d... ", val, dl_public_var_val); + if (val != dl_public_var_val) { + printf("&dl_public_var = %p, dl_get_public_var_addr -> %p\n", + &dl_public_var, dl_get_public_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly reading a public uninitialized variable. */ +static bool test_lnk_read_public_uvar(void) +{ + int val; + + printf("Read linked dl_public_uvar...\n"); + + val = dl_public_uvar; + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("&dl_public_uvar = %p, dl_get_public_uvar_addr -> %p\n", + &dl_public_uvar, dl_get_public_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test dircetly calling a function that returns contents of a private + * initialized fibril-local variable. + */ +static bool test_lnk_dl_get_private_fib_var(void) +{ + int val; + + printf("Call linked dl_get_private_fib_var...\n"); + + val = dl_get_private_fib_var(); + + printf("Got %d, expected %d... ", val, dl_private_fib_var_val); + if (val != dl_private_fib_var_val) { + printf("dl_get_private_fib_var_addr -> %p\n", + dl_get_private_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test dircetly calling a function that returns contents of a private + * uninitialized fibril-local variable. + */ +static bool test_lnk_dl_get_private_fib_uvar(void) +{ + int val; + + printf("Call linked dl_get_private_fib_uvar...\n"); + + val = dl_get_private_fib_uvar(); + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("dl_get_private_fib_uvar_addr -> %p\n", + dl_get_private_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly calling a function that returns the contents of a public + * initialized fibril-local variable. + */ +static bool test_lnk_dl_get_public_fib_var(void) +{ + int val; + + printf("Call linked dl_get_public_fib_var...\n"); + + val = dl_get_public_fib_var(); + + printf("Got %d, expected %d... ", val, dl_public_fib_var_val); + if (val != dl_public_fib_var_val) { + printf("dl_get_public_fib_var_addr -> %p\n", + dl_get_public_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly calling a function that returns the contents of a public + * uninitialized fibril-local variable. + */ +static bool test_lnk_dl_get_public_fib_uvar(void) +{ + int val; + + printf("Call linked dl_get_public_fib_uvar...\n"); + + val = dl_get_public_fib_uvar(); + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("dl_get_public_fib_uvar_addr -> %p\n", + dl_get_public_fib_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly reading a public initialized fibril-local variable. */ +static bool test_lnk_read_public_fib_var(void) +{ + int val; + + printf("Read linked dl_public_fib_var...\n"); + + val = dl_public_fib_var; + + printf("Got %d, expected %d... ", val, dl_public_fib_var_val); + if (val != dl_public_fib_var_val) { + printf("&dl_public_fib_var = %p, " + "dl_get_public_fib_var_addr -> %p\n", + &dl_public_fib_var, dl_get_public_fib_var_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +/** Test directly reading a public uninitialized fibril-local variable. */ +static bool test_lnk_read_public_fib_uvar(void) +{ + int val; + + printf("Read linked dl_public_fib_uvar...\n"); + + val = dl_public_fib_uvar; + + printf("Got %d, expected %d... ", val, 0); + if (val != 0) { + printf("&dl_public_fib_uvar = %p, " + "dl_get_public_fib_uvar_addr -> %p\n", + &dl_public_fib_uvar, dl_get_public_fib_uvar_addr()); + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + +#endif /* DLTEST_LINKED */ + +static int test_dlfcn(void) +{ printf("dlopen()... "); handle = dlopen("libdltest.so.0", 0); @@ -293,8 +870,113 @@ return 1; +#ifndef STATIC_EXE + if (!test_dlfcn_dl_get_private_fib_var()) + return 1; + + if (!test_dlfcn_dl_get_private_fib_uvar()) + return 1; + + if (!test_dlfcn_dl_get_public_fib_var()) + return 1; + + if (!test_dlfcn_dl_get_public_fib_uvar()) + return 1; + + if (!test_dlfcn_read_public_fib_var()) + return 1; + + if (!test_dlfcn_read_public_fib_uvar()) + return 1; +#endif /* STATIC_EXE */ + // printf("dlclose()... "); // dlclose(handle); // printf("Passed\n"); + return 0; +} + +#ifdef DLTEST_LINKED + +static int test_lnk(void) +{ + if (!test_lnk_dl_get_constant()) + return 1; + + if (!test_lnk_dl_get_private_var()) + return 1; + + if (!test_lnk_dl_get_private_uvar()) + return 1; + + if (!test_lnk_dl_get_public_var()) + return 1; + + if (!test_lnk_dl_get_public_uvar()) + return 1; + + if (!test_lnk_read_public_var()) + return 1; + + if (!test_lnk_read_public_uvar()) + return 1; + + if (!test_lnk_dl_get_private_fib_var()) + return 1; + + if (!test_lnk_dl_get_private_fib_uvar()) + return 1; + + if (!test_lnk_dl_get_public_fib_var()) + return 1; + + if (!test_lnk_dl_get_public_fib_uvar()) + return 1; + + if (!test_lnk_read_public_fib_var()) + return 1; + + if (!test_lnk_read_public_fib_uvar()) + return 1; + + return 0; +} + +#endif /* DLTEST_LINKED */ + +static void print_syntax(void) +{ + fprintf(stderr, "syntax: dltest [-n]\n"); + fprintf(stderr, "\t-n Do not run dlfcn tests\n"); +} + +int main(int argc, char *argv[]) +{ + printf("Dynamic linking test\n"); + + if (argc > 1) { + if (argc > 2) { + print_syntax(); + return 1; + } + + if (str_cmp(argv[1], "-n") == 0) { + no_dlfcn = true; + } else { + print_syntax(); + return 1; + } + } + + if (!no_dlfcn) { + if (test_dlfcn() != 0) + return 1; + } + +#ifdef DLTEST_LINKED + if (test_lnk() != 0) + return 1; +#endif + printf("All passed.\n"); return 0; Index: uspace/app/dltests/Makefile =================================================================== --- uspace/app/dltests/Makefile (revision 3a9414e69cdbce3cfab8ca582a8a4ecc87c57ea0) +++ uspace/app/dltests/Makefile (revision 3a9414e69cdbce3cfab8ca582a8a4ecc87c57ea0) @@ -0,0 +1,40 @@ +# +# Copyright (c) 2016 Jiri Svoboda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +EXTRA_CFLAGS = -I$(LIBDLTEST_PREFIX) +BINARY = dltests + +SOURCES = \ + dltests.c + +include $(USPACE_PREFIX)/Makefile.common + +ifeq ($(STATIC_BUILD), y) + EXTRA_CFLAGS += -DSTATIC_EXE +endif Index: uspace/app/dltests/dltests.c =================================================================== --- uspace/app/dltests/dltests.c (revision 3a9414e69cdbce3cfab8ca582a8a4ecc87c57ea0) +++ uspace/app/dltests/dltests.c (revision 3a9414e69cdbce3cfab8ca582a8a4ecc87c57ea0) @@ -0,0 +1,1 @@ +../dltest/dltest.c