Changeset f356618 in mainline for uspace/app/dltest/dltest.c

Timestamp:

2016-05-22T21:05:55Z (9 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b3364b7c

Parents:

af2254ec (diff), 3a9414e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge dynamic linking support for thread local storage.

File:

• uspace/app/dltest/dltest.c (modified) (14 diffs)

uspace/app/dltest/dltest.c

@@ -43 +43 @@
 
 /** libdltest library handle */
-void *handle;
+static void *handle;
+
+/** If true, do not run dlfcn tests */
+static bool no_dlfcn = false;
 
 /** Test dlsym() function */
@@ -93 +96 @@
 {
         int (*p_dl_get_private_var)(void);
+        int *(*p_dl_get_private_var_addr)(void);
         int val;
 
@@ -103 +107 @@
         }
 
+        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 +133 @@
 {
         int (*p_dl_get_private_uvar)(void);
+        int *(*p_dl_get_private_uvar_addr)(void);
         int val;
 
@@ -131 +144 @@
         }
 
+        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 +170 @@
 {
         int (*p_dl_get_public_var)(void);
+        int *(*p_dl_get_public_var_addr)(void);
         int val;
 
@@ -159 +181 @@
         }
 
+        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 +207 @@
 {
         int (*p_dl_get_public_uvar)(void);
+        int *(*p_dl_get_public_uvar_addr)(void);
         int val;
 
@@ -187 +218 @@
         }
 
+        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 +244 @@
 {
         int *p_dl_public_var;
+        int *(*p_dl_get_public_var_addr)(void);
         int val;
 
@@ -215 +255 @@
         }
 
+        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 +282 @@
 {
         int *p_dl_public_uvar;
+        int *(*p_dl_get_public_uvar_addr)(void);
         int val;
 
@@ -243 +293 @@
         }
 
+        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 +870 @@
                 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;