@@ -177,6 +177,20 @@ tests-static += tst-tls9-static
tst-tls9-static-ENV = \
LD_LIBRARY_PATH=$(objpfx):$(common-objpfx):$(common-objpfx)dlfcn
+dlmopen-rtld-tests-norm := \
+ tst-dlmopen-rtld-shared1 \
+ tst-dlmopen-rtld-shared2 \
+ tst-dlmopen-rtld-shared3 \
+ tst-dlmopen-rtld-shared4 \
+ tst-dlmopen-rtld-shared5 \
+ tst-dlmopen-rtld-shared6
+
+dlmopen-rtld-tests-uniq := \
+ tst-dlmopen-rtld-unique1 \
+ tst-dlmopen-rtld-unique2 \
+ tst-dlmopen-rtld-unique3 \
+ tst-dlmopen-rtld-unique4
+
tests += restest1 preloadtest loadfail multiload origtest resolvfail \
constload1 order noload filter \
reldep reldep2 reldep3 reldep4 nodelete nodelete2 \
@@ -201,7 +215,9 @@ tests += restest1 preloadtest loadfail multiload origtest resolvfail \
tst-unwind-ctor tst-unwind-main tst-audit13 \
tst-sonamemove-link tst-sonamemove-dlopen tst-dlopen-tlsmodid \
tst-dlopen-self tst-auditmany tst-initfinilazyfail tst-dlopenfail \
- tst-dlopenfail-2
+ tst-dlopenfail-2 \
+ $(dlmopen-rtld-tests-norm) \
+ $(dlmopen-rtld-tests-uniq)
# reldep9
tests-internal += loadtest unload unload2 circleload1 \
neededtest neededtest2 neededtest3 neededtest4 \
@@ -262,6 +278,8 @@ modules-names = testobj1 testobj2 testobj3 testobj4 testobj5 testobj6 \
$(modules-execstack-$(have-z-execstack)) \
tst-dlopenrpathmod tst-deep1mod1 tst-deep1mod2 tst-deep1mod3 \
tst-dlmopen1mod tst-auditmod1 \
+ tst-dlmopen-sharedmod-norm \
+ tst-dlmopen-sharedmod-uniq \
unload3mod1 unload3mod2 unload3mod3 unload3mod4 \
unload4mod1 unload4mod2 unload4mod3 unload4mod4 \
unload6mod1 unload6mod2 unload6mod3 \
@@ -773,6 +791,8 @@ tst-nodelete-uniquemod.so-no-z-defs = yes
tst-nodelete-rtldmod.so-no-z-defs = yes
tst-nodelete-zmod.so-no-z-defs = yes
tst-nodelete2mod.so-no-z-defs = yes
+tst-dlmopen-sharedmod-norm.so-no-z-defs = yes
+tst-dlmopen-sharedmod-uniq.so-no-z-defs = yes
ifeq ($(build-shared),yes)
# Build all the modules even when not actually running test programs.
@@ -1245,6 +1265,26 @@ $(objpfx)tst-dlmopen2.out: $(objpfx)tst-dlmopen1mod.so
$(objpfx)tst-dlmopen3: $(libdl)
$(objpfx)tst-dlmopen3.out: $(objpfx)tst-dlmopen1mod.so
+LDFLAGS-tst-dlmopen-sharedmod-uniq.so = -Wl,--unique-dso
+$(objpfx)tst-dlmopen-sharedmod-norm.so: $(libdl)
+$(objpfx)tst-dlmopen-sharedmod-uniq.so: $(libdl)
+
+dlmopen-rtld-tests-norm-executables := \
+ $(foreach x,$(dlmopen-rtld-tests-norm),$(objpfx)$(x))
+dlmopen-rtld-tests-norm-out := \
+ $(foreach x,$(dlmopen-rtld-tests-norm),$(objpfx)$(x).out)
+
+dlmopen-rtld-tests-uniq-executables := \
+ $(foreach x,$(dlmopen-rtld-tests-uniq),$(objpfx)$(x))
+dlmopen-rtld-tests-uniq-out := \
+ $(foreach x,$(dlmopen-rtld-tests-uniq),$(objpfx)$(x).out)
+
+$(dlmopen-rtld-tests-norm-executables): $(libdl)
+$(dlmopen-rtld-tests-norm-out): $(objpfx)tst-dlmopen-sharedmod-norm.so
+
+$(dlmopen-rtld-tests-uniq-executables): $(libdl)
+$(dlmopen-rtld-tests-uniq-out): $(objpfx)tst-dlmopen-sharedmod-uniq.so
+
$(objpfx)tst-audit1.out: $(objpfx)tst-auditmod1.so
tst-audit1-ENV = LD_AUDIT=$(objpfx)tst-auditmod1.so
new file mode 100644
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <gnu/lib-names.h>
+
+typedef struct
+{
+ const char *name;
+ void *free;
+} dlmopen_testresult;
+
+typedef dlmopen_testresult * (*dlmopen_testfunc) (void);
+
new file mode 100644
@@ -0,0 +1,899 @@
+#pragma once
+
+#include "tst-dlmopen-common.h"
+#include <dl-dtprocnum.h>
+#include <link.h>
+
+#define DSO_DUMMY "$ORIGIN/tst-dlmopen-sharedmod-noop.so"
+#define DSO_NORMAL "$ORIGIN/tst-dlmopen-sharedmod-norm.so"
+#define DSO_UNIQUE "$ORIGIN/tst-dlmopen-sharedmod-uniq.so"
+#define DSO_TESTFN "rtld_shared_testfunc"
+#define DSO_NAMESTUB "tst-dlmopen-sharedmod-"
+#define MAX_NS 16
+#define POISON 0xabad1dea
+
+#define LM_ID_NONE -2
+
+#define END_TESTS { .name = NULL },
+
+#define ERROR(test, fmt, ...) \
+ ({ if (last_test != test) \
+ printf ("FAILED: %s (%s):\n", test->name, test->desc); \
+ printf ("%s @ %d - " fmt, __FILE__, __LINE__, ##__VA_ARGS__); \
+ last_test = test; })
+
+static void *last_test;
+
+typedef enum
+ {
+ NONE = 0,
+ DSO = 1,
+ PROXY = 2,
+ NEW = 4,
+ } dso_type;
+
+typedef struct
+{
+ const char *name;
+ const char *desc;
+ int is_prep_stage;
+ const char *dso_name;
+ int failure;
+
+ struct
+ {
+ const char *dso_path;
+ Lmid_t ns;
+ int flags;
+ } args;
+
+ dso_type preloaded[MAX_NS];
+ dso_type loaded[MAX_NS];
+ dso_type handle_type;
+ Lmid_t handle_ns;
+} dlmopen_test_spec;
+
+struct r_scope_elem
+{
+ struct tst_lm **r_list;
+ unsigned int r_nlist;
+};
+
+/* This is a copy of the first part of the internal definition of
+ struct link_map from <include/link.h>. We use it to check some
+ expected internal state that's not readily accessible via public APIs.
+ */
+struct tst_lm
+ {
+ /* These first few members are part of the protocol with the debugger.
+ This is the same format used in SVR4. */
+
+ ElfW(Addr) l_addr; /* Difference between the address in the ELF
+ file and the addresses in memory. */
+ char *l_name; /* Absolute file name object was found in. */
+ ElfW(Dyn) *l_ld; /* Dynamic section of the shared object. */
+ struct tst_lm *l_next, *l_prev; /* Chain of loaded objects. */
+
+ /* All following members are internal to the dynamic linker.
+ They may change without notice. */
+
+ /* This is an element which is only ever different from a pointer to
+ the very same copy of this type when:
+ - A shallow copy of ld.so is placed in namespaces other than LM_ID_BASE.
+ - An object is proxied into a namespace by dlmopen with RTLD_SHARED. */
+ struct tst_lm *l_real;
+
+ /* Number of the namespace this link map belongs to. */
+ Lmid_t l_ns;
+
+ struct libname_list *l_libname;
+ /* Indexed pointers to dynamic section.
+ [0,DT_NUM) are indexed by the processor-independent tags.
+ [DT_NUM,DT_NUM+DT_THISPROCNUM) are indexed by the tag minus DT_LOPROC.
+ [DT_NUM+DT_THISPROCNUM,DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM) are
+ indexed by DT_VERSIONTAGIDX(tagvalue).
+ [DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM,
+ DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM) are indexed by
+ DT_EXTRATAGIDX(tagvalue).
+ [DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM,
+ DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM+DT_VALNUM) are
+ indexed by DT_VALTAGIDX(tagvalue) and
+ [DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM+DT_VALNUM,
+ DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM+DT_VALNUM+DT_ADDRNUM)
+ are indexed by DT_ADDRTAGIDX(tagvalue), see <elf.h>. */
+
+ ElfW(Dyn) *l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM
+ + DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];
+ const ElfW(Phdr) *l_phdr; /* Pointer to program header table in core. */
+ ElfW(Addr) l_entry; /* Entry point location. */
+ ElfW(Half) l_phnum; /* Number of program header entries. */
+ ElfW(Half) l_ldnum; /* Number of dynamic segment entries. */
+
+ /* Array of DT_NEEDED dependencies and their dependencies, in
+ dependency order for symbol lookup (with and without
+ duplicates). There is no entry before the dependencies have
+ been loaded. */
+ struct r_scope_elem l_searchlist;
+
+ /* We need a special searchlist to process objects marked with
+ DT_SYMBOLIC. */
+ struct r_scope_elem l_symbolic_searchlist;
+
+ /* Dependent object that first caused this object to be loaded. */
+ struct link_map *l_loader;
+
+ /* Array with version names. */
+ struct r_found_version *l_versions;
+ unsigned int l_nversions;
+
+ /* Symbol hash table. */
+ Elf_Symndx l_nbuckets;
+ Elf32_Word l_gnu_bitmask_idxbits;
+ Elf32_Word l_gnu_shift;
+ const ElfW(Addr) *l_gnu_bitmask;
+ union
+ {
+ const Elf32_Word *l_gnu_buckets;
+ const Elf_Symndx *l_chain;
+ };
+ union
+ {
+ const Elf32_Word *l_gnu_chain_zero;
+ const Elf_Symndx *l_buckets;
+ };
+
+ unsigned int l_direct_opencount; /* Reference count for dlopen/dlclose. */
+ enum /* Where this object came from. */
+ {
+ lt_executable, /* The main executable program. */
+ lt_library, /* Library needed by main executable. */
+ lt_loaded /* Extra run-time loaded shared object. */
+ } l_type:2;
+ unsigned int l_relocated:1; /* Nonzero if object's relocations done. */
+ unsigned int l_init_called:1; /* Nonzero if DT_INIT function called. */
+ unsigned int l_global:1; /* Nonzero if object in _dl_global_scope. */
+ unsigned int l_proxy:1; /* Nonzero if object is a shallow copy. */
+ unsigned int l_reserved:2; /* Reserved for internal use. */
+ unsigned int l_phdr_allocated:1; /* Nonzero if the data structure pointed
+ to by `l_phdr' is allocated. */
+ unsigned int l_soname_added:1; /* Nonzero if the SONAME is for sure in
+ the l_libname list. */
+ unsigned int l_faked:1; /* Nonzero if this is a faked descriptor
+ without associated file. */
+ unsigned int l_need_tls_init:1; /* Nonzero if GL(dl_init_static_tls)
+ should be called on this link map
+ when relocation finishes. */
+ unsigned int l_auditing:1; /* Nonzero if the DSO is used in auditing. */
+ unsigned int l_audit_any_plt:1; /* Nonzero if at least one audit module
+ is interested in the PLT interception.*/
+ unsigned int l_removed:1; /* Nozero if the object cannot be used anymore
+ since it is removed. */
+ unsigned int l_contiguous:1; /* Nonzero if inter-segment holes are
+ mprotected or if no holes are present at
+ all. */
+ unsigned int l_symbolic_in_local_scope:1; /* Nonzero if l_local_scope
+ during LD_TRACE_PRELINKING=1
+ contains any DT_SYMBOLIC
+ libraries. */
+ unsigned int l_free_initfini:1; /* Nonzero if l_initfini can be
+ freed, ie. not allocated with
+ the dummy malloc in ld.so. */
+ };
+
+typedef struct { void *handle; Lmid_t ns; } test_handle;
+static test_handle cached_handles[32];
+
+static void
+cache_test_handle (void *handle, Lmid_t ns)
+{
+ int i;
+
+ for (i = 0; i < sizeof(cached_handles)/sizeof(test_handle); i++)
+ if (cached_handles[i].handle == NULL)
+ {
+ cached_handles[i].handle = handle;
+ cached_handles[i].ns = ns;
+ break;
+ }
+}
+
+__attribute__((unused))
+static struct tst_lm *
+link_map_of_dl_handle (void *handle)
+{
+ struct tst_lm *lm = NULL;
+
+ if (dlinfo (handle, RTLD_DI_LINKMAP, &lm) == 0)
+ return lm;
+
+ printf ("dlinfo (LINKMAP) for %s in %s failed: %s\n",
+ LIBC_SO, __func__, dlerror ());
+
+ return NULL;
+}
+
+__attribute__((unused))
+static Lmid_t
+ns_of_dl_handle (void *handle)
+{
+ Lmid_t ns = 0;
+
+ if (dlinfo (handle, RTLD_DI_LMID, &ns) == 0)
+ return ns;
+
+ printf ("dlinfo (LMID) for %s in %s failed: %s\n",
+ LIBC_SO, __func__, dlerror ());
+
+ return -1;
+}
+
+__attribute__((unused))
+static Lmid_t real_ns_of_dl_handle (void *handle)
+{
+ Lmid_t ns = 0;
+ struct tst_lm *lm = link_map_of_dl_handle (handle);
+
+ if (lm == NULL)
+ return -1;
+
+ // printf ("DEBUG: handle %p; LM %p; proxy: %d / %p\n",
+ // handle, lm, lm->l_proxy, lm->l_real);
+
+ if (lm->l_proxy)
+ {
+ // printf ("DEBUG: proxy %p vs real %p\n", lm, lm->l_real);
+ ns = ns_of_dl_handle ((void *) lm->l_real);
+ }
+ else
+ ns = ns_of_dl_handle (handle);
+
+ return ns;
+}
+
+__attribute__((unused))
+static const char *str_soname (const char *name)
+{
+ char *slash = NULL;
+
+ if (name == NULL)
+ return NULL;
+
+ if ((slash = strrchr (name, '/')))
+ return ++slash;
+ else
+ return name;
+}
+
+__attribute__((unused))
+static const char *lm_name (struct tst_lm *lm)
+{
+ if (lm)
+ return lm->l_name;
+
+ return NULL;
+}
+
+
+static int dlm_dso_is_loaded (void *handle)
+{
+ if (handle != RTLD_DEFAULT)
+ {
+#ifdef DEBUG_DSO_LOADCHECK
+ Dl_info sinfo = {};
+#endif
+
+ if (((struct tst_lm *) handle)->l_type != lt_loaded)
+ return 0;
+
+#ifdef DEBUG_DSO_LOADCHECK
+ printf ("checking %p %s for %s\n",
+ handle, ((struct tst_lm *)handle)->l_name, DSO_TESTFN);
+#endif
+
+ void *symbol = dlsym (handle, DSO_TESTFN);
+
+#ifdef DEBUG_DSO_LOADCHECK
+ dladdr (symbol, &sinfo);
+ printf (" -> %s (in %s (%p))\n",
+ sinfo.dli_fname,
+ sinfo.dli_sname,
+ sinfo.dli_saddr);
+#endif
+
+ return symbol ? 1 : 0;
+ }
+
+ for (int i = 0; i < sizeof(cached_handles)/sizeof(test_handle); i++)
+ {
+ if (cached_handles[i].handle == NULL)
+ break;
+
+ if (((struct tst_lm *) cached_handles[i].handle)->l_type != lt_loaded)
+ continue;
+
+#ifdef DEBUG_DSO_LOADCHECK
+ printf ("checking %p %s for %s\n",
+ cached_handles[i].handle,
+ ((struct tst_lm *)cached_handles[i].handle)->l_name,
+ DSO_TESTFN);
+#endif
+
+ if (dlsym (cached_handles[i].handle, DSO_TESTFN) != NULL)
+ return 1;
+ }
+
+ return 0;
+}
+
+static int call_testfunc (dlmopen_test_spec *test, void *handle, Lmid_t expect_ns)
+{
+ Dl_info dli = {};
+ struct tst_lm *lm = NULL;
+ dlmopen_testfunc func = NULL;
+ dlmopen_testresult *result = NULL;
+
+ if (handle != RTLD_DEFAULT)
+ func = dlsym (handle, DSO_TESTFN);
+
+ if (func == NULL)
+ {
+ ERROR (test, "test function %s not found\n", DSO_TESTFN);
+ return 0;
+ }
+
+ result = (func)();
+
+ if (result == NULL)
+ {
+ ERROR (test, "test function %s returned NULL\n", DSO_TESTFN);
+ return 0;
+ }
+
+ dladdr1 (result->free, &dli, (void **)&lm, RTLD_DL_LINKMAP);
+
+ if (lm == NULL)
+ {
+ ERROR (test, "free() implementation from test module is invalid\n");
+ return 0;
+ }
+
+ if (lm->l_ns != expect_ns)
+ {
+ ERROR (test,
+ "free() function from test module was from ns %d, expected %d\n",
+ (int)lm->l_ns, (int)expect_ns);
+ return 0;
+ }
+
+ printf ("%s: %s: %s in ns %d using free() from ns %d: OK\n",
+ test->name, test->args.dso_path, DSO_TESTFN,
+ (int)test->handle_ns, (int)lm->l_ns);
+
+ return 1;
+}
+
+static void *link_map_snapshot_array (void *handle, void *func, Lmid_t ns, size_t *len)
+{
+ struct tst_lm *lm = NULL;
+ struct tst_lm *start = NULL;
+
+ if (len)
+ *len = 0;
+
+ if (handle != NULL)
+ {
+ dlinfo (handle, RTLD_DI_LINKMAP, &lm);
+ }
+ else if (func != NULL)
+ {
+ Dl_info dli = {};
+
+ dladdr1 (func, &dli, (void **)&lm, RTLD_DL_LINKMAP);
+ }
+ else if (ns >= LM_ID_BASE)
+ {
+ for (int i = 0; i < sizeof(cached_handles)/sizeof(test_handle); i++)
+ {
+ if (cached_handles[i].handle == NULL)
+ break;
+
+ if (cached_handles[i].ns != ns)
+ continue;
+
+ dlinfo (cached_handles[i].handle, RTLD_DI_LINKMAP, &lm);
+ break;
+ }
+ }
+
+ if (lm == NULL)
+ return NULL;
+
+ start = lm;
+
+ while (start->l_prev)
+ start = start->l_prev;
+
+ size_t lm_size = 0;
+
+ for (lm = start; lm; lm = lm->l_next)
+ lm_size++;
+
+ struct tst_lm **lm_list = calloc (lm_size + 1, sizeof (struct tst_lm *));
+
+ if (len)
+ *len = lm_size;
+
+ int i = 0;
+
+ for (lm = start; lm; lm = lm->l_next)
+ lm_list[i++] = lm;
+ lm_list[i] = NULL;
+
+ return lm_list;
+}
+
+__attribute__((unused))
+static int search_link_map_array (struct tst_lm **lma, size_t len, void *handle)
+{
+ if (lma == NULL)
+ return 0;
+
+ if (len == 0)
+ return 0;
+
+ struct tst_lm *target = link_map_of_dl_handle (handle);
+
+ for (int i = 0; i < len; i++)
+ {
+ //printf ("searching for %p in <%p>[%d] == %p\n",
+ // handle, lma, i, lma[i]);
+ if (handle == (struct tst_lm *)(lma[i]))
+ return 1;
+
+ if (target->l_proxy)
+ if (target->l_real == (struct tst_lm *)(lma[i]))
+ return 1;
+ }
+
+ return 0;
+}
+
+#ifdef DEBUG_DSO_SEARCH
+#define TRACE2(fmt, ...) \
+ printf (" find-test-dso (%s @ %d): " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#else
+#define TRACE2(fmt, ...)
+#endif
+
+static struct tst_lm *
+find_test_dso_in_link_map_array (struct tst_lm **lma, size_t len)
+{
+ if (lma == NULL)
+ return NULL;
+
+ if (len == 0)
+ return NULL;
+
+ for (int i = 0; i < len; i++)
+ {
+ if (!lma[i] || !lma[i]->l_name)
+ continue;
+
+ TRACE2 ("%p [%d/%d] %s", lma, i, (int)len - 1,
+ lma[i] ? (lma[i]->l_name ?: "???.so") : "NULL" );
+
+ if (lma[i] && lma[i]->l_name)
+ if (strstr (lma[i]->l_name, DSO_NAMESTUB))
+ if (dlsym (lma[i], DSO_TESTFN) != NULL)
+ return (struct tst_lm *)lma[i];
+ }
+
+ return NULL;
+}
+
+__attribute__((unused))
+static void *link_map_list (void *handle, void *func, int *len, Lmid_t *ns)
+{
+ struct tst_lm *lm = NULL;
+ struct tst_lm *start = NULL;
+
+ if (len)
+ *len = 0;
+
+ if (handle != NULL)
+ {
+ dlinfo (handle, RTLD_DI_LINKMAP, &lm);
+ }
+ else if (func != NULL)
+ {
+ Dl_info dli = {};
+
+ dladdr1 (func, &dli, (void **)&lm, RTLD_DL_LINKMAP);
+ }
+
+ if (lm == NULL)
+ return NULL;
+
+ if (ns)
+ *ns = lm->l_ns;
+
+ // rewind to start of link map list:
+ start = lm;
+
+ while (start->l_prev)
+ start = start->l_prev;
+
+ size_t lm_size = 0;
+
+ for (lm = start; lm; lm = lm->l_next)
+ lm_size++;
+
+ if (len)
+ *len = lm_size;
+
+ return start;
+}
+
+#ifdef DEBUG_DLMOPEN_TEST_WRAPPER
+#define TRACE(fmt, ...) \
+ printf ("%s (%s @ %d): " fmt "\n", test->name, __FILE__, __LINE__, ##__VA_ARGS__)
+#else
+#define TRACE(fmt, ...)
+#endif
+
+static int process_test_spec (dlmopen_test_spec *test)
+{
+ void *handle = NULL;
+ size_t lm_before_len[MAX_NS] = { 0 };
+ size_t lm_after_len[MAX_NS] = { 0 };
+ struct tst_lm **lm_before[MAX_NS] = { NULL };
+ struct tst_lm **lm_after[MAX_NS] = { NULL };
+ struct tst_lm *preloads[MAX_NS] = { NULL };
+ int want_preload = 0;
+ int test_status = 0;
+
+ memset (&lm_after[0], 0, sizeof (lm_after));
+ memset (&lm_before[0], 0, sizeof (lm_before));
+ memset (&preloads[0], 0, sizeof (preloads));
+
+ TRACE("BEFORE SNAPSHOTS: %p", &lm_before[0]);
+ TRACE("AFTER SNAPSHOTS: %p", &lm_after[0]);
+ TRACE("preloads : %p", preloads);
+ TRACE("setup done");
+
+ if (test->args.dso_path && *test->args.dso_path && !test->dso_name)
+ test->dso_name = str_soname (test->args.dso_path);
+
+ TRACE("DSO short name: %s", test->dso_name);
+
+ // get the existing link map contents before the test runs:
+ lm_before[0] = link_map_snapshot_array (NULL, process_test_spec,
+ LM_ID_BASE, &lm_before_len[0]);
+ for (int i = 1; i < MAX_NS; i++)
+ lm_before[i] = link_map_snapshot_array (NULL, NULL, i, &lm_before_len[i]);
+
+ TRACE("link map snapshots cached");
+
+ for (int i = 0; i < MAX_NS; i++)
+ {
+ if (test->preloaded[i] & PROXY)
+ {
+ struct tst_lm **lm = lm_before[i];
+ want_preload++;
+
+ if (lm != NULL)
+ for (int j = 0; !preloads[i] && (j < lm_before_len[i]); j++)
+ if (dlm_dso_is_loaded (lm[j]) && lm[j]->l_proxy)
+ preloads[i] = lm[j];
+
+ if (!preloads[i])
+ {
+ ERROR (test,
+ "needed proxy for %s preloaded in NS %d, not found\n",
+ test->dso_name, i);
+ goto cleanup;
+ }
+ }
+ else if (test->preloaded[i] & DSO)
+ {
+ struct tst_lm **lm = lm_before[i];
+ int lm_max = lm_before_len[i];
+ want_preload++;
+
+ if (lm != NULL)
+ for (int j = 0; !preloads[i] && (j < lm_max); j++)
+ {
+ if (dlm_dso_is_loaded (lm[j]) && !lm[j]->l_proxy)
+ preloads[i] = lm[j];
+ }
+ if (!preloads[i])
+ {
+ ERROR (test,
+ "needed %s preloaded in NS %d, not found\n",
+ test->dso_name, i);
+ goto cleanup;
+ }
+ }
+ }
+ TRACE("preload checks (A)");
+
+ if (dlm_dso_is_loaded (RTLD_DEFAULT))
+ {
+ // test DSO module must _not_ be preloaded, and is:
+ if (!want_preload)
+ {
+ ERROR (test, "DSO %s unexpectedly loaded before test\n", test->dso_name);
+ goto cleanup;
+ }
+ }
+ else
+ {
+ // DSO is not loaded, and must be:
+ // In theory we can never see this error as it
+ // should be caught by the preceding preload loop:
+ if (want_preload)
+ {
+ ERROR (test, "DSO %s must be preloaded (and is not)\n", test->args.dso_path);
+ goto cleanup;
+ }
+ }
+ TRACE("preload checks (B)");
+
+ if (!(test->args.flags & (RTLD_NOW|RTLD_LAZY)))
+ test->args.flags |= RTLD_NOW;
+
+ handle = dlmopen (test->args.ns, test->args.dso_path, test->args.flags);
+ TRACE("dlmopen returned %p", handle);
+
+ if (handle == NULL)
+ {
+ const char *status = "failed";
+
+ if (test->failure)
+ {
+ status = "failed (EXPECTED)";
+ test_status = 1;
+
+ printf ("%s: dlmopen(%s, %d, 0x%0x) failed: OK\n",
+ test->name, test->args.dso_path,
+ (int)test->args.ns, (int)test->args.flags);
+ printf ("Returned: %p\n\n", handle);
+
+ goto cleanup;
+ }
+
+ ERROR (test, "");
+
+ if (test->is_prep_stage)
+ printf ("(during setup of preconditions): ");
+ else
+ printf (": ");
+
+ if (test->args.ns == LM_ID_BASE)
+ printf ("dlmopen (LM_ID_BASE, \"%s\", 0x%x) %s: %s\n",
+ test->args.dso_path, test->args.flags, status, dlerror ());
+ else
+ printf ("dlmopen (%d, \"%s\", 0x%x) %s: %s\n",
+ (int)test->args.ns, test->args.dso_path, test->args.flags, status, dlerror ());
+
+ goto cleanup;
+ }
+ else if (test->failure)
+ {
+ ERROR (test, "dlmopen() call should have failed, but did not\n");
+ goto cleanup;
+ }
+
+ TRACE("return status checked");
+
+ if (!dlm_dso_is_loaded (handle))
+ {
+ ERROR (test, "DSO %s (%p) missing function (%s)\n",
+ test->args.dso_path, handle, DSO_TESTFN);
+ goto cleanup;
+ }
+
+ TRACE ("loaded DSO sanity checked");
+
+ Lmid_t hns = ns_of_dl_handle (handle);
+ Lmid_t real_hns = real_ns_of_dl_handle (handle);
+ Lmid_t proxy_ns = 0;
+
+ call_testfunc (test, handle, LM_ID_BASE);
+ TRACE (DSO_TESTFN "called");
+
+ cache_test_handle (handle, hns);
+ TRACE ("handle %p cached (ns %d)", handle, (int)hns);
+
+ // if the real ns was different to the apparent one
+ // then we have a proxy and we need to shuffle the values,
+ // else leave the proxy ns as 0 as an expect.proxy_ns of 0
+ // means we weren't expecting a proxy:
+ if (real_hns != hns)
+ {
+ proxy_ns = hns;
+ hns = real_hns;
+ }
+
+ if (proxy_ns)
+ printf ("Returned: proxy ns:%d (real ns: %d)\n\n", (int)proxy_ns, (int)hns);
+ else
+ printf ("Returned: dso ns:%d\n\n", (int)hns);
+
+ Lmid_t expected;
+ if (test->handle_type & PROXY)
+ expected = proxy_ns;
+ else
+ expected = hns;
+
+ TRACE("check expected ns %d", (int)expected);
+
+ if (test->args.ns == LM_ID_NEWLM)
+ {
+ if (expected <= LM_ID_BASE)
+ {
+ ERROR (test, "DSO should have been in NS > %d, was in %d\n",
+ LM_ID_BASE, (int)expected);
+ goto cleanup;
+ }
+
+ // for any cases where we can't predict
+ // the namespace in advance:
+ if (test->handle_ns == LM_ID_NEWLM)
+ test->handle_ns = expected;
+ }
+ else
+ {
+ if (test->args.ns != expected)
+ {
+ ERROR (test, "DSO should have been in NS %d, was in %d\n",
+ (int)test->args.ns, (int)expected);
+ goto cleanup;
+ }
+ }
+
+ TRACE("ns %d Ok", (int)expected);
+
+ if (test->handle_type & PROXY) // expecting a proxy
+ {
+ if (proxy_ns != 0) // got a proxy
+ {
+ if (test->handle_ns != proxy_ns) // but not in the right place
+ {
+ ERROR (test, "DSO proxy should have been in ns %d, was in %d\n",
+ (int)test->handle_ns, (int)proxy_ns);
+ goto cleanup;
+ }
+ }
+ else // didn't get a proxy
+ {
+ ERROR (test,
+ "DSO should have been a proxy in ns %d,"
+ " was a non-proxy in ns %d\n",
+ (int)test->handle_ns, (int)hns);
+ goto cleanup;
+ }
+ }
+ else // not expecting a proxy
+ {
+ if (proxy_ns > 0)
+ {
+ ERROR (test,
+ "DSO should NOT have been a proxy,"
+ " was a proxy in ns %d (real ns %d)\n",
+ (int)proxy_ns, (int)hns);
+ goto cleanup;
+ }
+
+ if (test->handle_ns != hns)
+ {
+ ERROR (test,
+ "DSO should have been in ns %d,"
+ " was in ns %d\n",
+ (int)test->handle_ns, (int)hns);
+ goto cleanup;
+ }
+ }
+ TRACE ("proxy status Ok");
+
+ // get the new link map contents after the test has run:
+ lm_after[0] = link_map_snapshot_array (NULL, process_test_spec,
+ LM_ID_BASE, &lm_after_len[0]);
+ for (int i = 1; i < MAX_NS; i++)
+ lm_after[i] = link_map_snapshot_array (NULL, NULL, i, &lm_after_len[i]);
+
+ for (int i = 0; i < MAX_NS; i++)
+ {
+ TRACE("checking status of NS %d", i);
+ void *old_handle =
+ find_test_dso_in_link_map_array (lm_before[i], lm_before_len[i]);
+ TRACE ("old handle is %p", old_handle);
+
+ void *new_handle =
+ find_test_dso_in_link_map_array (lm_after[i], lm_after_len[i]);
+ TRACE ("new handle is %p", new_handle);
+
+ if (test->loaded[i] == NONE)
+ {
+ TRACE ("ns %d requirement is NONE", i);
+ if (old_handle != NULL)
+ {
+ ERROR (test,
+ "Unexpected preload DSO %s in ns %d\n",
+ lm_name (old_handle), i);
+ goto cleanup;
+ }
+ if (new_handle != NULL)
+ {
+ ERROR (test, "Unexpected new DSO %s in ns %d\n",
+ lm_name (new_handle), i);
+ goto cleanup;
+ }
+ continue;
+ }
+
+ if (test->loaded[i] & NEW)
+ {
+ TRACE("ns %d requirement is NEW", i);
+ if (old_handle != NULL)
+ {
+ ERROR (test,
+ "DSO in ns %d should have been a new load,"
+ " found to have been preloaded\n", i);
+ goto cleanup;
+ }
+ if (new_handle == NULL)
+ {
+ ERROR (test, "Expected DSO in ns %d, not found\n", i);
+ goto cleanup;
+ }
+ }
+ else
+ {
+ TRACE("ns %d requirement is OLD", i);
+ if (new_handle == NULL)
+ {
+ ERROR (test, "Expected new DSO in ns %d, not found\n", i);
+ goto cleanup;
+ }
+
+ if (old_handle != new_handle)
+ {
+ ERROR (test, "DSO in ns %d changed. This should be impossible, "
+ "sanity check the test code in %s\n", i, __FILE__);
+ goto cleanup;
+ }
+ }
+
+ if (test->loaded[i] & PROXY)
+ {
+ TRACE ("rechecking DSO status in ns %d", i);
+ if (!((struct tst_lm *)new_handle)->l_proxy)
+ {
+ ERROR (test, "DSO in ns %d should be a proxy but is not\n", i);
+ goto cleanup;
+ }
+ }
+ else
+ {
+ TRACE ("rechecking proxy status in ns %d", i);
+ if (((struct tst_lm *)new_handle)->l_proxy)
+ {
+ ERROR (test, "DSO in ns %d should NOT be a proxy but is\n", i);
+ goto cleanup;
+ }
+ }
+ }
+
+ test_status = 1;
+
+ cleanup:
+ for (int i = 0; i < MAX_NS; i++)
+ free (lm_after[i]);
+ for (int i = 0; i < MAX_NS; i++)
+ free (lm_before[i]);
+
+ return test_status;
+}
+
+
new file mode 100644
@@ -0,0 +1,3 @@
+#pragma once
+
+#include "tst-dlmopen-common.h"
new file mode 100644
@@ -0,0 +1,74 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen:0:none--ns0",
+ .desc = "dlmopen as dlopen",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .loaded = { [0] = DSO|NEW },
+ .handle_type = DSO,
+ .handle_ns = LM_ID_BASE,
+ },
+ {
+ .name = "dlmopen:0:ns0--ns0",
+ .desc = "dlmopen a preloaded DSO in the base NS",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO },
+ .handle_type = DSO,
+ .handle_ns = LM_ID_BASE,
+ },
+ {
+ .name = "dlmopen-shared:0:ns0--ns0",
+ .desc = "dlmopen a preloaded DSO in the base NS with RTLD_SHARED",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO },
+ .handle_type = DSO,
+ .handle_ns = LM_ID_BASE,
+ },
+ {
+ .name = "dlmopen:0:ns0--ns1",
+ .desc = "dlmopen a preloaded DSO in the base NS into a new NS",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_NEWLM,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO, [1] = DSO|NEW },
+ .handle_type = DSO,
+ .handle_ns = 1,
+ },
+ {
+ .name = "dlmopen:0:ns0-ns1--ns0-ns1",
+ .desc = "dlmopen a preloaded DSO in the base & secondary NS into the base NS",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .preloaded = { [0] = DSO, [1] = DSO },
+ .loaded = { [0] = DSO, [1] = DSO },
+ .handle_type = DSO,
+ .handle_ns = LM_ID_BASE,
+ },
+ {
+ .name = "dlmopen-shared:0:ns0-ns1--ns0-ns1",
+ .desc = "dlmopen a preloaded DSO in the base & secondary NS into the base NS",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .preloaded = { [0] = DSO, [1] = DSO },
+ .loaded = { [0] = DSO, [1] = DSO },
+ .handle_type = DSO,
+ .handle_ns = LM_ID_BASE,
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,76 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-shared:0:none--ns0",
+ .desc = "dlmopen as dlopen with RTLD_SHARED",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .loaded = { [0] = DSO|NEW },
+ .handle_ns = LM_ID_BASE,
+ .handle_type = DSO,
+ },
+ {
+ .name = "dlmopen-shared:1:ns0--ns0-ns1p",
+ .desc = "dlmopen into a new namespace with the target already in the base NS",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_NEWLM,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO, [1] = PROXY|NEW }
+ },
+ {
+ .name = "dlmopen:0:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen into base NS while proxy already in ns1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ {
+ .name = "dlmopen-shared:0:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen with RTLD_SHARED into base NS while proxy already in ns1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ {
+ .name = "dlmopen:1:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen into NS 1 while proxy already in ns1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = 1,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ {
+ .name = "dlmopen-shared:1:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen with RTLD_SHARED into NS 1 while proxy already in ns1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = 1,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,53 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen:1:none--ns1",
+ .desc = "dlmopen into ns1, no copies preloaded",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_NEWLM,
+ .handle_ns = 1,
+ .handle_type = DSO,
+ .preloaded = { },
+ .loaded = { [1] = DSO|NEW },
+ },
+ {
+ .name = "dlmopen:0:ns1--ns0-ns1",
+ .desc = "dlmopen into ns 0, copy already loaded in ns 1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [1] = DSO },
+ .loaded = { [0] = DSO|NEW, [1] = DSO },
+ },
+ {
+ .name = "dlmopen:1:ns0-ns1--ns1",
+ .desc = "dlmopen into ns 1, copies already in ns 0 and ns 1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = 1,
+ .handle_ns = 1,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO, [1] = DSO },
+ .loaded = { [0] = DSO, [1] = DSO },
+ },
+ {
+ .name = "dlmopen-shared:1:ns0-ns1--ns1",
+ .desc = "dlmopen RTLD_SHARED into ns1 with a DSO already in NS0 and NS1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = 1,
+ .args.flags = RTLD_SHARED,
+ .failure = 1,
+ .preloaded = { [0] = DSO, [1] = DSO },
+ .loaded = { [0] = DSO, [1] = DSO },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,24 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-shared:1:none--ns0-ns1",
+ .desc = "dlmopen a new proxy in ns1 with no preexisting dso in ns0",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_NEWLM,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { },
+ .loaded = { [0] = DSO|NEW, [1] = PROXY|NEW },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,35 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-preload:1:none--ns1",
+ .desc = "preload a DSO into ns1 to prepare for other tests",
+ .is_prep_stage = 1,
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_NEWLM,
+ .handle_ns = 1,
+ .handle_type = DSO,
+ .preloaded = { },
+ .loaded = { [1] = DSO|NEW },
+ },
+ {
+ .name = "dlmopen-shared:0:ns1--ns1-ns0",
+ .desc = "dlmopen RTLD_SHARED into ns0 when preloaded into ns1",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [1] = DSO },
+ .loaded = { [0] = DSO|NEW, [1] = DSO },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,46 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-preload:1:none--ns1",
+ .desc = "preload a DSO into ns1 to prepare for other tests",
+ .is_prep_stage = 1,
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = LM_ID_NEWLM,
+ .handle_ns = 1,
+ .handle_type = DSO,
+ .preloaded = { },
+ .loaded = { [1] = DSO|NEW },
+ },
+ {
+ .name = "dlmopen:1:ns1--ns1",
+ .desc = "dlmopen a dso in ns1 while already loaded there",
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = 1,
+ .handle_ns = 1,
+ .handle_type = DSO,
+ .preloaded = { [1] = DSO },
+ .loaded = { [1] = DSO },
+ },
+ {
+ .name = "dlmopen-shared:1:ns1--ns1",
+ .desc = "dlmopen RTLD_SHARED a dso in ns1 while already loaded there",
+ .failure = 1,
+ .args.dso_path = DSO_NORMAL,
+ .args.ns = 1,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = DSO,
+ .preloaded = { [1] = DSO },
+ .loaded = { [1] = DSO },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,96 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-unique:0:none--ns0",
+ .desc = "dlmopen a DF_1_UNIQUE dso into ns0",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_BASE,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { },
+ .loaded = { [0] = DSO|NEW },
+ },
+ {
+ .name = "dlmopen-unique:0:ns0--ns0",
+ .desc = "dlmopen a DF_1_UNIQUE dso into ns0 while already present",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_BASE,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO },
+ },
+ {
+ .name = "dlmopen-unique-shared:0:ns0--ns0",
+ .desc = "dlmopen RTLD_SHARED a DF_1_UNIQUE dso into ns0 while already present",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO },
+ },
+ {
+ .name = "dlmopen-unique:1:ns0--ns1",
+ .desc = "dlmopen a DF_1_UNIQUE dso into ns1 while present in ns0",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_NEWLM,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO, [1] = PROXY|NEW },
+ },
+ {
+ .name = "dlmopen-unique:0:ns0-ns1p--ns0--ns1p",
+ .desc = "dlmopen a DF_1_UNIQUE dso already in ns0 proxied in ns1",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_BASE,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ {
+ .name = "dlmopen-shared-unique:0:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen RTLD_SHARED a DF_1_UNIQUE dso into ns0 already in ns0 and proxied in ns1",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ {
+ .name = "dlmopen-unique:0:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen a DF_1_UNIQUE dso into ns0 already in ns0 and proxied in ns1",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = 1,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ {
+ .name = "dlmopen-unique:0:ns0-ns1p--ns0-ns1p",
+ .desc = "dlmopen RTLD_SHARED a DF_1_UNIQUE dso into ns0 already in ns0 and proxied in ns1",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = 1,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO, [1] = PROXY },
+ .loaded = { [0] = DSO, [1] = PROXY },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,35 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-shared-unique:0:none--ns0",
+ .desc = "dlmopen RTLD_SHARED a DF_1_UNIQUE dso in the base ns",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_BASE,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 0,
+ .handle_type = DSO,
+ .preloaded = { },
+ .loaded = { [0] = DSO|NEW },
+ },
+ {
+ .name = "dlmopen-shared-unique:1:ns0--ns0-ns1p",
+ .desc = "dlmopen RTLD_SHARED a DF_1_UNIQUE dso into ns1 while present in ns0",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_NEWLM,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { [0] = DSO },
+ .loaded = { [0] = DSO, [1] = PROXY|NEW },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,23 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-unique:1:none--ns0-ns1p",
+ .desc = "dlmopen a DF_1_UNIQUE dso into ns1",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_NEWLM,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { },
+ .loaded = { [0] = DSO|NEW, [1] = PROXY|NEW },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,24 @@
+#include <dlfcn.h>
+#include "tst-dlmopen-main.h"
+
+static dlmopen_test_spec dltest[] =
+ {
+ {
+ .name = "dlmopen-shared-unique:1:none--ns0-ns1p",
+ .desc = "dlmopen a DF_1_UNIQUE dso",
+ .args.dso_path = DSO_UNIQUE,
+ .args.ns = LM_ID_NEWLM,
+ .args.flags = RTLD_SHARED,
+ .handle_ns = 1,
+ .handle_type = PROXY,
+ .preloaded = { },
+ .loaded = { [0] = DSO|NEW, [1] = PROXY|NEW },
+ },
+ END_TESTS
+ };
+
+#include "tst-dlmopen-std-do-test.h"
+
+DEFINE_DLMOPEN_TEST(dltest)
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1,11 @@
+#include "tst-dlmopen-modules.h"
+
+dlmopen_testresult *rtld_shared_testfunc (void)
+{
+ static dlmopen_testresult result;
+
+ result.name = "norm";
+ result.free = free;
+
+ return &result;
+}
new file mode 100644
@@ -0,0 +1,11 @@
+#include "tst-dlmopen-modules.h"
+
+dlmopen_testresult *rtld_shared_testfunc (void)
+{
+ static dlmopen_testresult result;
+
+ result.name = "noop";
+ result.free = free;
+
+ return &result;
+}
new file mode 100644
@@ -0,0 +1,11 @@
+#pragma once
+
+#define DEFINE_DLMOPEN_TEST(x) \
+ static int \
+ do_test (void) \
+ { \
+ for (int i = 0; x[i].name; i++) \
+ if (!process_test_spec (&x[i])) \
+ return 1; \
+ return 0; \
+ }