Home | History | Annotate | Line # | Download | only in ld.elf_so
t_tls_extern.c revision 1.12 
      1 /*	$NetBSD: t_tls_extern.c,v 1.12 2023/06/04 01:24:58 joerg Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2023 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26  * POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/types.h>
     30 
     31 #include <atf-c.h>
     32 #include <dlfcn.h>
     33 
     34 #define	ATF_REQUIRE_DL(x)	ATF_REQUIRE_MSG(x, "%s: %s", #x, dlerror())
     35 
     36 enum order {
     37 	DEF_USE_EAGER,
     38 	DEF_USE_LAZY,
     39 	USE_DEF,
     40 	USE_DEF_NOLOAD,
     41 };
     42 
     43 static void
     44 tls_extern(const char *libdef, const char *libuse, enum order order)
     45 {
     46 	void *def, *use;
     47 	int *(*fdef)(void), *(*fuse)(void);
     48 	int *pdef, *puse;
     49 
     50 	(void)dlerror();
     51 
     52 	switch (order) {
     53 	case DEF_USE_EAGER:
     54 		ATF_REQUIRE_DL(def = dlopen(libdef, 0));
     55 		ATF_REQUIRE_DL(fdef = dlsym(def, "fdef"));
     56 		pdef = (*fdef)();
     57 		ATF_REQUIRE_DL(use = dlopen(libuse, 0));
     58 		ATF_REQUIRE_DL(fuse = dlsym(use, "fuse"));
     59 		puse = (*fuse)();
     60 		break;
     61 	case DEF_USE_LAZY:
     62 		ATF_REQUIRE_DL(def = dlopen(libdef, 0));
     63 		ATF_REQUIRE_DL(use = dlopen(libuse, 0));
     64 		goto lazy;
     65 	case USE_DEF:
     66 		ATF_REQUIRE_DL(use = dlopen(libuse, 0));
     67 		ATF_REQUIRE_DL(def = dlopen(libdef, 0));
     68 		goto lazy;
     69 	case USE_DEF_NOLOAD:
     70 		ATF_REQUIRE_DL(use = dlopen(libuse, 0));
     71 		ATF_REQUIRE_DL(def = dlopen(libdef, RTLD_NOLOAD));
     72 lazy:		ATF_REQUIRE_DL(fdef = dlsym(def, "fdef"));
     73 		ATF_REQUIRE_DL(fuse = dlsym(use, "fuse"));
     74 		pdef = (*fdef)();
     75 		puse = (*fuse)();
     76 		break;
     77 	}
     78 
     79 	ATF_CHECK_EQ_MSG(pdef, puse,
     80 	    "%p in defining library != %p in using library",
     81 	    pdef, puse);
     82 }
     83 
     84 ATF_TC(dynamic_abusedef);
     85 ATF_TC_HEAD(dynamic_abusedef, tc)
     86 {
     87 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
     88 	    " loading static use than dynamic def");
     89 }
     90 ATF_TC_BODY(dynamic_abusedef, tc)
     91 {
     92 	tls_extern("libh_def_dynamic.so", "libh_abuse_dynamic.so", USE_DEF);
     93 }
     94 
     95 ATF_TC(dynamic_abusedefnoload);
     96 ATF_TC_HEAD(dynamic_abusedefnoload, tc)
     97 {
     98 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
     99 	    " loading static use then dynamic def with RTLD_NOLOAD");
    100 }
    101 ATF_TC_BODY(dynamic_abusedefnoload, tc)
    102 {
    103 	tls_extern("libh_def_dynamic.so", "libh_abuse_dynamic.so",
    104 	    USE_DEF_NOLOAD);
    105 }
    106 
    107 ATF_TC(dynamic_defabuse_eager);
    108 ATF_TC_HEAD(dynamic_defabuse_eager, tc)
    109 {
    110 	atf_tc_set_md_var(tc, "descr", "dlopen refuses extern __thread for TLS,"
    111 	    " loading dynamic def then static use eagerly");
    112 }
    113 ATF_TC_BODY(dynamic_defabuse_eager, tc)
    114 {
    115 	void *def;
    116 	int *(*fdef)(void);
    117 
    118 	ATF_REQUIRE_DL(def = dlopen("libh_def_dynamic.so", 0));
    119 	ATF_REQUIRE_DL(fdef = dlsym(def, "fdef"));
    120 	(void)(*fdef)();
    121 	ATF_CHECK_EQ_MSG(NULL, dlopen("libh_abuse_dynamic.so", 0),
    122 	    "dlopen failed to detect static-then-dynamic abuse");
    123 }
    124 
    125 ATF_TC(dynamic_defabuse_lazy);
    126 ATF_TC_HEAD(dynamic_defabuse_lazy, tc)
    127 {
    128 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    129 	    " loading dynamic def then static use lazily");
    130 }
    131 ATF_TC_BODY(dynamic_defabuse_lazy, tc)
    132 {
    133 	tls_extern("libh_def_dynamic.so", "libh_abuse_dynamic.so",
    134 	    DEF_USE_LAZY);
    135 }
    136 
    137 ATF_TC(dynamic_defuse_eager);
    138 ATF_TC_HEAD(dynamic_defuse_eager, tc)
    139 {
    140 	atf_tc_set_md_var(tc, "descr", "extern __thread for dynamic TLS works,"
    141 	    " loading def then use eagerly");
    142 }
    143 ATF_TC_BODY(dynamic_defuse_eager, tc)
    144 {
    145 	tls_extern("libh_def_dynamic.so", "libh_use_dynamic.so",
    146 	    DEF_USE_EAGER);
    147 }
    148 
    149 ATF_TC(dynamic_defuse_lazy);
    150 ATF_TC_HEAD(dynamic_defuse_lazy, tc)
    151 {
    152 	atf_tc_set_md_var(tc, "descr", "extern __thread for dynamic TLS works,"
    153 	    " loading def then use lazyly");
    154 }
    155 ATF_TC_BODY(dynamic_defuse_lazy, tc)
    156 {
    157 	tls_extern("libh_def_dynamic.so", "libh_use_dynamic.so",
    158 	    DEF_USE_LAZY);
    159 }
    160 
    161 ATF_TC(dynamic_usedef);
    162 ATF_TC_HEAD(dynamic_usedef, tc)
    163 {
    164 	atf_tc_set_md_var(tc, "descr", "extern __thread for dynamic TLS works,"
    165 	    " loading use then def");
    166 }
    167 ATF_TC_BODY(dynamic_usedef, tc)
    168 {
    169 	tls_extern("libh_def_dynamic.so", "libh_use_dynamic.so",
    170 	    USE_DEF);
    171 }
    172 
    173 ATF_TC(dynamic_usedefnoload);
    174 ATF_TC_HEAD(dynamic_usedefnoload, tc)
    175 {
    176 	atf_tc_set_md_var(tc, "descr", "extern __thread for dynamic TLS works,"
    177 	    " loading use then def with RTLD_NOLOAD");
    178 }
    179 ATF_TC_BODY(dynamic_usedefnoload, tc)
    180 {
    181 	tls_extern("libh_def_dynamic.so", "libh_use_dynamic.so",
    182 	    USE_DEF_NOLOAD);
    183 }
    184 
    185 ATF_TC(static_abusedef);
    186 ATF_TC_HEAD(static_abusedef, tc)
    187 {
    188 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    189 	    " loading dynamic use then static def");
    190 }
    191 ATF_TC_BODY(static_abusedef, tc)
    192 {
    193 	tls_extern("libh_def_static.so", "libh_abuse_static.so", USE_DEF);
    194 }
    195 
    196 ATF_TC(static_abusedefnoload);
    197 ATF_TC_HEAD(static_abusedefnoload, tc)
    198 {
    199 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    200 	    " loading dynamic use then static def with RTLD_NOLOAD");
    201 }
    202 ATF_TC_BODY(static_abusedefnoload, tc)
    203 {
    204 	tls_extern("libh_def_static.so", "libh_abuse_static.so",
    205 	    USE_DEF_NOLOAD);
    206 }
    207 
    208 ATF_TC(static_defabuse_eager);
    209 ATF_TC_HEAD(static_defabuse_eager, tc)
    210 {
    211 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    212 	    " loading static def then dynamic use eagerly");
    213 }
    214 ATF_TC_BODY(static_defabuse_eager, tc)
    215 {
    216 	tls_extern("libh_def_static.so", "libh_abuse_static.so",
    217 	    DEF_USE_EAGER);
    218 }
    219 
    220 ATF_TC(static_defabuse_lazy);
    221 ATF_TC_HEAD(static_defabuse_lazy, tc)
    222 {
    223 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    224 	    " loading static def then dynamic use lazyly");
    225 }
    226 ATF_TC_BODY(static_defabuse_lazy, tc)
    227 {
    228 	tls_extern("libh_def_static.so", "libh_abuse_static.so",
    229 	    DEF_USE_LAZY);
    230 }
    231 
    232 ATF_TC(static_defuse_eager);
    233 ATF_TC_HEAD(static_defuse_eager, tc)
    234 {
    235 	atf_tc_set_md_var(tc, "descr", "extern __thread for static TLS works,"
    236 	    " loading def then use eagerly");
    237 }
    238 ATF_TC_BODY(static_defuse_eager, tc)
    239 {
    240 	tls_extern("libh_def_static.so", "libh_use_static.so",
    241 	    DEF_USE_EAGER);
    242 }
    243 
    244 ATF_TC(static_defuse_lazy);
    245 ATF_TC_HEAD(static_defuse_lazy, tc)
    246 {
    247 	atf_tc_set_md_var(tc, "descr", "extern __thread for static TLS works,"
    248 	    " loading def then use lazyly");
    249 }
    250 ATF_TC_BODY(static_defuse_lazy, tc)
    251 {
    252 	tls_extern("libh_def_static.so", "libh_use_static.so",
    253 	    DEF_USE_LAZY);
    254 }
    255 
    256 ATF_TC(static_usedef);
    257 ATF_TC_HEAD(static_usedef, tc)
    258 {
    259 	atf_tc_set_md_var(tc, "descr", "extern __thread for static TLS works,"
    260 	    " loading use then def");
    261 }
    262 ATF_TC_BODY(static_usedef, tc)
    263 {
    264 	tls_extern("libh_def_static.so", "libh_use_static.so",
    265 	    USE_DEF);
    266 }
    267 
    268 ATF_TC(static_usedefnoload);
    269 ATF_TC_HEAD(static_usedefnoload, tc)
    270 {
    271 	atf_tc_set_md_var(tc, "descr", "extern __thread for static TLS works,"
    272 	    " loading use then def with RTLD_NOLOAD");
    273 }
    274 ATF_TC_BODY(static_usedefnoload, tc)
    275 {
    276 	tls_extern("libh_def_static.so", "libh_use_static.so",
    277 	    USE_DEF_NOLOAD);
    278 }
    279 
    280 ATF_TC(onlydef_dynamic_static_ctor);
    281 ATF_TC_HEAD(onlydef_dynamic_static_ctor, tc)
    282 {
    283 	atf_tc_set_md_var(tc, "descr", "definition-only library,"
    284 	    " dynamic load and use in ctor, then static load fails");
    285 }
    286 ATF_TC_BODY(onlydef_dynamic_static_ctor, tc)
    287 {
    288 
    289 	ATF_REQUIRE_DL(dlopen("libh_onlydef.so", 0));
    290 	ATF_REQUIRE_DL(dlopen("libh_onlyctor_dynamic.so", 0));
    291 	ATF_CHECK_EQ_MSG(NULL, dlopen("libh_onlyuse_static.so", 0),
    292 	    "dlopen failed to detect dynamic-then-static abuse");
    293 }
    294 
    295 ATF_TC(onlydef_dynamic_static_eager);
    296 ATF_TC_HEAD(onlydef_dynamic_static_eager, tc)
    297 {
    298 	atf_tc_set_md_var(tc, "descr", "definition-only library,"
    299 	    " dynamic load and use, then static load fails");
    300 }
    301 ATF_TC_BODY(onlydef_dynamic_static_eager, tc)
    302 {
    303 	void *use_dynamic;
    304 	int *(*fdynamic)(void);
    305 
    306 	ATF_REQUIRE_DL(use_dynamic = dlopen("libh_onlyuse_dynamic.so", 0));
    307 	ATF_REQUIRE_DL(fdynamic = dlsym(use_dynamic, "fdynamic"));
    308 	(void)(*fdynamic)();
    309 	ATF_CHECK_EQ_MSG(NULL, dlopen("libh_onlyuse_static.so", 0),
    310 	    "dlopen failed to detect dynamic-then-static abuse");
    311 }
    312 
    313 ATF_TC(onlydef_dynamic_static_lazy);
    314 ATF_TC_HEAD(onlydef_dynamic_static_lazy, tc)
    315 {
    316 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    317 	    " with definition-only library, dynamic and static load and use");
    318 }
    319 ATF_TC_BODY(onlydef_dynamic_static_lazy, tc)
    320 {
    321 	void *use_dynamic, *use_static;
    322 	int *(*fdynamic)(void), *(*fstatic)(void);
    323 	int *pdynamic, *pstatic;
    324 
    325 	ATF_REQUIRE_DL(use_dynamic = dlopen("libh_onlyuse_dynamic.so", 0));
    326 	ATF_REQUIRE_DL(use_static = dlopen("libh_onlyuse_static.so", 0));
    327 	ATF_REQUIRE_DL(fdynamic = dlsym(use_dynamic, "fdynamic"));
    328 	ATF_REQUIRE_DL(fstatic = dlsym(use_static, "fstatic"));
    329 	pdynamic = (*fdynamic)();
    330 	pstatic = (*fstatic)();
    331 	ATF_CHECK_EQ_MSG(pdynamic, pstatic,
    332 	    "%p in dynamic tls user != %p in static tls user",
    333 	    pdynamic, pstatic);
    334 }
    335 
    336 ATF_TC(onlydef_static_dynamic_eager);
    337 ATF_TC_HEAD(onlydef_static_dynamic_eager, tc)
    338 {
    339 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    340 	    " with definition-only library,"
    341 	    " static load and use, then dynamic load and use");
    342 }
    343 ATF_TC_BODY(onlydef_static_dynamic_eager, tc)
    344 {
    345 	void *use_static, *use_dynamic;
    346 	int *(*fstatic)(void), *(*fdynamic)(void);
    347 	int *pstatic, *pdynamic;
    348 
    349 	ATF_REQUIRE_DL(dlopen("libh_onlydef.so", 0));
    350 	ATF_REQUIRE_DL(use_static = dlopen("libh_onlyuse_static.so", 0));
    351 	ATF_REQUIRE_DL(fstatic = dlsym(use_static, "fstatic"));
    352 	pstatic = (*fstatic)();
    353 	ATF_REQUIRE_DL(use_dynamic = dlopen("libh_onlyuse_dynamic.so", 0));
    354 	ATF_REQUIRE_DL(fdynamic = dlsym(use_dynamic, "fdynamic"));
    355 	pdynamic = (*fdynamic)();
    356 	ATF_CHECK_EQ_MSG(pstatic, pdynamic,
    357 	    "%p in static tls user != %p in dynamic tls user",
    358 	    pstatic, pdynamic);
    359 }
    360 
    361 ATF_TC(onlydef_static_dynamic_lazy);
    362 ATF_TC_HEAD(onlydef_static_dynamic_lazy, tc)
    363 {
    364 	atf_tc_set_md_var(tc, "descr", "extern __thread for TLS works,"
    365 	    " with definition-only library, static and dynamic load and use");
    366 }
    367 ATF_TC_BODY(onlydef_static_dynamic_lazy, tc)
    368 {
    369 	void *use_static, *use_dynamic;
    370 	int *(*fstatic)(void), *(*fdynamic)(void);
    371 	int *pstatic, *pdynamic;
    372 
    373 	ATF_REQUIRE_DL(dlopen("libh_onlydef.so", 0));
    374 	ATF_REQUIRE_DL(use_static = dlopen("libh_onlyuse_static.so", 0));
    375 	ATF_REQUIRE_DL(use_dynamic = dlopen("libh_onlyuse_dynamic.so", 0));
    376 	ATF_REQUIRE_DL(fstatic = dlsym(use_static, "fstatic"));
    377 	ATF_REQUIRE_DL(fdynamic = dlsym(use_dynamic, "fdynamic"));
    378 	pstatic = (*fstatic)();
    379 	pdynamic = (*fdynamic)();
    380 	ATF_CHECK_EQ_MSG(pstatic, pdynamic,
    381 	    "%p in static tls user != %p in dynamic tls user",
    382 	    pstatic, pdynamic);
    383 }
    384 
    385 ATF_TP_ADD_TCS(tp)
    386 {
    387 
    388 	ATF_TP_ADD_TC(tp, dynamic_abusedef);
    389 	ATF_TP_ADD_TC(tp, dynamic_abusedefnoload);
    390 	ATF_TP_ADD_TC(tp, dynamic_defabuse_eager);
    391 	ATF_TP_ADD_TC(tp, dynamic_defabuse_lazy);
    392 	ATF_TP_ADD_TC(tp, dynamic_defuse_eager);
    393 	ATF_TP_ADD_TC(tp, dynamic_defuse_lazy);
    394 	ATF_TP_ADD_TC(tp, dynamic_usedef);
    395 	ATF_TP_ADD_TC(tp, dynamic_usedefnoload);
    396 	ATF_TP_ADD_TC(tp, onlydef_dynamic_static_ctor);
    397 	ATF_TP_ADD_TC(tp, onlydef_dynamic_static_eager);
    398 	ATF_TP_ADD_TC(tp, onlydef_dynamic_static_lazy);
    399 	ATF_TP_ADD_TC(tp, onlydef_static_dynamic_eager);
    400 	ATF_TP_ADD_TC(tp, onlydef_static_dynamic_lazy);
    401 	ATF_TP_ADD_TC(tp, static_abusedef);
    402 	ATF_TP_ADD_TC(tp, static_abusedefnoload);
    403 	ATF_TP_ADD_TC(tp, static_defabuse_eager);
    404 	ATF_TP_ADD_TC(tp, static_defabuse_lazy);
    405 	ATF_TP_ADD_TC(tp, static_defuse_eager);
    406 	ATF_TP_ADD_TC(tp, static_defuse_lazy);
    407 	ATF_TP_ADD_TC(tp, static_usedef);
    408 	ATF_TP_ADD_TC(tp, static_usedefnoload);
    409 	return atf_no_error();
    410 }
    411