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) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * Object file dependent suport for ELF objects. 28 */ 29 30 #include <sys/mman.h> 31 #include <stdio.h> 32 #include <unistd.h> 33 #include <libelf.h> 34 #include <string.h> 35 #include <dlfcn.h> 36 #include <debug.h> 37 #include <libld.h> 38 #include "_rtld.h" 39 #include "_audit.h" 40 #include "_elf.h" 41 42 static Rt_map *olmp = NULL; 43 static Alist *mpalp = NULL; 44 45 static Ehdr dehdr = { { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, 46 M_CLASS, M_DATA }, 0, M_MACH, EV_CURRENT }; 47 48 /* 49 * Process a relocatable object. The static object link map pointer is used as 50 * a flag to determine whether a concatenation is already in progress (ie. an 51 * LD_PRELOAD may specify a list of objects). The link map returned simply 52 * specifies an `object' flag which the caller can interpret and thus call 53 * elf_obj_fini() to complete the concatenation. 54 */ 55 static Rt_map * 56 elf_obj_init(Lm_list *lml, Aliste lmco, const char *oname) 57 { 58 Ofl_desc *ofl; 59 const char *name; 60 61 /* 62 * Allocate the name of this object, as the original name may be 63 * associated with a data buffer that can be reused to load the 64 * dependencies needed to processes this object. 65 */ 66 if ((name = stravl_insert(oname, 0, 0, 0)) == NULL) 67 return (NULL); 68 69 /* 70 * Initialize an output file descriptor and the entrance criteria. 71 */ 72 if ((ofl = calloc(1, sizeof (Ofl_desc))) == NULL) 73 return (NULL); 74 75 ofl->ofl_dehdr = &dehdr; 76 77 ofl->ofl_flags = (FLG_OF_DYNAMIC | FLG_OF_SHAROBJ | FLG_OF_STRIP); 78 ofl->ofl_flags1 = (FLG_OF1_RELDYN | FLG_OF1_TEXTOFF | FLG_OF1_MEMORY); 79 ofl->ofl_lml = lml; 80 81 /* 82 * As ent_setup() will effectively lazy load the necessary support 83 * libraries, make sure ld.so.1 is initialized for plt relocations. 84 * Then configure libld.so to process objects of the desired target 85 * type (this is the first call to libld.so, which will effectively 86 * lazyload it). 87 */ 88 if ((elf_rtld_load() == 0) || (ld_init_target(lml, M_MACH) != 0)) { 89 free(ofl); 90 return (NULL); 91 } 92 93 /* 94 * Obtain a generic set of entrance criteria, and generate a link map 95 * place holder and use the ELFPRV() element to maintain the output 96 * file descriptor. 97 */ 98 if ((ld_ent_setup(ofl, syspagsz) == S_ERROR) || 99 ((olmp = calloc(1, sizeof (*olmp))) == NULL)) { 100 free(ofl); 101 return (NULL); 102 } 103 104 DBG_CALL(Dbg_file_elf(lml, name, 0, 0, lml->lm_lmidstr, lmco)); 105 FLAGS(olmp) |= FLG_RT_OBJECT; 106 ELFPRV(olmp) = (void *)ofl; 107 108 /* 109 * Initialize string tables. 110 */ 111 if (ld_init_strings(ofl) == S_ERROR) { 112 free(ofl); 113 free(olmp); 114 olmp = NULL; 115 return (NULL); 116 } 117 118 /* 119 * Assign the output file name to be the initial object that got us 120 * here. This name is being used for diagnostic purposes only as we 121 * don't actually generate an output file unless debugging is enabled. 122 */ 123 ofl->ofl_name = name; 124 NAME(olmp) = (char *)name; 125 LIST(olmp) = lml; 126 127 lm_append(lml, lmco, olmp); 128 return (olmp); 129 } 130 131 /* 132 * Define a structure to retain the mapping information of the original 133 * relocatable object. Typically, mmapobj(2) maps a relocatable object into one 134 * mapping. However, if padding has been enabled by a debugger, then additional 135 * padding segments may have been added. elf_obj_file() needs to know which 136 * segment is the relocatable objects data, and retain the initial segment and 137 * the associated segment number for unmapping this object later (see 138 * elf_obj_fini()). Note, even if padding is enabled, the final shared object 139 * that is created by the link-editor for this relocatable object will have no 140 * associated padding, as ld(1) has no capabilities to provide padding. 141 */ 142 typedef struct { 143 mmapobj_result_t *md_mpp; 144 uint_t md_mnum; 145 } Mmap_desc; 146 147 /* 148 * Initial processing of a relocatable object. If this is the first object 149 * encountered we need to initialize some structures, then simply call the 150 * link-edit functionality to provide the initial processing of the file (ie. 151 * reads in sections and symbols, performs symbol resolution if more that one 152 * object file have been specified, and assigns input sections to output 153 * sections). 154 */ 155 Rt_map * 156 elf_obj_file(Lm_list *lml, Aliste lmco, Rt_map *clmp, const char *name, 157 mmapobj_result_t *hmpp, mmapobj_result_t *mpp, uint_t mnum) 158 { 159 Rej_desc rej; 160 Mmap_desc md; 161 162 /* 163 * If this is the first relocatable object (LD_PRELOAD could provide a 164 * list of objects), initialize an input file descriptor and a link map. 165 */ 166 if ((olmp == NULL) && ((olmp = elf_obj_init(lml, lmco, name)) == NULL)) 167 return (NULL); 168 169 DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 170 171 /* 172 * Keep track of the input image, as this must be free'd after all ELF 173 * processing is completed. 174 */ 175 md.md_mpp = mpp; 176 md.md_mnum = mnum; 177 if (alist_append(&mpalp, &md, sizeof (Mmap_desc), 178 AL_CNT_MPOBJS) == NULL) { 179 remove_so(lml, olmp, clmp); 180 return (NULL); 181 } 182 183 /* 184 * Pass the object mapping to the link-editor to commence processing the 185 * file. 186 */ 187 if (ld_process_mem(name, name, hmpp->mr_addr, hmpp->mr_msize, 188 (Ofl_desc *)ELFPRV(olmp), &rej) == (Ifl_desc *)S_ERROR) { 189 remove_so(lml, olmp, clmp); 190 return (NULL); 191 } 192 193 return (olmp); 194 } 195 196 /* 197 * Ensure any platform or machine capability names are valid. 198 */ 199 inline static int 200 check_plat_names(Syscapset *scapset, Alist *caps, Rej_desc *rej) 201 { 202 Capstr *capstr; 203 Aliste idx; 204 205 for (ALIST_TRAVERSE(caps, idx, capstr)) { 206 if (platcap_check(scapset, capstr->cs_str, rej) == 1) 207 return (1); 208 } 209 return (0); 210 } 211 212 inline static int 213 check_mach_names(Syscapset *scapset, Alist *caps, Rej_desc *rej) 214 { 215 Capstr *capstr; 216 Aliste idx; 217 218 for (ALIST_TRAVERSE(caps, idx, capstr)) { 219 if (machcap_check(scapset, capstr->cs_str, rej) == 1) 220 return (1); 221 } 222 return (0); 223 } 224 225 /* 226 * Finish relocatable object processing. Having already initially processed one 227 * or more objects, complete the generation of a shared object image by calling 228 * the appropriate link-edit functionality (refer to sgs/ld/common/main.c). 229 */ 230 Rt_map * 231 elf_obj_fini(Lm_list *lml, Rt_map *lmp, Rt_map *clmp, int *in_nfavl) 232 { 233 Ofl_desc *ofl = (Ofl_desc *)ELFPRV(lmp); 234 Rt_map *nlmp, *tlmp; 235 Ehdr *ehdr; 236 Phdr *phdr; 237 mmapobj_result_t *mpp, *hmpp; 238 uint_t phnum; 239 int mnum; 240 Lm_cntl *lmc; 241 Aliste idx1; 242 Mmap_desc *mdp; 243 Fdesc fd = { 0 }; 244 Grp_hdl *ghp; 245 Rej_desc rej = { 0 }; 246 Syscapset *scapset; 247 elfcap_mask_t omsk; 248 Alist *oalp; 249 250 DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD)); 251 252 if (ld_reloc_init(ofl) == S_ERROR) 253 return (NULL); 254 if (ld_sym_validate(ofl) == S_ERROR) 255 return (NULL); 256 257 /* 258 * At this point, all input section processing is complete. If any 259 * capabilities have been established, ensure that they are appropriate 260 * for this system. 261 */ 262 if (pnavl_recorded(&capavl, ofl->ofl_name, 0, NULL)) 263 scapset = alt_scapset; 264 else 265 scapset = org_scapset; 266 267 if ((((omsk = ofl->ofl_ocapset.oc_hw_1.cm_val) != 0) && 268 (hwcap1_check(scapset, omsk, &rej) == 0)) || 269 (((omsk = ofl->ofl_ocapset.oc_sf_1.cm_val) != 0) && 270 (sfcap1_check(scapset, omsk, &rej) == 0)) || 271 (((omsk = ofl->ofl_ocapset.oc_hw_2.cm_val) != 0) && 272 (hwcap2_check(scapset, omsk, &rej) == 0)) || 273 (((oalp = ofl->ofl_ocapset.oc_plat.cl_val) != NULL) && 274 (check_plat_names(scapset, oalp, &rej) == 0)) || 275 (((oalp = ofl->ofl_ocapset.oc_mach.cl_val) != NULL) && 276 (check_mach_names(scapset, oalp, &rej) == 0))) { 277 if ((lml_main.lm_flags & LML_FLG_TRC_LDDSTUB) && lmp && 278 (FLAGS1(lmp) & FL1_RT_LDDSTUB) && (NEXT(lmp) == NULL)) { 279 /* LINTED */ 280 (void) printf(MSG_INTL(ldd_reject[rej.rej_type]), 281 ofl->ofl_name, rej.rej_str); 282 } 283 return (NULL); 284 } 285 286 /* 287 * Finish creating the output file. 288 */ 289 if (ld_make_sections(ofl) == S_ERROR) 290 return (NULL); 291 if (ld_create_outfile(ofl) == S_ERROR) 292 return (NULL); 293 if (ld_update_outfile(ofl) == S_ERROR) 294 return (NULL); 295 if (ld_reloc_process(ofl) == S_ERROR) 296 return (NULL); 297 298 /* 299 * At this point we have a memory image of the shared object. The link 300 * editor would normally simply write this to the required output file. 301 * If we're debugging generate a standard temporary output file. 302 */ 303 DBG_CALL(Dbg_file_output(ofl)); 304 305 /* 306 * Allocate a mapping array to retain mapped segment information. 307 */ 308 ehdr = ofl->ofl_nehdr; 309 phdr = ofl->ofl_phdr; 310 311 if ((mpp = hmpp = calloc(ehdr->e_phnum, 312 sizeof (mmapobj_result_t))) == NULL) 313 return (NULL); 314 for (mnum = 0, phnum = 0; phnum < ehdr->e_phnum; phnum++) { 315 if (phdr[phnum].p_type != PT_LOAD) 316 continue; 317 318 mpp[mnum].mr_addr = (caddr_t)((uintptr_t)phdr[phnum].p_vaddr + 319 (uintptr_t)ehdr); 320 mpp[mnum].mr_msize = phdr[phnum].p_memsz; 321 mpp[mnum].mr_fsize = phdr[phnum].p_filesz; 322 mpp[mnum].mr_prot = (PROT_READ | PROT_WRITE | PROT_EXEC); 323 mnum++; 324 } 325 326 /* 327 * Generate a new link map representing the memory image created. 328 */ 329 fd.fd_nname = ofl->ofl_name; 330 if ((nlmp = elf_new_lmp(lml, CNTL(olmp), &fd, (Addr)hmpp->mr_addr, 331 ofl->ofl_size, NULL, clmp, in_nfavl)) == NULL) 332 return (NULL); 333 334 MMAPS(nlmp) = hmpp; 335 MMAPCNT(nlmp) = mnum; 336 PADSTART(nlmp) = (ulong_t)hmpp->mr_addr; 337 PADIMLEN(nlmp) = mpp->mr_addr + mpp->mr_msize - hmpp->mr_addr; 338 339 /* 340 * Replace the original (temporary) link map with the new link map. 341 */ 342 /* LINTED */ 343 lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(nlmp)); 344 lml->lm_obj--; 345 346 if ((tlmp = PREV_RT_MAP(nlmp)) == olmp) 347 tlmp = nlmp; 348 349 if (PREV(olmp)) { 350 NEXT(PREV_RT_MAP(olmp)) = (Link_map *)nlmp; 351 PREV(nlmp) = PREV(olmp); 352 } else { 353 PREV(nlmp) = NULL; 354 lmc->lc_head = nlmp; 355 if (CNTL(nlmp) == ALIST_OFF_DATA) 356 lml->lm_head = nlmp; 357 } 358 359 if (NEXT(olmp) != (Link_map *)nlmp) { 360 NEXT(nlmp) = NEXT(olmp); 361 PREV(NEXT_RT_MAP(olmp)) = (Link_map *)nlmp; 362 } 363 364 NEXT(tlmp) = NULL; 365 366 lmc->lc_tail = tlmp; 367 if (CNTL(nlmp) == ALIST_OFF_DATA) 368 lml->lm_tail = tlmp; 369 370 HANDLES(nlmp) = HANDLES(olmp); 371 GROUPS(nlmp) = GROUPS(olmp); 372 STDEV(nlmp) = STDEV(olmp); 373 STINO(nlmp) = STINO(olmp); 374 375 FLAGS(nlmp) |= ((FLAGS(olmp) & ~FLG_RT_OBJECT) | FLG_RT_IMGALLOC); 376 FLAGS1(nlmp) |= FLAGS1(olmp); 377 MODE(nlmp) |= MODE(olmp); 378 379 NAME(nlmp) = NAME(olmp); 380 381 /* 382 * Reassign any original handles to the new link-map. 383 */ 384 for (APLIST_TRAVERSE(HANDLES(nlmp), idx1, ghp)) { 385 Grp_desc *gdp; 386 Aliste idx2; 387 388 ghp->gh_ownlmp = nlmp; 389 390 for (ALIST_TRAVERSE(ghp->gh_depends, idx2, gdp)) { 391 if (gdp->gd_depend == olmp) { 392 gdp->gd_depend = nlmp; 393 break; 394 } 395 } 396 } 397 398 ld_ofl_cleanup(ofl); 399 free(ELFPRV(olmp)); 400 free(olmp); 401 olmp = 0; 402 403 /* 404 * Unmap the original relocatable object. 405 */ 406 for (ALIST_TRAVERSE(mpalp, idx1, mdp)) { 407 unmap_obj(mdp->md_mpp, mdp->md_mnum); 408 free(mdp->md_mpp); 409 } 410 free(mpalp); 411 mpalp = NULL; 412 413 /* 414 * Now that we've allocated our permanent link map structure, expand the 415 * PATHNAME() and insert this path name into the FullPathNode AVL tree. 416 */ 417 (void) fullpath(nlmp, 0); 418 if (fpavl_insert(lml, nlmp, PATHNAME(nlmp), 0) == 0) 419 return (NULL); 420 421 /* 422 * If we're being audited tell the audit library of the file we've just 423 * opened. 424 */ 425 if ((lml->lm_tflags | AFLAGS(nlmp)) & LML_TFLG_AUD_MASK) { 426 if (audit_objopen(nlmp, nlmp) == 0) 427 return (NULL); 428 } 429 return (nlmp); 430 } 431