1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _RTLD_H 28 #define _RTLD_H 29 30 /* 31 * Global include file for the runtime linker. 32 */ 33 #include <time.h> 34 #include <sgs.h> 35 #include <thread.h> 36 #include <synch.h> 37 #include <link.h> 38 #include <sys/avl.h> 39 #include <alist.h> 40 #include <libc_int.h> 41 42 #ifdef _SYSCALL32 43 #include <inttypes.h> 44 #endif 45 46 #ifdef __cplusplus 47 extern "C" { 48 #endif 49 50 51 /* 52 * We use rtld_ino_t instead of ino_t so that we can get 53 * access to large inode values from 32-bit code. 54 */ 55 #ifdef _LP64 56 typedef ino_t rtld_ino_t; 57 #else 58 typedef ino64_t rtld_ino_t; 59 #endif 60 61 62 /* 63 * Linked list of directories or filenames (built from colon separated string). 64 */ 65 typedef struct pnode { 66 const char *p_name; 67 const char *p_oname; 68 size_t p_len; 69 uint_t p_orig; 70 void *p_info; 71 struct pnode *p_next; 72 } Pnode; 73 74 typedef struct rt_map Rt_map; 75 76 /* 77 * A binding descriptor. Establishes the binding relationship between two 78 * objects, the caller (originator) and the dependency (destination). 79 */ 80 typedef struct { 81 Rt_map *b_caller; /* caller (originator) of a binding */ 82 Rt_map *b_depend; /* dependency (destination) of a */ 83 /* binding */ 84 uint_t b_flags; /* relationship of caller to the */ 85 /* dependency */ 86 } Bnd_desc; 87 88 #define BND_NEEDED 0x0001 /* caller NEEDED the dependency */ 89 #define BND_REFER 0x0002 /* caller relocation references the */ 90 /* dependency */ 91 #define BND_FILTER 0x0004 /* pseudo binding to identify filter */ 92 93 /* 94 * Private structure for communication between rtld_db and rtld. 95 * 96 * We must bump the version number when ever an update in one of the 97 * structures/fields that rtld_db reads is updated. This hopefully permits 98 * rtld_db implementations of the future to recognize core files produced on 99 * older systems and deal with these core files accordingly. 100 * 101 * As of version 'RTLD_DB_VERSION <= 2' the following fields were valid for core 102 * file examination (basically the public Link_map): 103 * 104 * ADDR() 105 * NAME() 106 * DYN() 107 * NEXT() 108 * PREV() 109 * 110 * Valid fields for RTLD_DB_VERSION3 111 * 112 * PATHNAME() 113 * PADSTART() 114 * PADIMLEN() 115 * MSIZE() 116 * FLAGS() 117 * FLAGS1() 118 * 119 * Valid fields for RTLD_DB_VERSION4 120 * 121 * TLSMODID() 122 * 123 * Valid fields for RTLD_DB_VERSION5 124 * 125 * Added rtld_flags & FLG_RT_RELOCED to stable flags range 126 * 127 */ 128 #define R_RTLDDB_VERSION1 1 /* base version level - used for core */ 129 /* file examination */ 130 #define R_RTLDDB_VERSION2 2 /* minor revision - not relevant for */ 131 /* core files */ 132 #define R_RTLDDB_VERSION3 3 133 #define R_RTLDDB_VERSION4 4 134 #define R_RTLDDB_VERSION5 5 135 #define R_RTLDDB_VERSION R_RTLDDB_VERSION5 /* current version */ 136 137 typedef struct rtld_db_priv { 138 struct r_debug rtd_rdebug; /* original r_debug structure */ 139 Word rtd_version; /* version no. */ 140 size_t rtd_objpad; /* padding around mmap()ed objects */ 141 List * rtd_dynlmlst; /* pointer to Dynlm_list */ 142 } Rtld_db_priv; 143 144 #ifdef _SYSCALL32 145 typedef struct rtld_db_priv32 { 146 struct r_debug32 rtd_rdebug; /* original r_debug structure */ 147 Elf32_Word rtd_version; /* version no. */ 148 Elf32_Word rtd_objpad; /* padding around mmap()ed objects */ 149 Elf32_Addr rtd_dynlmlst; /* pointer to Dynlm_list */ 150 } Rtld_db_priv32; 151 #endif /* _SYSCALL32 */ 152 153 /* 154 * External function definitions. ld.so.1 must convey information to libc in 155 * regards to threading. libc also provides routines for atexit() and message 156 * localization. libc provides the necessary interfaces via its RTLDINFO 157 * structure and/or later _ld_libc() calls. 158 * 159 * These external functions are maintained for each link-map list, and used 160 * where appropriate. The functions are associated with the object that 161 * provided them, so that should the object be deleted (say, from an alternative 162 * link-map), the functions can be removed. 163 */ 164 typedef struct { 165 Rt_map *lc_lmp; /* function provider */ 166 union { 167 int (*lc_func)(); /* external function pointer */ 168 uintptr_t lc_val; /* external value */ 169 char *lc_ptr; /* external character pointer */ 170 } lc_un; 171 } Lc_desc; 172 173 /* 174 * Link map list definition. Link-maps are used to describe each loaded object. 175 * Lists of these link-maps describe the various namespaces within a process. 176 * The process executable and its dependencies are maintained on the lml_main 177 * list. The runtime linker, and its dependencies are maintained on the 178 * lml_rtld list. Additional lists can be created (see dlmopen()) for such 179 * things as auditors and their dependencies. 180 * 181 * Each link-map list maintains an Alist of one, or more, linked lists of 182 * link-maps. For backward compatibility, the lm_head/lm_tail elements are 183 * initialized to the first linked-list of link-maps: 184 * 185 * Lm_list 186 * ---------- 187 * | lm_tail | ------------------------------------ 188 * | lm_head | -------------------- | 189 * | | | Rt_map | Rt_map 190 * | | | ------ | ------ 191 * | | Alist --> | | |--> | | 192 * | | --------- | | | -- | | 193 * | lm_lists | ----> | | | | | --> | | 194 * | | |---------| | | | | | | 195 * | | | lc_head | -- ------ | ------ 196 * | | | lc_tail | ------------------ 197 * | | |---------| 198 * | lc_head | 199 * | lc_tail | 200 * |---------| 201 * 202 * Multiple link-map lists exist to support the addition of lazy loaded 203 * families, filtee families, and dlopen() families. The intent of these 204 * lists is to insure that a family of objects that are to be loaded are 205 * fully relocatable, and hence usable, before they become part of the main 206 * (al_data[0]) link-map control list. This main link-map control list is 207 * the only list in existence when control is transferred to user code. 208 * 209 * During process initialization, the dynamic executable and its non-lazy 210 * dependencies are maintained on al_data[0]. If a new object is loaded, then 211 * this object is added to the next available control list [1], typically 212 * al_data[1]. Any dependencies of this object that have not already been 213 * loaded are added to the same control list. Once all of the objects on the 214 * new control list have been successfully relocated, the objects are moved from 215 * the new control list to the highest control list to which objects of the new 216 * control list bound to, typically al_data[1] to al_data[0]. 217 * 218 * Each loading scenario can be broken down as follows: 219 * 220 * setup() - only the initial link-map control list is used: 221 * i. create al_data[0] 222 * ii. add new link-map for main on al_data[0] 223 * iii. analyze al_data[0] to add all non-lazy dependencies 224 * iv. relocate al_data[0] dependencies. 225 * 226 * dlopen() - the initiator can only be the initial link-map control list: 227 * i. create al_data[1] from caller al_data[0] 228 * ii. add new link-map for the dlopen'ed object on al_data[1] 229 * iii. analyze al_data[1] to add all non-lazy dependencies 230 * iv. relocate al_data[1] dependencies, and move to al_data[0]. 231 * 232 * filtee and lazy loading processing - the initiator can be any link-map 233 * control list that is being relocated: 234 * i. create al_data[y] from caller al_data[x] 235 * ii. add new link-map for the new object on al_data[y] 236 * iii. analyze al_data[y] to add all non-lazy dependencies 237 * iv. relocate al_data[y] dependencies, and move to al_data[x]. 238 * 239 * This Alist therefore maintains a stack of link-map control lists. The newest 240 * link-map control list can locate symbols within any of the former lists, 241 * however, control is not passed to a former list until the newest lists 242 * processing is complete. Thus, objects can't bind to new objects until they 243 * have been fully analyzed and relocated. 244 * 245 * [1] Note, additional link-map control list creation occurs after the head 246 * link-map object (typically the dynamic executable) has been relocated. This 247 * staging is required to satisfy the binding requirements of copy relocations. 248 * Copy relocations, effectively, transfer the bindings of the copied data 249 * (say _iob in libc.so.1) to the copy location (_iob in the application). 250 * Thus an object that might bind to the original copy data must be redirected 251 * to the copy reference. As the knowledge of a copy relocation having taken 252 * place is only known after relocating the application, link-map control list 253 * additions are suspended until after this relocation has completed. 254 */ 255 typedef struct { 256 Rt_map *lc_head; 257 Rt_map *lc_tail; 258 APlist *lc_now; /* pending promoted bind-now objects */ 259 uint_t lc_flags; 260 } Lm_cntl; 261 262 #define LMC_FLG_ANALYZING 0x01 /* control list is being analyzed */ 263 #define LMC_FLG_RELOCATING 0x02 /* control list is being relocated */ 264 #define LMC_FLG_REANALYZE 0x04 /* repeat analysis (established when */ 265 /* interposers are added */ 266 267 struct lm_list { 268 /* 269 * BEGIN: Exposed to rtld_db - don't move, don't delete 270 */ 271 Rt_map *lm_head; /* linked list pointers to active */ 272 Rt_map *lm_tail; /* link-map list */ 273 APlist *lm_handle; /* not used by rtld_db - but spacing */ 274 /* is required for flags */ 275 Word lm_flags; 276 /* 277 * END: Exposed to rtld_db - don't move, don't delete 278 */ 279 Alist *lm_rti; /* list of RTLDINFO tables */ 280 Audit_list *lm_alp; /* audit list descriptor */ 281 avl_tree_t *lm_fpavl; /* avl tree of objects loaded */ 282 Alist *lm_lists; /* active and pending link-map lists */ 283 char ***lm_environ; /* pointer to environment array */ 284 Word lm_tflags; /* transferable flags */ 285 uint_t lm_obj; /* total number of objs on link-map */ 286 uint_t lm_init; /* new obj since last init processing */ 287 uint_t lm_lazy; /* obj with pending lazy dependencies */ 288 uint_t lm_tls; /* new obj that require TLS */ 289 uint_t lm_lmid; /* unique link-map list identifier, */ 290 char *lm_lmidstr; /* and associated diagnostic string */ 291 APlist *lm_actaudit; /* list of pending audit activity */ 292 Lc_desc lm_lcs[CI_MAX]; /* external libc functions */ 293 }; 294 295 #ifdef _SYSCALL32 296 struct lm_list32 { 297 /* 298 * BEGIN: Exposed to rtld_db - don't move, don't delete 299 */ 300 Elf32_Addr lm_head; 301 Elf32_Addr lm_tail; 302 Elf32_Addr lm_handle; 303 Elf32_Word lm_flags; 304 /* 305 * END: Exposed to rtld_db - don't move, don't delete 306 */ 307 Elf32_Addr lm_rti; 308 Elf32_Addr lm_fpavl; 309 Elf32_Addr lm_lists; 310 Elf32_Addr lm_environ; 311 Elf32_Word lm_tflags; 312 uint_t lm_obj; 313 uint_t lm_init; 314 uint_t lm_lazy; 315 uint_t lm_tls; 316 uint_t lm_lmid; 317 Elf32_Addr lm_lmidstr; 318 Elf32_Addr lm_actaudit; 319 Elf32_Addr lm_lcs[CI_MAX]; 320 }; 321 #endif /* _SYSCALL32 */ 322 323 /* 324 * Possible Link_map list flags (Lm_list.lm_flags) 325 */ 326 /* 327 * BEGIN: Exposed to rtld_db - don't move, don't delete 328 */ 329 #define LML_FLG_BASELM 0x00000001 /* primary link-map */ 330 #define LML_FLG_RTLDLM 0x00000002 /* rtld link-map */ 331 /* 332 * END: Exposed to rtld_db - don't move, don't delete 333 */ 334 #define LML_FLG_NOAUDIT 0x00000004 /* symbol auditing disabled */ 335 #define LML_FLG_PLTREL 0x00000008 /* deferred plt relocation */ 336 /* initialization */ 337 /* (ld.so.1 only) */ 338 #define LML_FLG_HOLDLOCK 0x00000010 /* hold the rtld mutex lock */ 339 #define LML_FLG_ENVIRON 0x00000020 /* environ var initialized */ 340 #define LML_FLG_INTRPOSE 0x00000040 /* interposing objs on list */ 341 #define LML_FLG_LOCAUDIT 0x00000080 /* local auditors exists for */ 342 /* this link-map list */ 343 #define LML_FLG_LOADAVAIL 0x00000100 /* load anything available */ 344 #define LML_FLG_IGNRELERR 0x00000200 /* ignore relocation errors - */ 345 /* internal for crle(1) */ 346 #define LML_FLG_DBNOTIF 0x00000400 /* binding activity going on */ 347 #define LML_FLG_STARTREL 0x00000800 /* relocation started */ 348 #define LML_FLG_ATEXIT 0x00001000 /* atexit processing */ 349 #define LML_FLG_OBJADDED 0x00002000 /* object(s) added */ 350 #define LML_FLG_OBJDELETED 0x00004000 /* object(s) deleted */ 351 #define LML_FLG_OBJREEVAL 0x00008000 /* existing object(s) needs */ 352 /* tsort reevaluation */ 353 #define LML_FLG_NOPENDGLBLAZY 0x00010000 /* no pending, global, lazy */ 354 /* dependencies remain */ 355 #define LML_FLG_INTRPOSETSORT 0x00020000 /* interpose tsorting done */ 356 #define LML_FLG_AUDITNOTIFY 0x00040000 /* audit consistent required */ 357 #define LML_FLG_GROUPSEXIST 0x00080000 /* local groups exist */ 358 359 #define LML_FLG_TRC_LDDSTUB 0x00100000 /* identify lddstub */ 360 #define LML_FLG_TRC_ENABLE 0x00200000 /* tracing enabled (ldd) */ 361 #define LML_FLG_TRC_WARN 0x00400000 /* print warnings for undefs */ 362 #define LML_FLG_TRC_VERBOSE 0x00800000 /* verbose (versioning) trace */ 363 #define LML_FLG_TRC_SEARCH 0x01000000 /* trace search paths */ 364 #define LML_FLG_TRC_UNREF 0x02000000 /* trace unreferenced */ 365 /* dependencies */ 366 #define LML_FLG_TRC_UNUSED 0x04000000 /* trace unused dependencies */ 367 #define LML_FLG_TRC_INIT 0x08000000 /* print .init order */ 368 #define LML_FLG_TRC_NOUNRESWEAK 0x10000000 /* unresolved weak references */ 369 /* are not allowed */ 370 #define LML_FLG_TRC_NOPAREXT 0x20000000 /* unresolved PARENT/EXTERN */ 371 /* references are not */ 372 /* allowed */ 373 #define LML_MSK_TRC 0xfff00000 /* tracing mask */ 374 375 /* 376 * Possible Link_map transferable flags (Lm_list.lm_tflags), i.e., link-map 377 * list flags that can be propagated to any new link-map list created. 378 */ 379 #define LML_TFLG_NOLAZYLD 0x00000001 /* lazy loading disabled */ 380 #define LML_TFLG_NODIRECT 0x00000002 /* direct bindings disabled */ 381 382 #define LML_TFLG_LOADFLTR 0x00000008 /* trigger filtee loading */ 383 384 #define LML_TFLG_AUD_PREINIT 0x00100000 /* preinit (audit) exists */ 385 #define LML_TFLG_AUD_OBJSEARCH 0x00200000 /* objsearch (audit) exists */ 386 #define LML_TFLG_AUD_OBJOPEN 0x00400000 /* objopen (audit) exists */ 387 #define LML_TFLG_AUD_OBJFILTER 0x00800000 /* objfilter (audit) exists */ 388 #define LML_TFLG_AUD_OBJCLOSE 0x01000000 /* objclose (audit) exists */ 389 #define LML_TFLG_AUD_SYMBIND 0x02000000 /* symbind (audit) exists */ 390 #define LML_TFLG_AUD_PLTENTER 0x04000000 /* pltenter (audit) exists */ 391 #define LML_TFLG_AUD_PLTEXIT 0x08000000 /* pltexit (audit) exists */ 392 #define LML_TFLG_AUD_ACTIVITY 0x10000000 /* activity (audit) exists */ 393 394 /* 395 * NOTE: Audit flags have duplicated FLAGS1() values. If more audit flags are 396 * added, update the FLAGS1() reservation FL1_AUD_RS_STR to FL1_AUD_RS_END 397 * defined later. 398 */ 399 #define LML_TFLG_AUD_MASK 0xfff00000 /* audit interfaces mask */ 400 401 /* 402 * Define a Group Handle. 403 * 404 * The capability of ld.so.1 to associate a group of objects, look for symbols 405 * within that group, ensure that groups are isolated from one another (with 406 * regard to relocations), and to unload a group, centers around a handle. This 407 * data structure is tracked from the link-map HANDLE(), and is the structure 408 * returned from dlopen(), and similar object loading capabilities such as 409 * filter/filtee processing. 410 * 411 * A handle keeps track of all the dependencies of the associated object. 412 * These dependencies may be added as objects are lazily loaded. The core 413 * dependencies on the handle are the ldd(1) list of the associated object. 414 * The object assigned the handle, and the parent (or caller) who requested the 415 * handle are also maintained as dependencies on the handle. 416 * 417 * Presently, an object may have two handles, one requested with RTLD_FIRST 418 * and one without. 419 * 420 * A handle may be referenced by any number of parents (callers). A reference 421 * count tracks the number. A dlclose() operation drops the reference count, 422 * and when the count is zero, the handle is used to determine the family of 423 * objects to unload. As bindings may occur to objects on the handle from 424 * other handles, it may not be possible to remove a complete family of 425 * objects or that handle itself. Handles in this state are moved to an orphan 426 * list. A handle on the orphan list is taken off the orphan list if the 427 * associated object is reopened. Otherwise, the handle remains on the orphan 428 * list for the duration of the process. The orphan list is inspected any time 429 * objects are unloaded, to determine if the orphaned objects can also be 430 * unloaded. 431 * 432 * Objects can be dlopened using RTLD_NOW. This attribute requires that all 433 * relocations of the object, and its dependencies are processed immediately, 434 * before return to the caller. Typically, an object is loaded without 435 * RTLD_NOW, and procedure linkage relocations are satisfied when their 436 * associated function is first called. If an object is already loaded, and an 437 * RTLD_NOW request is made, then the object, and its dependencies, most undergo 438 * additional relocation processing. This promotion from lazy binding to 439 * immediate binding is carried out using handles, as the handle defines the 440 * dependencies that must be processed. A temporary handle is created for this 441 * purpose, and is discarded immediately after the promotion operation has been 442 * completed. 443 */ 444 typedef struct { 445 Alist *gh_depends; /* handle dependency list */ 446 Rt_map *gh_ownlmp; /* handle owners link-map */ 447 Lm_list *gh_ownlml; /* handle owners link-map list */ 448 uint_t gh_refcnt; /* handle reference count */ 449 uint_t gh_flags; /* handle flags (GPH_ values) */ 450 } Grp_hdl; 451 452 #define GPH_ZERO 0x0001 /* special handle for dlopen(0) */ 453 #define GPH_LDSO 0x0002 /* special handle for ld.so.1 */ 454 #define GPH_FIRST 0x0004 /* dlsym() can only use originating */ 455 /* dependency */ 456 #define GPH_FILTEE 0x0008 /* handle used to specify a filtee */ 457 #define GPH_INITIAL 0x0010 /* handle is initialized */ 458 #define GPH_NOPENDLAZY 0x0020 /* no pending lazy dependencies */ 459 /* remain for this handle */ 460 461 /* 462 * Define a Group Descriptor. 463 * 464 * Each dependency associated with a group handle is maintained by a group 465 * descriptor. The descriptor defines the associated dependency together with 466 * flags that indicate how the dependency can be used. 467 */ 468 typedef struct { 469 Rt_map * gd_depend; /* dependency */ 470 uint_t gd_flags; /* dependency flags (GPD_ values) */ 471 } Grp_desc; 472 473 #define GPD_DLSYM 0x0001 /* dependency available to dlsym() */ 474 #define GPD_RELOC 0x0002 /* dependency available to satisfy */ 475 /* relocation binding */ 476 #define GPD_ADDEPS 0x0004 /* dependencies of this dependency */ 477 /* should be added to handle */ 478 #define GPD_PARENT 0x0008 /* dependency is a parent */ 479 #define GPD_FILTER 0x0010 /* dependency is our filter */ 480 #define GPD_PROMOTE 0x0020 /* dependency is our RTLD_NOW */ 481 /* promoter */ 482 #define GPD_REMOVE 0x1000 /* descriptor is a candidate for */ 483 /* removal from the group */ 484 485 /* 486 * Define threading structures. For compatibility with libthread (T1_VERSION 1 487 * and TI_VERSION 2) our locking structure is sufficient to hold a mutex or a 488 * readers/writers lock. 489 */ 490 typedef struct { 491 union { 492 mutex_t l_mutex; 493 rwlock_t l_rwlock; 494 } u; 495 } Rt_lock; 496 497 typedef cond_t Rt_cond; 498 499 /* 500 * Define a dynamic section information descriptor. This parallels the entries 501 * in the .dynamic section and holds auxiliary information to implement lazy 502 * loading and filtee processing. 503 */ 504 typedef struct { 505 uint_t di_flags; 506 void *di_info; 507 } Dyninfo; 508 509 #define FLG_DI_STDFLTR 0x00001 /* .dynamic entry for DT_FILTER */ 510 #define FLG_DI_AUXFLTR 0x00002 /* .dynamic entry for DT_AUXILIARY */ 511 #define FLG_DI_SYMFLTR 0x00004 /* .dynamic entry for DT_SYMFILTER */ 512 /* and DT_SYMAUXILIARY */ 513 #define MSK_DI_FILTER 0x0000f /* mask for all filter possibilities */ 514 515 #define FLG_DI_POSFLAG1 0x00010 /* .dynamic entry for DT_POSFLAG_1 */ 516 #define FLG_DI_NEEDED 0x00020 /* .dynamic entry for DT_NEEDED */ 517 #define FLG_DI_LAZY 0x00100 /* lazy needed entry - preceded by */ 518 /* DF_P1_LAZYLOAD (DT_POSFLAG_1) */ 519 #define FLG_DI_GROUP 0x00200 /* group needed entry - preceded by */ 520 /* DF_P1_GROUPPERM (DT_POSFLAG_1) */ 521 522 #define FLG_DI_LDD_DONE 0x01000 /* entry has been processed (ldd) */ 523 #define FLG_DI_LAZYFAIL 0x02000 /* the lazy loading of this entry */ 524 /* failed */ 525 /* 526 * Data structure to track AVL tree of pathnames. This structure provides the 527 * basis of both the "not-found" node tree, and the "full-path" node tree. Both 528 * of these trees persist for the life of a process, although the "not-found" 529 * tree may be moved aside during a dlopen() or dlsym() fall back operation. 530 */ 531 typedef struct { 532 const char *pn_name; /* path name */ 533 avl_node_t pn_avl; /* avl book-keeping (see SGSOFFSETOF) */ 534 uint_t pn_hash; /* path name hash value */ 535 } PathNode; 536 537 /* 538 * Data structure to track AVL tree for full path names of objects that are 539 * loaded into memory. 540 */ 541 typedef struct { 542 PathNode fpn_node; /* path node */ 543 Rt_map *fpn_lmp; /* object link-map */ 544 } FullPathNode; 545 546 /* 547 * Define a mapping structure, which is maintained to describe each mapping 548 * of an object, ie. the text segment, data segment, bss segment, etc. 549 */ 550 typedef struct { 551 caddr_t m_vaddr; /* mapping address */ 552 size_t m_fsize; /* backing file size */ 553 size_t m_msize; /* mapping size */ 554 int m_perm; /* mapping permissions */ 555 } Mmap; 556 557 /* 558 * A given link-map can hold either a supplier or receiver copy 559 * relocation list, but not both. This union is used to overlap 560 * the space used for the two lists. 561 */ 562 typedef union { 563 Alist *rtc_r; /* receiver list (Rel_copy) */ 564 APlist *rtc_s; /* supplier list (Rt_map *) */ 565 } Rt_map_copy; 566 567 568 /* 569 * Link-map definition. 570 */ 571 struct rt_map { 572 /* 573 * BEGIN: Exposed to rtld_db - don't move, don't delete 574 */ 575 Link_map rt_public; /* public data */ 576 char *rt_pathname; /* full pathname of loaded object */ 577 ulong_t rt_padstart; /* start of image (including padding) */ 578 ulong_t rt_padimlen; /* size of image (including padding */ 579 ulong_t rt_msize; /* total memory mapped */ 580 uint_t rt_flags; /* state flags, see FLG below */ 581 uint_t rt_flags1; /* state flags1, see FL1 below */ 582 ulong_t rt_tlsmodid; /* TLS module id */ 583 /* 584 * END: Exposed to rtld_db - don't move, don't delete 585 */ 586 APlist *rt_alias; /* list of linked file names */ 587 APlist *rt_fpnode; /* list of FullpathNode AVL nodes */ 588 void (*rt_init)(); /* address of _init */ 589 void (*rt_fini)(); /* address of _fini */ 590 char *rt_runpath; /* LD_RUN_PATH and its equivalent */ 591 Pnode *rt_runlist; /* Pnode structures */ 592 APlist *rt_depends; /* list of dependencies */ 593 APlist *rt_callers; /* list of callers */ 594 APlist *rt_handles; /* dlopen handles */ 595 APlist *rt_groups; /* groups we're a member of */ 596 ulong_t rt_etext; /* etext address */ 597 struct fct *rt_fct; /* file class table for this object */ 598 Sym *(*rt_symintp)(); /* link map symbol interpreter */ 599 void *rt_priv; /* private data, object type specific */ 600 Lm_list *rt_list; /* link map list we belong to */ 601 uint_t rt_objfltrndx; /* object filtees .dynamic index */ 602 uint_t rt_symsfltrcnt; /* number of standard symbol filtees */ 603 uint_t rt_symafltrcnt; /* number of auxiliary symbol filtees */ 604 int rt_mode; /* usage mode, see RTLD mode flags */ 605 int rt_sortval; /* temporary buffer to traverse graph */ 606 uint_t rt_cycgroup; /* cyclic group */ 607 dev_t rt_stdev; /* device id and inode number for .so */ 608 rtld_ino_t rt_stino; /* multiple inclusion checks */ 609 char *rt_origname; /* original pathname of loaded object */ 610 size_t rt_dirsz; /* and its size */ 611 Rt_map_copy rt_copy; /* list of copy relocations */ 612 Audit_desc *rt_auditors; /* audit descriptor array */ 613 Audit_info *rt_audinfo; /* audit information descriptor */ 614 Syminfo *rt_syminfo; /* elf .syminfo section - here */ 615 /* because it is checked in */ 616 /* common code */ 617 Addr *rt_initarray; /* .initarray table */ 618 Addr *rt_finiarray; /* .finiarray table */ 619 Addr *rt_preinitarray; /* .preinitarray table */ 620 Mmap *rt_mmaps; /* array of mapping information */ 621 uint_t rt_mmapcnt; /* and associated number */ 622 uint_t rt_initarraysz; /* size of .initarray table */ 623 uint_t rt_finiarraysz; /* size of .finiarray table */ 624 uint_t rt_preinitarraysz; /* size of .preinitarray table */ 625 Dyninfo *rt_dyninfo; /* .dynamic information descriptors */ 626 uint_t rt_dyninfocnt; /* count of dyninfo entries */ 627 uint_t rt_relacount; /* no. of RELATIVE relocations */ 628 uint_t rt_idx; /* hold index within linkmap list */ 629 uint_t rt_lazy; /* lazy dependencies pending */ 630 Rt_cond *rt_condvar; /* variables */ 631 Xword rt_hwcap; /* hardware capabilities */ 632 Xword rt_sfcap; /* software capabilities */ 633 thread_t rt_threadid; /* thread init/fini synchronization */ 634 uint_t rt_cntl; /* link-map control list we belong to */ 635 uint_t rt_flags2; /* state flags2, see FL2 below */ 636 }; 637 638 639 #ifdef _SYSCALL32 640 /* 641 * Structure to allow 64-bit rtld_db to read 32-bit processes out of procfs. 642 */ 643 typedef union { 644 uint32_t rtc_r; 645 uint32_t rtc_s; 646 } Rt_map_copy32; 647 648 typedef struct rt_map32 { 649 /* 650 * BEGIN: Exposed to rtld_db - don't move, don't delete 651 */ 652 Link_map32 rt_public; 653 uint32_t rt_pathname; 654 uint32_t rt_padstart; 655 uint32_t rt_padimlen; 656 uint32_t rt_msize; 657 uint32_t rt_flags; 658 uint32_t rt_flags1; 659 uint32_t rt_tlsmodid; 660 /* 661 * END: Exposed to rtld_db - don't move, don't delete 662 */ 663 uint32_t rt_alias; 664 uint32_t rt_fpnode; 665 uint32_t rt_init; 666 uint32_t rt_fini; 667 uint32_t rt_runpath; 668 uint32_t rt_runlist; 669 uint32_t rt_depends; 670 uint32_t rt_callers; 671 uint32_t rt_handles; 672 uint32_t rt_groups; 673 uint32_t rt_etext; 674 uint32_t rt_fct; 675 uint32_t rt_symintp; 676 uint32_t rt_priv; 677 uint32_t rt_list; 678 uint32_t rt_objfltrndx; 679 uint32_t rt_symsfltrcnt; 680 uint32_t rt_symafltrcnt; 681 int32_t rt_mode; 682 int32_t rt_sortval; 683 uint32_t rt_cycgroup; 684 uint32_t rt_stdev; 685 uint32_t rt_stino; 686 uint32_t rt_origname; 687 uint32_t rt_dirsz; 688 Rt_map_copy32 rt_copy; 689 uint32_t rt_auditors; 690 uint32_t rt_audinfo; 691 uint32_t rt_syminfo; 692 uint32_t rt_initarray; 693 uint32_t rt_finiarray; 694 uint32_t rt_preinitarray; 695 uint32_t rt_mmaps; 696 uint32_t rt_mmapcnt; 697 uint32_t rt_initarraysz; 698 uint32_t rt_finiarraysz; 699 uint32_t rt_preinitarraysz; 700 uint32_t rt_dyninfo; 701 uint32_t rt_dyninfocnt; 702 uint32_t rt_relacount; 703 uint32_t rt_idx; 704 uint32_t rt_lazy; 705 uint32_t rt_condvar; 706 uint32_t rt_hwcap; 707 uint32_t rt_sfcap; 708 uint32_t rt_threadid; 709 uint32_t rt_cntl; 710 uint32_t rt_flags2; 711 } Rt_map32; 712 713 #endif /* _SYSCALL32 */ 714 715 /* 716 * Link map state flags. 717 */ 718 /* 719 * BEGIN: Exposed to rtld_db - don't move, don't delete 720 */ 721 #define FLG_RT_ISMAIN 0x00000001 /* object represents main executable */ 722 #define FLG_RT_IMGALLOC 0x00000002 /* image is allocated (not mmap'ed) */ 723 /* 724 * Available for r_debug version >= RTLD_DB_VERSION5 725 */ 726 #define FLG_RT_RELOCED 0x00000004 /* object has been relocated */ 727 /* 728 * END: Exposed to rtld_db - don't move, don't delete 729 */ 730 #define FLG_RT_SETGROUP 0x00000008 /* group establishment required */ 731 #define FLG_RT_HWCAP 0x00000010 /* process $HWCAP expansion */ 732 #define FLG_RT_OBJECT 0x00000020 /* object processing (ie. .o's) */ 733 #define FLG_RT_NEWLOAD 0x00000040 /* object is newly loaded */ 734 #define FLG_RT_NODUMP 0x00000080 /* object can't be dldump(3x)'ed */ 735 #define FLG_RT_DELETE 0x00000100 /* object can be deleted */ 736 #define FLG_RT_ANALYZED 0x00000200 /* object has been analyzed */ 737 #define FLG_RT_INITDONE 0x00000400 /* objects .init has been completed */ 738 #define FLG_RT_TRANS 0x00000800 /* object is acting as a translator */ 739 #define FLG_RT_FIXED 0x00001000 /* image location is fixed */ 740 #define FLG_RT_PRELOAD 0x00002000 /* object was preloaded */ 741 #define FLG_RT_ALTER 0x00004000 /* alternative object used */ 742 #define FLG_RT_LOADFLTR 0x00008000 /* trigger filtee loading */ 743 #define FLG_RT_AUDIT 0x00010000 /* object is an auditor */ 744 #define FLG_RT_MODESET 0x00020000 /* MODE() has been initialized */ 745 #define FLG_RT_ANALZING 0x00040000 /* object is being analyzed */ 746 #define FLG_RT_INITFRST 0x00080000 /* execute .init first */ 747 #define FLG_RT_NOOPEN 0x00100000 /* dlopen() not allowed */ 748 #define FLG_RT_FINICLCT 0x00200000 /* fini has been collected (tsort) */ 749 #define FLG_RT_INITCALL 0x00400000 /* objects .init has been called */ 750 #define FLG_RT_OBJINTPO 0x00800000 /* object is a global interposer */ 751 #define FLG_RT_SYMINTPO 0x01000000 /* object contains symbol interposer */ 752 #define MSK_RT_INTPOSE 0x01800000 /* mask for all interposer */ 753 /* possibilities */ 754 #define FLG_RT_MOVE 0x02000000 /* object needs move operation */ 755 #define FLG_RT_TMPLIST 0x04000000 /* object is part of a temporary list */ 756 #define FLG_RT_REGSYMS 0x08000000 /* object has DT_REGISTER entries */ 757 #define FLG_RT_INITCLCT 0x10000000 /* init has been collected (tsort) */ 758 #define FLG_RT_HANDLE 0x20000000 /* generate a handle for this object */ 759 #define FLG_RT_RELOCING 0x40000000 /* object is being relocated */ 760 761 #define FL1_RT_COPYTOOK 0x00000001 /* copy relocation taken */ 762 #define FL1_RT_RELATIVE 0x00000002 /* relative path expansion required */ 763 #define FL1_RT_CONFSET 0x00000004 /* object was loaded by crle(1) */ 764 #define FL1_RT_NODEFLIB 0x00000008 /* ignore default library search */ 765 #define FL1_RT_ENDFILTE 0x00000010 /* filtee terminates filters search */ 766 #define FL1_RT_DISPREL 0x00000020 /* object has *disp* relocation */ 767 #define FL1_RT_TEXTREL 0x00000040 /* DT_TEXTREL set in object */ 768 #define FL1_RT_INITWAIT 0x00000080 /* threads are waiting on .init */ 769 #define FL1_RT_LDDSTUB 0x00000100 /* identify lddstub */ 770 #define FL1_RT_NOINIFIN 0x00000200 /* no .init or .fini exists */ 771 #define FL1_RT_USED 0x00000400 /* symbol referenced from this object */ 772 #define FL1_RT_SYMBOLIC 0x00000800 /* DF_SYMBOLIC was set - use */ 773 /* symbolic sym resolution */ 774 #define FL1_RT_OBJSFLTR 0x00001000 /* object is acting as a standard */ 775 #define FL1_RT_OBJAFLTR 0x00002000 /* or auxiliary filter */ 776 #define FL1_RT_SYMSFLTR 0x00004000 /* symbol is acting as a standard */ 777 #define FL1_RT_SYMAFLTR 0x00008000 /* or auxiliary filter */ 778 #define MSK_RT_FILTER 0x0000f000 /* mask for all filter possibilities */ 779 780 #define FL1_RT_TLSADD 0x00010000 /* objects TLS has been registered */ 781 #define FL1_RT_TLSSTAT 0x00020000 /* object requires static TLS */ 782 #define FL1_RT_DIRECT 0x00040000 /* object has DIRECT bindings enabled */ 783 #define FL1_RT_GLOBAUD 0x00080000 /* establish global auditing */ 784 785 /* 786 * The following range of bits are reserved to hold LML_TFLG_AUD_ values 787 * (although the definitions themselves aren't used anywhere). 788 */ 789 #define FL1_AUD_RS_STR 0x00100000 /* RESERVATION start for AU flags */ 790 #define FL1_AUD_RS_END 0x80000000 /* RESERVATION end for AU flags */ 791 792 #define FL2_RT_DTFLAGS 0x00000001 /* DT_FLAGS element exists */ 793 794 /* 795 * Flags for the tls_modactivity() routine 796 */ 797 #define TM_FLG_MODADD 0x01 /* call tls_modadd() interface */ 798 #define TM_FLG_MODREM 0x02 /* call tls_modrem() interface */ 799 800 /* 801 * Macros for getting to link_map data. 802 */ 803 #define ADDR(X) ((X)->rt_public.l_addr) 804 #define NAME(X) ((X)->rt_public.l_name) 805 #define DYN(X) ((X)->rt_public.l_ld) 806 #define NEXT(X) ((X)->rt_public.l_next) 807 #define PREV(X) ((X)->rt_public.l_prev) 808 #define REFNAME(X) ((X)->rt_public.l_refname) 809 810 /* 811 * An Rt_map starts with a Link_map, followed by other information. 812 * ld.so.1 allocates Rt_map structures, and then casts them to Link_map, 813 * and back, depending on context. 814 * 815 * On some platforms, Rt_map can have a higher alignment requirement 816 * than Link_map. On such platforms, the cast from Link_map to Rt_map will 817 * draw an E_BAD_PTR_CAST_ALIGN warning from lint. Since we allocate 818 * the memory as the higher alignment Rt_map, we know that this is a safe 819 * conversion. The LINKMAP_TO_RTMAP macro is used to handle the conversion 820 * in a manner that satisfies lint. 821 */ 822 #ifdef lint 823 #define LINKMAP_TO_RTMAP(X) (Rt_map *)(void *)(X) 824 #else 825 #define LINKMAP_TO_RTMAP(X) (Rt_map *)(X) 826 #endif 827 828 /* 829 * Convenience macros for the common case of using 830 * NEXT()/PREV() and casting the result to (Rt_map *) 831 */ 832 #define NEXT_RT_MAP(X) LINKMAP_TO_RTMAP(NEXT(X)) 833 #define PREV_RT_MAP(X) LINKMAP_TO_RTMAP(PREV(X)) 834 835 /* 836 * Macros for getting to linker private data. 837 */ 838 #define PATHNAME(X) ((X)->rt_pathname) 839 #define PADSTART(X) ((X)->rt_padstart) 840 #define PADIMLEN(X) ((X)->rt_padimlen) 841 #define MSIZE(X) ((X)->rt_msize) 842 #define FLAGS(X) ((X)->rt_flags) 843 #define FLAGS1(X) ((X)->rt_flags1) 844 #define FLAGS2(X) ((X)->rt_flags2) 845 #define TLSMODID(X) ((X)->rt_tlsmodid) 846 847 #define ALIAS(X) ((X)->rt_alias) 848 #define FPNODE(X) ((X)->rt_fpnode) 849 #define INIT(X) ((X)->rt_init) 850 #define FINI(X) ((X)->rt_fini) 851 #define RPATH(X) ((X)->rt_runpath) 852 #define RLIST(X) ((X)->rt_runlist) 853 #define DEPENDS(X) ((X)->rt_depends) 854 #define CALLERS(X) ((X)->rt_callers) 855 #define HANDLES(X) ((X)->rt_handles) 856 #define GROUPS(X) ((X)->rt_groups) 857 #define ETEXT(X) ((X)->rt_etext) 858 #define FCT(X) ((X)->rt_fct) 859 #define SYMINTP(X) ((X)->rt_symintp) 860 #define LIST(X) ((X)->rt_list) 861 #define OBJFLTRNDX(X) ((X)->rt_objfltrndx) 862 #define SYMSFLTRCNT(X) ((X)->rt_symsfltrcnt) 863 #define SYMAFLTRCNT(X) ((X)->rt_symafltrcnt) 864 #define MODE(X) ((X)->rt_mode) 865 #define SORTVAL(X) ((X)->rt_sortval) 866 #define CYCGROUP(X) ((X)->rt_cycgroup) 867 #define STDEV(X) ((X)->rt_stdev) 868 #define STINO(X) ((X)->rt_stino) 869 #define ORIGNAME(X) ((X)->rt_origname) 870 #define DIRSZ(X) ((X)->rt_dirsz) 871 #define COPY_R(X) ((X)->rt_copy.rtc_r) 872 #define COPY_S(X) ((X)->rt_copy.rtc_s) 873 #define AUDITORS(X) ((X)->rt_auditors) 874 #define AUDINFO(X) ((X)->rt_audinfo) 875 #define SYMINFO(X) ((X)->rt_syminfo) 876 #define INITARRAY(X) ((X)->rt_initarray) 877 #define FINIARRAY(X) ((X)->rt_finiarray) 878 #define PREINITARRAY(X) ((X)->rt_preinitarray) 879 #define MMAPS(X) ((X)->rt_mmaps) 880 #define MMAPCNT(X) ((X)->rt_mmapcnt) 881 #define INITARRAYSZ(X) ((X)->rt_initarraysz) 882 #define FINIARRAYSZ(X) ((X)->rt_finiarraysz) 883 #define PREINITARRAYSZ(X) ((X)->rt_preinitarraysz) 884 #define DYNINFO(X) ((X)->rt_dyninfo) 885 #define DYNINFOCNT(X) ((X)->rt_dyninfocnt) 886 #define RELACOUNT(X) ((X)->rt_relacount) 887 #define IDX(X) ((X)->rt_idx) 888 #define LAZY(X) ((X)->rt_lazy) 889 #define CONDVAR(X) ((X)->rt_condvar) 890 #define CNTL(X) ((X)->rt_cntl) 891 #define HWCAP(X) ((X)->rt_hwcap) 892 #define SFCAP(X) ((X)->rt_sfcap) 893 #define THREADID(X) ((X)->rt_threadid) 894 895 /* 896 * Flags for tsorting. 897 */ 898 #define RT_SORT_FWD 0x01 /* topological sort (.fini) */ 899 #define RT_SORT_REV 0x02 /* reverse topological sort (.init) */ 900 #define RT_SORT_DELETE 0x10 /* process FLG_RT_DELNEED objects */ 901 /* only (called via dlclose()) */ 902 #define RT_SORT_INTPOSE 0x20 /* process interposer objects */ 903 904 /* 905 * Flags for lookup_sym (and hence find_sym) routines. 906 */ 907 #define LKUP_DEFT 0x0000 /* simple lookup request */ 908 #define LKUP_SPEC 0x0001 /* special ELF lookup (allows address */ 909 /* resolutions to plt[] entries) */ 910 #define LKUP_LDOT 0x0002 /* indicates the original A_OUT */ 911 /* symbol had a leading `.' */ 912 #define LKUP_FIRST 0x0004 /* lookup symbol in first link map */ 913 /* only */ 914 #define LKUP_COPY 0x0008 /* lookup symbol for a COPY reloc, do */ 915 /* not bind to symbol at head */ 916 #define LKUP_STDRELOC 0x0010 /* lookup originates from a standard */ 917 /* relocation (elf_reloc()) */ 918 #define LKUP_SELF 0x0020 /* lookup symbol in ourself - undef */ 919 /* is valid */ 920 #define LKUP_WEAK 0x0040 /* relocation reference is weak */ 921 #define LKUP_NEXT 0x0080 /* request originates from RTLD_NEXT */ 922 #define LKUP_NODESCENT 0x0100 /* don't descend through dependencies */ 923 #define LKUP_NOFALLBACK 0x0200 /* don't fall back to loading */ 924 /* pending lazy dependencies */ 925 #define LKUP_DIRECT 0x0400 /* direct binding request */ 926 #define LKUP_SYMNDX 0x0800 /* establish symbol index */ 927 #define LKUP_SINGLETON 0x1000 /* search for a singleton symbol */ 928 #define LKUP_STANDARD 0x2000 /* standard lookup - originated from */ 929 /* head link-map element */ 930 #define LKUP_WORLD 0x4000 /* ensure world lookup */ 931 932 /* 933 * For the runtime linker to perform a symbol search, a number of data items 934 * related to the search are required. An Slookup data structure is used to 935 * convey this data to lookup_sym(), and in special cases, to other core 936 * routines that provide the implementation details for lookup_sym() 937 * 938 * The symbol name (sl_name), the caller (sl_cmap), and the link-map from which 939 * to start the search (sl_imap) are fundamental to the symbol search. The 940 * initial search link-map might get modified by the core routines that provide 941 * the implementation details for lookup_sym(). This modification accommodates 942 * requirements such as processing a handle, direct binding and interposition. 943 * The association between the caller and the potential destination also 944 * determines whether the destination is a candidate to search. 945 * 946 * The lookup identifier (sl_id) is used to identify a runtime linker operation. 947 * Within this operation, any lazy loads that fail are not re-examined. This 948 * technique keeps the overhead of processing a failed lazy load to a minimum. 949 * 950 * Symbol searches that originate from a relocation record are accompanied by 951 * the relocation index (sl_rsymndx), the symbol reference (sl_rsym) and 952 * possibly the relocation type (sl_rtype). This data provides for determining 953 * lazy loading, direct binding, and special symbol processing requirements 954 * such as copy relocations and singleton lookup. 955 * 956 * The symbols hash value is computed by lookup_sym, and propagated throughout 957 * the search engine. Note, occasionally the Slookup data is passed to a core 958 * routine that provides the implementation details for lookup_sym(), ie. 959 * elf_find_sym(), in which case the caller must initialize the hash value. 960 * 961 * The symbols binding information is established by lookup_sym() when the 962 * symbols relocation type is supplied. Weak bindings allow relocations to 963 * be set to zero should a symbol lookup fail. 964 * 965 * The flags allow the caller to control aspects of the search, including the 966 * interpretation of copy relocations, etc. Note, a number of flag settings 967 * are established in lookup_sym() from attributes of the symbol reference. 968 */ 969 typedef struct { 970 const char *sl_name; /* symbol name */ 971 Rt_map *sl_cmap; /* callers link-map */ 972 Rt_map *sl_imap; /* initial link-map to search */ 973 ulong_t sl_id; /* identifier for this lookup */ 974 ulong_t sl_hash; /* symbol hash value */ 975 ulong_t sl_rsymndx; /* referencing reloc symndx */ 976 Sym *sl_rsym; /* referencing symbol */ 977 uchar_t sl_rtype; /* relocation type associate with */ 978 /* symbol */ 979 uchar_t sl_bind; /* symbols binding (returned) */ 980 uint_t sl_flags; /* lookup flags */ 981 } Slookup; 982 983 #define SLOOKUP_INIT(sl, name, cmap, imap, id, hash, rsymndx, rsym, rtype, \ 984 flags) \ 985 (void) (sl.sl_name = (name), sl.sl_cmap = (cmap), sl.sl_imap = (imap), \ 986 sl.sl_id = (id), sl.sl_hash = (hash), sl.sl_rsymndx = (rsymndx), \ 987 sl.sl_rsym = (rsym), sl.sl_rtype = (rtype), sl.sl_bind = 0, \ 988 sl.sl_flags = (flags)) 989 990 /* 991 * Define a number of .plt lookup outcomes, for use in binding diagnostics. 992 */ 993 typedef enum { 994 PLT_T_NONE = 0, 995 PLT_T_21D, 996 PLT_T_24D, 997 PLT_T_U32, 998 PLT_T_U44, 999 PLT_T_FULL, 1000 PLT_T_FAR, 1001 PLT_T_NUM /* Must be last */ 1002 } Pltbindtype; 1003 1004 /* 1005 * Prototypes. 1006 */ 1007 extern ulong_t ld_entry_cnt; /* counter bumped on each entry to */ 1008 /* ld.so.1. */ 1009 extern Lm_list lml_main; /* main's link map list */ 1010 extern Lm_list lml_rtld; /* rtld's link map list */ 1011 extern Lm_list *lml_list[]; 1012 1013 extern Pltbindtype elf_plt_write(uintptr_t, uintptr_t, void *, uintptr_t, 1014 Xword); 1015 extern Rt_map *is_so_loaded(Lm_list *, const char *, int *); 1016 extern Sym *lookup_sym(Slookup *, Rt_map **, uint_t *, int *); 1017 extern int rt_dldump(Rt_map *, const char *, int, Addr); 1018 1019 #ifdef __cplusplus 1020 } 1021 #endif 1022 1023 #endif /* _RTLD_H */ 1024