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